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;
 }
}