zoukankan      html  css  js  c++  java
  • 【转】Struts2中的MethodFilterInterceptor(转)

    这是一个Struts2.1.8.1应用,代码如下

    首先是web.xml文件

    view plaincopy to clipboardprint?
    01.<?xml version="1.0" encoding="UTF-8"?>  
    02.<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
    03.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    04.    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee    
    05.    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
    06.    <filter>  
    07.        <filter-name>struts2</filter-name>  
    08.        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
    09.    </filter>  
    10.    <filter-mapping>  
    11.        <filter-name>struts2</filter-name>  
    12.        <url-pattern>/*</url-pattern>  
    13.    </filter-mapping>  
    14.    <welcome-file-list>  
    15.        <welcome-file>methodFilter.jsp</welcome-file>  
    16.    </welcome-file-list>  
    17.</web-app>  
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
     <filter>
      <filter-name>struts2</filter-name>
      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
     </filter>
     <filter-mapping>
      <filter-name>struts2</filter-name>
      <url-pattern>/*</url-pattern>
     </filter-mapping>
     <welcome-file-list>
      <welcome-file>methodFilter.jsp</welcome-file>
     </welcome-file-list>
    </web-app>

    然后用于提交方法过滤测试的methodFilter.jsp页面

    view plaincopy to clipboardprint?
    01.<%@ page language="java" pageEncoding="UTF-8"%>  
    02.<%@ taglib prefix="s" uri="/struts-tags"%>  
    03.<s:form action="methodFilter" theme="simple">  
    04.    您可以直接点击Submit提交请求,然后在控制台查看输出情况<br/>  
    05.    <s:submit value="我要测试方法过滤拦截器"/>  
    06.</s:form>  
    <%@ page language="java" pageEncoding="UTF-8"%>
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <s:form action="methodFilter" theme="simple">
     您可以直接点击Submit提交请求,然后在控制台查看输出情况<br/>
     <s:submit value="我要测试方法过滤拦截器"/>
    </s:form>

    然后是用于显示方法过滤结果的methodFilterResult.jsp页面

    view plaincopy to clipboardprint?
    01.<%@ page pageEncoding="UTF-8"%>  
    02.<h2>请移步控制台查看输出情况</h2>  
    <%@ page pageEncoding="UTF-8"%>
    <h2>请移步控制台查看输出情况</h2>

    然后是struts.xml文件

    view plaincopy to clipboardprint?

    01.<?xml version="1.0" encoding="UTF-8" ?>  
    02.<!DOCTYPE struts PUBLIC   
    03.        "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"   
    04.        "http://struts.apache.org/dtds/struts-2.1.dtd">  
    05.<struts>  
    06.    <package name="methodFilter" extends="struts-default">  
    07.        <interceptors>  
    08.            <interceptor name="myInterceptor11" class="com.jadyer.interceptor.MyInterceptor11">  
    09.                <param name="hello">world</param>  
    10.            </interceptor>  
    11.            <!-- <param name="hello">world</param>表示为拦截器增加一个名为hello值为world的属性 -->  
    12.            <!-- 但是这里也只是为hello赋了初值为world。如若在下面的<action/>中配置使用该拦截器的时候 -->  
    13.            <!-- 增加了<param name="hello">welcome</param>,则最后拦截器类中hello属性值即为welcome -->  
    14.            <interceptor name="myInterceptor22" class="com.jadyer.interceptor.MyInterceptor22"/>  
    15.            <interceptor name="myInterceptor33" class="com.jadyer.interceptor.MyInterceptor33">  
    16.                <param name="includeMethods">test,abc</param>  
    17.            </interceptor>  
    18.        </interceptors>  
    19.        <action name="methodFilter" class="com.jadyer.action.MethodFilterAction" method="test">  
    20.            <result name="success">/methodFilterResult.jsp</result>  
    21.            <interceptor-ref name="defaultStack"/>  
    22.            <interceptor-ref name="myInterceptor11"/>  
    23.            <interceptor-ref name="myInterceptor22"/>  
    24.            <interceptor-ref name="myInterceptor33">  
    25.                <param name="includeMethods">abc</param>  
    26.            </interceptor-ref>  
    27.        </action>  
    28.    </package>  
    29.</struts>  


    30.<!-- *********************【方法过滤拦截器的使用】********************************************** -->  
    31.<!-- 默认的情况下,拦截器会拦截Action中的所有的方法,这里不包括setter或getter方法 -->  
    32.<!-- 这时就可以使用方法过滤拦截器来拦截指定的方法,这是一种更加细化的拦截器的配置方式 -->  
    33.<!-- 它可以细化到拦截具体的某个方法。而不是拦截某个Action,因为拦截Action是一种粗粒度的实现方式 -->  
    34.<!-- 使用includeMethods指明拦截器所要拦截的方法。使用excludeMethods指明拦截器不再拦截的方法 -->  
    35.<!-- 这里excludeMethods和includeMethods是在MethodFilterInterceptor类中定义的成员变量 -->  
    36.<!-- 而且只要includeMethods进来的方法就一定会被拦截,而不管是否已经把它excludeMethods在外了 -->  
    37.<!-- 也就是说includeMethods的优先级要高于excludeMethods -->  
    38.<!-- 也可以使用<param name="includeMethods"/>在上面定义拦截器的时候指定全局性过滤的方法 -->  
    39.<!-- 区别就是对方法的过滤有全局性和局部性区分。而当发生冲突时,则依照【就近原则】以局部性的配置为准 -->  
    40.<!-- 所谓的发生冲突,指的是类似于全局中有一个includeMethods配置,而局部中也有一个includeMethods配置 -->  
    41.<!-- 另外,还有一种情况,假设全局性过滤定义为<param name="includeMethods">test</param> -->  
    42.<!-- 而在局部性过滤中定义为<param name="excludeMethods">test</param> -->  
    43.<!-- 这种情况下,<param name="includeMethods">test</param>将生效,即拦截Action中的test()方法 -->  
    44.<!-- 这个时候全局中配置的是拦截,局部中配置的是不拦截,二者并没有发生冲突,所以仍是以includeMethods优先级高 -->  
    45.<!-- 可以认为在局部的配置中,已经隐含的把<param name="includeMethods">test</param>继承过来了 -->  
    46.<!-- 补充:这里衡量的所谓拦截到与否,主要可以通过查看控制台输出的语句,以判断是否执行到该拦截器内部 -->  
    47.<!-- **************************************************************************************** -->  
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE struts PUBLIC
      "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"
      "http://struts.apache.org/dtds/struts-2.1.dtd">
    <struts>
     <package name="methodFilter" extends="struts-default">
      <interceptors>
       <interceptor name="myInterceptor11" class="com.jadyer.interceptor.MyInterceptor11">
        <param name="hello">world</param>
       </interceptor>
       <!-- <param name="hello">world</param>表示为拦截器增加一个名为hello值为world的属性 -->
       <!-- 但是这里也只是为hello赋了初值为world。如若在下面的<action/>中配置使用该拦截器的时候 -->
       <!-- 增加了<param name="hello">welcome</param>,则最后拦截器类中hello属性值即为welcome -->
       <interceptor name="myInterceptor22" class="com.jadyer.interceptor.MyInterceptor22"/>
       <interceptor name="myInterceptor33" class="com.jadyer.interceptor.MyInterceptor33">
        <param name="includeMethods">test,abc</param>
       </interceptor>
      </interceptors>
      <action name="methodFilter" class="com.jadyer.action.MethodFilterAction" method="test">
       <result name="success">/methodFilterResult.jsp</result>
       <interceptor-ref name="defaultStack"/>
       <interceptor-ref name="myInterceptor11"/>
       <interceptor-ref name="myInterceptor22"/>
       <interceptor-ref name="myInterceptor33">
        <param name="includeMethods">abc</param>
       </interceptor-ref>
      </action>
     </package>
    </struts>
    <!-- *********************【方法过滤拦截器的使用】********************************************** -->
    <!-- 默认的情况下,拦截器会拦截Action中的所有的方法,这里不包括setter或getter方法 -->
    <!-- 这时就可以使用方法过滤拦截器来拦截指定的方法,这是一种更加细化的拦截器的配置方式 -->
    <!-- 它可以细化到拦截具体的某个方法。而不是拦截某个Action,因为拦截Action是一种粗粒度的实现方式 -->
    <!-- 使用includeMethods指明拦截器所要拦截的方法。使用excludeMethods指明拦截器不再拦截的方法 -->
    <!-- 这里excludeMethods和includeMethods是在MethodFilterInterceptor类中定义的成员变量 -->
    <!-- 而且只要includeMethods进来的方法就一定会被拦截,而不管是否已经把它excludeMethods在外了 -->
    <!-- 也就是说includeMethods的优先级要高于excludeMethods -->
    <!-- 也可以使用<param name="includeMethods"/>在上面定义拦截器的时候指定全局性过滤的方法 -->
    <!-- 区别就是对方法的过滤有全局性和局部性区分。而当发生冲突时,则依照【就近原则】以局部性的配置为准 -->
    <!-- 所谓的发生冲突,指的是类似于全局中有一个includeMethods配置,而局部中也有一个includeMethods配置 -->
    <!-- 另外,还有一种情况,假设全局性过滤定义为<param name="includeMethods">test</param> -->
    <!-- 而在局部性过滤中定义为<param name="excludeMethods">test</param> -->
    <!-- 这种情况下,<param name="includeMethods">test</param>将生效,即拦截Action中的test()方法 -->
    <!-- 这个时候全局中配置的是拦截,局部中配置的是不拦截,二者并没有发生冲突,所以仍是以includeMethods优先级高 -->
    <!-- 可以认为在局部的配置中,已经隐含的把<param name="includeMethods">test</param>继承过来了 -->
    <!-- 补充:这里衡量的所谓拦截到与否,主要可以通过查看控制台输出的语句,以判断是否执行到该拦截器内部 -->
    <!-- **************************************************************************************** -->

    实现了Interceptor接口的自定义拦截器MyInterceptor11.java

    view plaincopy to clipboardprint?
    01.package com.jadyer.interceptor;   
    02.  
    03.import com.opensymphony.xwork2.ActionInvocation;   
    04.import com.opensymphony.xwork2.interceptor.Interceptor;   
    05.  
    06./**  
    07. * 实现Interceptor接口的自定义拦截器  
    08. * @see 【这种方式不太常用】  
    09. */  
    ")   
    11.public class MyInterceptor11 implements Interceptor {   
    12.    //这里的属性名要与struts.xml配置的<param name=""/>中的name值相同   
    13.    //然后Struts2会自动将struts.xml中配置的world值赋值到这里的hello属性中   
    14.    //当然,前提是要提供setter和getter方法,只要符合JavaBean的要求即可   
    15.    private String hello;   
    16.  
    17.    public String getHello() {   
    18.        return hello;   
    19.    }   
    20.    public void setHello(String hello) {   
    21.        this.hello = hello;   
    22.    }   
    23.  
    24.    /**  
    25.     * 初始化时执行的方法  
    26.     */  
    27.    public void init() {   
    28.        System.out.println("------MyInterceptor11 init method invoked------");   
    29.        System.out.println(hello);   
    30.    }   
    31.    /**  
    32.     * 销毁时执行的方法  
    33.     */  
    34.    public void destroy() {   
    35.        System.out.println("------MyInterceptor11 destroy method invoked------");   
    36.    }   
    37.  
    38.    //每执行一次action请求,这里的intercept()方法都会被执行一次   
    39.    public String intercept(ActionInvocation invocation) throws Exception {   
    40.        System.out.println("------MyInterceptor11 invoked begin------");   
    41.        //调用invoke()方法   
    42.        //如果还有下一个拦截器的话,就执行下一个拦截器   
    43.        //如果没有下一个拦截器的话,便执行Action中的方法   
    44.        String result = invocation.invoke();   
    45.        System.out.println("------MyInterceptor11 invoked finish------");   
    46.        return result;   
    47.    }   
    48.}   
    49./********************【浅析Struts2的拦截器】***********************************************************/  
    50.//Struts2中的拦截器,实际上就是用来拦截Action的。它就相当于入口和出口一样,把Action的相关方法包裹在中间了   
    51.//过滤器可以组成过滤器链,也就是有多个过滤器来过滤相同的东西。拦截器同样也有拦截器链,在Struts2中称为拦截器栈   
    52.//拦截器栈相当于一串拦截器,用来共同的拦截某一个Action。拦截的顺序是按照配置的顺序执行的   
    53.//假设先配置的是myInterceptor11,后配置的是myInterceptor22   
    54.//所以在执行时,先执行myInterceptor11,后执行myInterceptor22   
    55.//但是在结束时,先执行myInterceptor22,后执行myInterceptor11   
    56.//就好像进入一个有两道门的房间一样,进去的顺序和出来的顺序正好相反   
    57.//也就是说它首先会进入第一个拦截器,出来后再进入第二个拦截器,依此类推,最后进入Action的execute()方法   
    58.//当execute()执行后,再按照相反的顺序,先回到第二个拦截器,再回到第一个拦截器,最后才回到结果视图   
    59.//因此invoke()就是用来判断,若还有下一个拦截器,就调用下一个拦截器。否则,直接跳到Action的execute()方法   
    60./********************【Struts2的默认拦截器】***********************************************************/  
    61.//实际上可以把Struts2看成是一个空的容器。就是因为里面配置了大量的拦截器,导致了我们的请求需要一层一层的通过这些拦截器   
    62.//然后它会处理我们的请求,并根据我们的配置,把它所感兴趣的东西解析出来。如果出现问题,它会放到错误消息里面去   
    63./****************************************************************************************************/  

    package com.jadyer.interceptor;
    
    import com.opensymphony.xwork2.ActionInvocation;
    import com.opensymphony.xwork2.interceptor.Interceptor;
    
    /**
     * 实现Interceptor接口的自定义拦截器
     * @see 【这种方式不太常用】
     */
    @SuppressWarnings("serial")
    public class MyInterceptor11 implements Interceptor {
     //这里的属性名要与struts.xml配置的<param name=""/>中的name值相同
     //然后Struts2会自动将struts.xml中配置的world值赋值到这里的hello属性中
     //当然,前提是要提供setter和getter方法,只要符合JavaBean的要求即可
     private String hello;
    
     public String getHello() {
      return hello;
     }
     public void setHello(String hello) {
      this.hello = hello;
     }
    
     /**
      * 初始化时执行的方法
      */
     public void init() {
      System.out.println("------MyInterceptor11 init method invoked------");
      System.out.println(hello);
     }
     /**
      * 销毁时执行的方法
      */
     public void destroy() {
      System.out.println("------MyInterceptor11 destroy method invoked------");
     }
    
     //每执行一次action请求,这里的intercept()方法都会被执行一次
     public String intercept(ActionInvocation invocation) throws Exception {
      System.out.println("------MyInterceptor11 invoked begin------");
      //调用invoke()方法
      //如果还有下一个拦截器的话,就执行下一个拦截器
      //如果没有下一个拦截器的话,便执行Action中的方法
      String result = invocation.invoke();
      System.out.println("------MyInterceptor11 invoked finish------");
      return result;
     }
    }

    /********************【浅析Struts2的拦截器】***********************************************************/
    //Struts2中的拦截器,实际上就是用来拦截Action的。它就相当于入口和出口一样,把Action的相关方法包裹在中间了
    //过滤器可以组成过滤器链,也就是有多个过滤器来过滤相同的东西。拦截器同样也有拦截器链,在Struts2中称为拦截器栈
    //拦截器栈相当于一串拦截器,用来共同的拦截某一个Action。拦截的顺序是按照配置的顺序执行的
    //假设先配置的是myInterceptor11,后配置的是myInterceptor22
    //所以在执行时,先执行myInterceptor11,后执行myInterceptor22
    //但是在结束时,先执行myInterceptor22,后执行myInterceptor11
    //就好像进入一个有两道门的房间一样,进去的顺序和出来的顺序正好相反
    //也就是说它首先会进入第一个拦截器,出来后再进入第二个拦截器,依此类推,最后进入Action的execute()方法
    //当execute()执行后,再按照相反的顺序,先回到第二个拦截器,再回到第一个拦截器,最后才回到结果视图
    //因此invoke()就是用来判断,若还有下一个拦截器,就调用下一个拦截器。否则,直接跳到Action的execute()方法
    /********************【Struts2的默认拦截器】***********************************************************/
    //实际上可以把Struts2看成是一个空的容器。就是因为里面配置了大量的拦截器,导致了我们的请求需要一层一层的通过这些拦截器
    //然后它会处理我们的请求,并根据我们的配置,把它所感兴趣的东西解析出来。如果出现问题,它会放到错误消息里面去
    /****************************************************************************************************/

    继承了AbstractInterceptor类的自定义拦截器MyInterceptor22.java

    view plaincopy to clipboardprint?

    package com.jadyer.interceptor;   
      
    import com.opensymphony.xwork2.ActionInvocation;   
    import com.opensymphony.xwork2.interceptor.AbstractInterceptor;   
      
    /**  
     * 继承AbstractInterceptor类的自定义拦截器  
     * @see 【这种方式比较常用】  
     * @see 继承AbstractInterceptor之后,就不需要再去实现init()和destroy()方法了  
     * @see 所以实际应用中,更多的时候还是继承AbstractInterceptor,而不是实现Interceptor  
     */  
    ")   
    public class MyInterceptor22 extends AbstractInterceptor {   
        @Override  
       public String intercept(ActionInvocation invocation) throws Exception {   
            System.out.println("------MyInterceptor22 invoked begin------");   
            String result = invocation.invoke();   
            System.out.println("------MyInterceptor22 invoked finish------");   
            return result;   
       }   
    }  



    package com.jadyer.interceptor;
    
    import com.opensymphony.xwork2.ActionInvocation;
    import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
    
    /**
     * 继承AbstractInterceptor类的自定义拦截器
     * @see 【这种方式比较常用】
     * @see 继承AbstractInterceptor之后,就不需要再去实现init()和destroy()方法了
     * @see 所以实际应用中,更多的时候还是继承AbstractInterceptor,而不是实现Interceptor
     */
    @SuppressWarnings("serial")
    public class MyInterceptor22 extends AbstractInterceptor {
     @Override
     public String intercept(ActionInvocation invocation) throws Exception {
      System.out.println("------MyInterceptor22 invoked begin------");
      String result = invocation.invoke();
      System.out.println("------MyInterceptor22 invoked finish------");
      return result;
     }
    }

    继承了MethodFilterInterceptor拦截器类的自定义拦截器MyInterceptor33.java

    view plaincopy to clipboardprint?
    01.package com.jadyer.interceptor;   
    02.  
    03.import com.opensymphony.xwork2.ActionInvocation;   
    04.import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;   
    05.  
    06./**  
    07. * 继承MethodFilterInterceptor的拦截器,即方法过滤的拦截器  
    08. * @see 查看MethodFilterInterceptor的源码可知,它也是一个拦截器类,它继承了AbstractInterceptor  
    09. * @see 观察它的类名,可以发现,它就是一个拦截某一个具体的方法的方法过滤拦截器  
    10. * @see 而MethodFilterInterceptor类已经自动实现好了Intercept()方法  
    11. * @see 实际上MethodFilterInterceptor类中的Intercept()方法真正执行的是它本身的一个doIntercept()抽象方法  
    12. * @see 因此,我们想要拦截某一个方法的时候,只要继承MethodFilterInterceptor类,然后实现doIntercept()便OK  
    13. */  
    ")   
    15.public class MyInterceptor33 extends MethodFilterInterceptor {   
    16.    @Override  
    17.    protected String doIntercept(ActionInvocation invocation) throws Exception {   
    18.        System.out.println("------MyInterceptor33 invoked begin------");   
    19.        String result = invocation.invoke();   
    20.        System.out.println("------MyInterceptor33 invoked finish------");   
    21.        return result;   
    22.    }   
    23.}  
    package com.jadyer.interceptor;

    import com.opensymphony.xwork2.ActionInvocation;
    import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

    /**
     * 继承MethodFilterInterceptor的拦截器,即方法过滤的拦截器
     * @see 查看MethodFilterInterceptor的源码可知,它也是一个拦截器类,它继承了AbstractInterceptor
     * @see 观察它的类名,可以发现,它就是一个拦截某一个具体的方法的方法过滤拦截器
     * @see 而MethodFilterInterceptor类已经自动实现好了Intercept()方法
     * @see 实际上MethodFilterInterceptor类中的Intercept()方法真正执行的是它本身的一个doIntercept()抽象方法
     * @see 因此,我们想要拦截某一个方法的时候,只要继承MethodFilterInterceptor类,然后实现doIntercept()便OK
     */
    @SuppressWarnings("serial")
    public class MyInterceptor33 extends MethodFilterInterceptor {
     @Override
     protected String doIntercept(ActionInvocation invocation) throws Exception {
      System.out.println("------MyInterceptor33 invoked begin------");
      String result = invocation.invoke();
      System.out.println("------MyInterceptor33 invoked finish------");
      return result;
     }
    }

    最后是用到的Action类

    view plaincopy to clipboardprint?
    01.package com.jadyer.action;   
    02.  
    03.import com.opensymphony.xwork2.ActionSupport;   
    04.  
    ")   
    06.public class MethodFilterAction extends ActionSupport{   
    07.    public String test() throws Exception {   
    08.        System.out.println("------test() is invoked------");   
    09.        return SUCCESS;   
    10.    }   
    11.       
    12.    public String abc() throws Exception {   
    13.        System.out.println("------abc() is invoked------");   
    14.        return SUCCESS;   
    15.    }   
    16.  
    17.    @Override  
    18.    public String execute() throws Exception {   
    19.        System.out.println("------execute() is invoked------");   
    20.        return SUCCESS;   
    21.    }   
    22.} 

  • 相关阅读:
    类特性:多态
    类特性:继承
    类,对象入门
    cf round599 CDE
    cf round#598 CDEF
    高精度小数BigDecimal+二分——java
    点分治
    java——IO(普通文件,二进制文件,压缩文件 )
    JCF——Map
    JCF——set
  • 原文地址:https://www.cnblogs.com/lbangel/p/3145570.html
Copyright © 2011-2022 走看看