struts2 拦截器详解

拦截器，用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。
    拦截器是AOP（Aspect-Oriented Programming 面向方面编程）中的一种实现策略。
    1 用代理模式与动态代理编写拦截器
      
       所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，
       然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。
       当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，
       在生成它的实例时你必须提供一个handler，由它接管实际的工作
        那么如何实现动态代理呢
        1 写一个动态代理，implements InvocationHandler接口，实现方法
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                  
                   method.invoke(sub,args);
                return null;
                }
        2 调用 ，
        真实实现类名 xxx = new 真实实现类名(); // 在这里指定被代理类
        InvocationHandler ds = new DynamicSubject(xxx); // 初始化代理类
        接口  接口变量= (接口) Proxy.newProxyInstance(xxx.getClass().getClassLoader(), xxx.getClass().getInterfaces(), ds);
                       接口变量.方法
          
               /**
         * 从以上可以看出,动态代理可以任意指定被代理的类,即真实对象类,而代理模式则无法实现该功能，
         * 因为他把真实对象的写死在代理类里,如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是
         * 实际使用时，一个真实角色或其接口必须对应一个代理角色，如果大量使用会导致类的急剧膨胀
         */

      
    2  struts2拦截器
      解压strut2的核心包，根目录下struts-default.xml中有struts2的拦截器配置
    

       拦截器几乎完成了Struts2框架70%的工作，包括解析请求参数、将请求参数赋值给Action属性、执行数据校验、
       文件上传……，Struts2设计的灵巧性，更大程度地得益于拦截器设计，当需要扩展Struts2功能时，只需要提供对应拦截器，
       并将它配置在Struts2容器中即可；如果不需要该功能时，也只需要取消该拦截器的配置即可。
       这种可插拔式的设计，正是软件设计领域一直孜孜以求的目标。
    实际上，Struts2的精髓就在于拦截器，掌握了Struts2的拦截器机制，你就可以说精通了Struts2。
    从某个角度来看，我们可以把Struts2框架理解成一个空壳，而这些拦截器像一个一个抽屉，随时可以
    插进入，也可以拔出来——这是软件产品一直追求的目标。
    如果你喜欢，你可以把Struts2的全部插件拔出，那么Struts2就成了一个空容器——
    而这种空，正是 Struts2的魅力，你可以把任何自己想要的东西填入进去，甚至包括自己完全实现这个框架。

    另一方面，因为Struts2的插件机制,Struts2提供了无限扩展的可能性，你可以把自己想要的任何
    东西做成插件，然后填入Struts2——这样的结果是：一个企业，一个团队，可以把自己业务相关的东西
    做成插件，随时随地地复用。
    也就是说：如果你想要，你可以把Struts2改造成属于自己的框架。

    当然，Struts2也内建了大量的拦截器，这些拦截器以name-class对的形式配置在struts-default. xml文件中，其中name是拦截器的名字，就是以后使用该拦截器的唯一标识；class则指定了该拦截器的实现类，如果我们定义的package继承了Struts2的默认struts-default包，则可以自由使用下面定义的拦截器，否则必须自己定义这些拦截器。
    下面是Struts2内建拦截器的简要介绍：
    alias：实现在不同请求中相似参数别名的转换。
    autowiring：这是个自动装配的拦截器，主要用于当Struts2和Spring整合时，Struts2可以使用自动装配的方式来访问Spring容器中的Bean。
    chain：构建一个Action链，使当前Action可以访问前一个Action的属性，一般和<result type="chain" .../>一起使用。
    conversionError：这是一个负责处理类型转换错误的拦截器，它负责将类型转换错误从ActionContext中取出，并转换成Action的FieldError错误。
    createSession：该拦截器负责创建一个HttpSession对象，主要用于那些需要有HttpSession对象才能正常工作的拦截器中。
    debugging：当使用Struts2的开发模式时，这个拦截器会提供更多的调试信息。
    execAndWait：后台执行Action，负责将等待画面发送给用户。
    exception：这个拦截器负责处理异常，它将异常映射为结果。
    fileUpload：这个拦截器主要用于文件上传，它负责解析表单中文件域的内容。
    i18n：这是支持国际化的拦截器，它负责把所选的语言、区域放入用户Session中。
    logger：这是一个负责日志记录的拦截器，主要是输出Action的名字。
    model-driven：这是一个用于模型驱动的拦截器，当某个Action类实现了ModelDriven接口时，它负责把getModel()方法的结果堆入ValueStack中。
    scoped-model-driven：如果一个Action实现了一个ScopedModelDriven接口，该拦截器负责从指定生存范围中找出指定的Modol，并将通过setModel方法将该Model传给Action实例。
    params：这是最基本的一个拦截器，它负责解析HTTP请求中的参数，并将参数值设置成Action对应的属性值。
    prepare：如果action实现了Preparable接口，将会调用该拦截器的prepare()方法。
    static-params：这个拦截器负责将xml中<action>标签下<param>标签中的参数传入action。
    scope：这是范围转换拦截器，它可以将Action状态信息保存到HttpSession范围，或者保存到ServletContext范围内。
    servlet-config：如果某个Action需要直接访问Servlet API，就是通过这个拦截器实现的。
    注意：尽量避免在Action中直接访问Servlet API，这样会导致Action与Servlet的高耦合。
    roles：这是一个JAAS（Java Authentication and Authorization Service，Java授权和认证服务）拦截器，只有当浏览者取得合适的授权后，才可以调用被该拦截器拦截的Action。
    timer：这个拦截器负责输出Action的执行时间，这个拦截器在分析该Action的性能瓶颈时比较有用。
    token：这个拦截器主要用于阻止重复提交，它检查传到Action中的token，从而防止多次提交。
    token-session：这个拦截器的作用与前一个基本类似，只是它把token保存在HttpSession中。
    validation：通过执行在xxxAction-validation.xml中定义的校验器，从而完成数据校验。
    workflow：这个拦截器负责调用Action类中的validate方法，如果校验失败，则返回input的逻辑视图。
    大部分时候，开发者无需手动控制这些拦截器，因为struts-default.xml文件中已经配置了这些拦截器，只要我们定义的包继承了系统的struts-default包，就可以直接使用这些拦截器。

    当然，Struts2的拦截器机制并不是来自于Struts1，而是来自于webWork。




  3  自定义拦截器
     （1）编写拦截器类，继承AbstractInterceptor类 重写intercept(ActionInvocation arg0)方法
          调用用参数类ActionInvocation的invoke方法，即 String result= arg0.invoke();  返回该result=
          invoke就是回调使用了该拦截器的action得相应方法，此时可在该方法执行前后加入我们想要的代码，达到我们拦截action的目的
      利用 arg0.getAction()方法还可以得到拦截器拦截的action实例
    public String intercept(ActionInvocation arg0) throws Exception {
     //  LoginAction loginaction=LoginAction(arg0.getAction());
       System.out.println("执行ction之前");
      String result= arg0.invoke();
       System.out.println("执行ction之后");
        return result;
    }    
    、（2）在struts.xml配置拦截器
        <package name="default" extends="struts-default" namespace="/">    
    <!--配置拦截器  -->
    <interceptors>
    <interceptor name="拦截器名" class="包名.拦截器类名">
        <!--设置拦截器类属性值，如没有则不用设置  -->
          <param name="拦截器类属性名">属性值</param>
    </interceptor>
    </interceptors>
        <action name="login"  class="com.LoginAction" >
        <result name="success">/welcome.jsp</result>
        <result name="error">/error.jsp</result>
        <interceptor-ref name="defaultStack"></interceptor-ref><!--struts-default包默认的拦截器栈  -->
            <!--使用拦截器  -->
        <interceptor-ref name="拦截器名"></interceptor-ref>
        </action>
        
    </package>

     多个拦截器在一起组成一个拦截器栈
          <interceptor-stack name="拦截器栈">
                <interceptor-ref name="拦截器名1"/>
                <interceptor-ref name="拦截器名2"/>
                <interceptor-ref name="拦截器名3"/>
            </interceptor-stack>

