Struts2学习笔记（5）--拦截器

Struts2学习笔记（5）--拦截器

 

Interceptor （底层通过动态代理实现）

1.建包 ...interceptor

自定义拦截器

第一种方式：
实现xwork包下的Interceptor接口

init() {} 初始化时调用
destroy() {} 销毁时调用

class MyInterceptor implements Interceptor {

 private String hello;
 //setter...getter...

 public void init() {
  System.out.println("init()...");
  System.out.println( hello );
 }
 public void destroy() {
  System.out.println("destroy()...");
 }

 public String intercept(ActionInvocation invocation) throws Exception {

  System.out.println("intercept()1...");

  //拦截器有拦截器站
  //invoke()将判断是否还有下一个拦截器，有就执行下一个拦截器，没有则开始执行被拦截的类
  String result = invocation.invoke();
  System.out.println("finish1...");
  return result;
 }

---------------------------------
第二种方式：

1.继承AbstractInterceptor 

  该类实现了Interceptor接口，并且空实现了init()和destroy()方法

public class MyInterceptor extends AbstractInterceptor {

 public String intercept(ActionInvocation invocation) throws Exception {

  System.out.println("intercept()2...");
  String result = invocation.invoke();
  System.out.println("finish2...");
  return result;
 }
}

----------------------------

2. struts.xml 配置

<struts>
 struts采用包名把不同的action区分开，相同类似功能的放在一个包里
 包之间是可以有继承关系的，
 extends="struts-default" 相当于把struts2-core-2.0.11.jar下的struts-default.xml的东西给继承过来了
 其中包括N多的拦截器
 
 <package name="包名" extends="struts-default">
  
  定义拦截器
  <interceptors>

   定义多个拦截器时可以包含多个<interceptor>
   <interceptor name="myInterceptor" class="com....interceptor.MyInterceptor"/>

   <interceptor name="myInterceptor2" class="...">

    为拦截器配置参数
    name对应到拦截器类中的字段属性，该属性需要有set、get方法
    当启动拦截器时这项配置将会吧world作为值赋给私有成员hello
    也可以在引用拦截器时改变这个值
    <param name="hello">world</param>
   </interceptor>
  </interceptors>

  声明拦截器栈
  <interceptors-stack name="myInterceptorStack">

   引用拦截器
   <interceptor-ref name="myInterceptor" />
   <interceptor-ref name="myInterceptor2" />

   拦截器栈中可以包含拦截器栈
   <interceptor-ref name="defaultStack" />   defaultStack---Struts2默认的拦截器
   
  </interceptors-stack>

  <interceptors-stack name="myInterceptorStack2">   
   <interceptor-ref name="myInterceptor" />

   引用拦截器栈
   <interceptor-ref name="myInterceptorStack" />     
  </interceptors-stack>

  <action ...>
   <result name="...">...</result>
   ...

   使用拦截器 action被请求一次，拦截器的intercept()就被执行一次
   引用拦截器
   <interceptor-ref name="myInterceptor" />

   <interceptor-ref name="myInterceptor2" >

    使用拦截器时对hello赋值，会改变引用时的赋值
    <param name="hello">welcome</param>
   </interceptor-ref>

   <interceptor-ref name="defaultStack" />  手动导入Struts2默认的拦截器栈
  </action>

  定义默认的拦截器栈
  他会自动的把默认的拦截器附加到每一个Action中去
  在一个包中，可以有0或1个默认的拦截器栈
  如果在一个<action>中手动的指定一个拦截器，默认的拦截器就不会再自动的加到这个action里
  只能通过手工的方式再导入一下
  <default-interceptor-ref name="defaultStack" />
 </package>
</struts>  

 

=======================================
如果调用多个拦截器，执行顺序是怎样的？

如：

<interceptors>
 <interceptor name="myInterceptor" class="..."></interceptor>
 <interceptor name="myInterceptor2" class="..."></interceptor>
</interceptors>

<interceptors-stack name="myInterceptorStack"> 

 执行顺序 按 配置的顺序 
 <interceptor-ref name="myInterceptor" />
 <interceptor-ref name="myInterceptor2" />
</interceptors-stack>

注：拦截器会在调用invoke()方法调用之前和之后都会执行

   拦截器1                          1 中invoke方法前的语句
     |_________拦截器2              2 中invoke方法后的语句
                     |__________
                                    |
                                 invoke()   执行invoke()方法
                      __________|
                     |
      ________拦截器2               2 中invoke方法后的语句
     |
   拦截器1                          1 中invoke方法后的语句

 

==================================================
第三中方式：指定拦截的方法

如果拦截器没有做任何配合话，它会拦截所有的逻辑执行方法

如果<action>中method="execute" 指定了方法，它便只拦截execute方法

还可以通过方法过滤拦截器来指定拦截或不拦截的方法

--------------------------------------------------
继承MethodFilterInterceptor

public class MyInterceptor3 extends MethodFilterInterceptor {

 @Override
 public void init() {
  System.out.println("init3");
 }

 //intercept()已经实现好了，不用去管他
 //需要重写一下doIntercept
 @Override
 public String doIntercept(ActionInvocation invocation) throws Exception {

  System.out.println("intercept()3...");
  String result = invocation.invoke();
  System.out.println("finish3...");
  return result;
 }
}

---------------------------------------------------
MethodFilterInterceptor中包含两个protected的属性

 Set includeMethods : 包含谁
 Set excludeMethods : 排除谁

<interceptors>
 <interceptor name="myInterceptor3" class="..."></interceptor>
</interceptors>

<action ...>
 <result ...>...</result>
 ...
 
 <interceptor-ref name="myInterceptor3" >

  包含                         要拦截方法 多个用逗号分开
  <param name="includeMethods">execute,test</param>
  
  排除                         不拦截的方法 多个用逗号分开
  <param name="excludeMethods">execute</param>
 </interceptor-ref>
 <interceptor-ref name="defaulteStack" />

</action>

注：

如果 既包含includeMethod和excludeMethod，includeMethod一定会被拦截不管是否以把它排除

 

================
     补充
================

-------------------------------
      Java的过滤器 Filer:
-------------------------------

3个方法：
init( FilterConfig filterConfig ) {} 初始化时调用
destroy() {}  过滤器销毁时调用
                                                            过滤器链
doFilter( ServletRequest request, ServletResponse response, FilterChain chain ) {}

 

 

-------------------------------
       Strust2的监听器
-------------------------------
PreResultListener接口
  void beforeResult(ActionInvocation invocation, String resultCode) {}

监听的点是当你执行完execute()并返回到显示页面之前，beforeResult()方法被执行

--------------

1.
建立包：listener

2.
建立类：MyListener 继承 PreResultListener

3.
重写beforeResult方法

public class MyListener implements PreResultListener {

 public void beforeResult(ActionInvocation invocation, String resultCode) {
  
  // resultCode为 action中业务逻辑方法的返回值
  System.out.println("result=" + resultCode);
 }

}

4.
把监听器注册到拦截器中

public class MyInterceptor3 extends MethodFilterInterceptor {

 @Override
 public void init() {
  System.out.println("init3");
 }

 @Override
 public String doIntercept(ActionInvocation invocation) throws Exception {

  //注册自己定义的监听器
  invocation.addPreResultListener( new MyListener() );

  System.out.println("intercept()3...");
  String result = invocation.invoke();
  System.out.println("finish3...");
  return result;
 }
}