比如：<package name="default" extends="struts-default">
        <interceptors>
            <interceptor name="MyInterceptor" class="com.lxitedu.test.InterceptorCustom"></interceptor>
        </interceptors>
        
        <action name="register" class="com.lxitedu.test.Register">
            <interceptor-ref name="MyInterceptor"></interceptor-ref>
            <interceptor-ref name="defaultStack" />
            <result name="fail">/index.jsp </result>
            <result name="success">/success.jsp</result>
        </action>
    </package>

    使用拦截器栈 与 使用拦截器一样语法

     当配置一个包时，可以为其指定默认的拦截器，每个包只能有一个默认的拦截器，一旦为某个包指定了默认的拦截器，
     如果该包中的action没有指定自己的拦截器，则action使用包指定的默认拦截器,但是一旦为action指定了自己拦截器，
     则包的默认拦截器将会失效，如果还想使用原来包的默认拦截器，则必须显示的指定，如
      <action name="login"  class="com.LoginAction" >
        <interceptor-ref name="defaultStack"></interceptor-ref><!--struts-default包默认的拦截器栈  -->
            <!--使用我们的拦截器  -->
        <interceptor-ref name="拦截器名"></interceptor-ref>
        </action>

     我们的包继承另一个包时，也继承了另一个包的默认拦截器，以及包里面的其他如（<result-types>）
     当然我们可以定义自己包的默认拦截器覆盖之


     从这里可以解释为什么我们刚刚开始学struts2的时候老是extends="struts-default"
     因为struts-default包中的默认拦截器以及result-types是个好东东
     如果不继承它，将失去result-types以及里面定义的拦截器功能，可以试着extends="struts-default"去掉，此时如果struts.xml里有
     result的配置的话，则tomcat启动的时候No result type specified for result named 。。。。。错误。我们可以把里面的 result配置去掉
     重新启动tomcat，去测试页面属性值是否能够封装到action属性中，答案不会 因为我们没有继承struts-default
    
 



     配置默认拦截器 在 包package中 <default-interceptor-ref name="拦截器名或拦截器栈"></default-interceptor-ref> 放后面，action配置的前面
      
     
        上面拦截器会拦截action中的所有方法 要想拦截某个方法怎么办  拦截指定方法  
      编写拦截器类，extends MethodFilterInterceptor   MethodFilterInterceptor是AbstractInterceptor的子类
      重写doIntercept方法
         public String doIntercept(ActionInvocation invocation)
        throws Exception
    {
         //  LoginAction loginaction=LoginAction(arg0.getAction());
           System.out.println("执行action方法之前");
           String result= arg0.invoke();
          System.out.println("执行action方法之后");
        return result;
    }
     
       使用配置指定拦截的方法
         <!-- 拦截器一般配置在result元素之后! -->
            <interceptor-ref name="拦截器名1">
                <param name="excludeMethods">execute,haha</param>         <!-- 不拦截! -->
                <param name="includeMethods">execute</param>               <!-- 拦截! -->
            </interceptor-ref>


      可以重复使用一个拦截器或配置多个拦截器与拦截器栈，拦截器的执行顺序是在方法执行前，先配先执行，在方法执行后，后配先执行


      拦截结果的监听 是在action结束后，返回result之前的一个监听器，可以在该监听器里写我们的代码，
      以便在返回结果前执行，
      这个监听器通过手动注册在拦截器内部的
      监听器示例代码  implements PreResultListener
        public class MyPreResultListener implements PreResultListener
         {
    public void beforeResult(ActionInvocation invocation,String resultCode)
    {
        System.out.println("返回的逻辑视图为:" + resultCode);
    }
      }

         拦截器示例代码
        public class BeforeResultInterceptor extends AbstractInterceptor
           {
        public String intercept(ActionInvocation invocation) throws Exception
        {
            invocation.addPreResultListener(new MyPreResultListener()); //注册监听器
            System.out.println("execute方法执行之前的拦截...");
            String result = invocation.invoke();
            System.out.println("execute方法执行之后的拦截......");
            return result;

          }
           }

     监听器代码在action结束后，返回结果前执行，和在action结束后在拦截器内部写的代码相比， 监听器代码把action结束后的代码
     放到监听器似乎更精确和清晰些

       

     给拦截器栈传递参数时会出现一个问题，当拦截器栈中拦截器类中的属性名相同时，不知道这个参数到底要传给那个拦截器，为了
     解决这个问题，可作如下配置
            <interceptor-ref name="拦截器栈名">
                    <param name="拦截器名（不是类名，注意哦）.属性名">属性值</param>
            </interceptor-ref>