logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

类拦截器和方法拦截器

 夜空小雄 2016-12-05

一、拦截器


  1、拦截器小介


       拦截器的功能类似于web.xml文件中的Filter，能对用户的请求进行拦截，通过拦截用户的请求来实现对页面的控制。拦截器是在Struts-core-2.2.3.jar中进行配置的，原始的拦截器是在struts-default.xml中配置的，里面封存了拦截器的基本使用方法。

       Struts2拦截器功能类似于Servlet过滤器。在Action执行execute方法前，Struts2会首先执行struts.xml中引用的拦截器，如果有多个拦截器则会按照上下顺序依次执行，在执行完所有的拦截器的interceptor方法后，会执行Action的execute方法。

        Struts2的拦截器必须从com.opensymphoy.xwork2.interceptor.Interceptor中实现该接口，在被定义的拦截器中有下面三个方法需要被实现：

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. void destroy();   
  2. void init();   
  3. String intercept(ActionInvocation invocation) throws Exception;  

       自定义的拦截器需要重写上面三个方法。另外Struts2的拦截器配置文件struts.xml它是继承了原始文件struts-default.xml文件的，这样在相应的<package>中就会自动拥有struts-default.xml中的所有配置信息了。具体代码如下：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <package name="demo" extends="struts-default" > ... </package>  


  2、Demo


       想要使用拦截器必须要经过配置，struts2采用的是映射的方法，所以想用使用某一个功能就必须在配置文件中配置，拦截器也不例外。所以必须在package中添加相应的拦截器元素，同时将拦截器关联相应的class文件，这样在执行action前才会执行相应的拦截器，具体使用方法如下。


      （1）添加配置文件struts.xml，并在该文件中添加拦截器

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.     </interceptors>  
  6.           
  7.     <action name="demo" class="com.action.LoginAction">  
  8.         <result name="error" type="redirect">/error.jsp</result>  
  9.         <result name="success">/success.jsp</result>  
  10.         <result name="checkError">/checkSession.jsp</result>  
  11.         <interceptor-ref name="myInterceptor"></interceptor-ref>  
  12.         <interceptor-ref name="defaultStack"></interceptor-ref>  
  13.     </action>  
  14. </package>  

        上面的package中添加了一个名为myInterceptor的拦截器，并为该拦截器注册了一个java类，该类名称为MyInterceptor，并被封存在com.interceptor包中。另外还在该package中添加了相应的action，在执行该action前会首先执行myInterceptor拦截器。


      （2）编写被注册的拦截器类MyInterceptor，该类必须实现com.opensymphoy.xwork2.interceptor.Interceptor接口，并重写相应的方法

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package com.interceptor;  
  2.   
  3. import java.util.Map;  
  4.   
  5. import com.entity.User;  
  6. import com.opensymphony.xwork2.ActionContext;  
  7. import com.opensymphony.xwork2.ActionInvocation;  
  8. import com.opensymphony.xwork2.interceptor.Interceptor;  
  9.   
  10. public class MyInterceptor implements Interceptor{  
  11.   
  12.     private User user;  
  13.       
  14.       
  15.     public User getUser() {  
  16.         return user;  
  17.     }  
  18.   
  19.     public void setUser(User user) {  
  20.         this.user = user;  
  21.     }  
  22.   
  23.     @Override  
  24.     public void destroy() {  
  25.         // TODO Auto-generated method stub  
  26.         System.out.println("----destroy()----");  
  27.     }  
  28.   
  29.     @Override  
  30.     public void init() {  
  31.         // TODO Auto-generated method stub  
  32.         System.out.println("-----Init()-------");  
  33.     }  
  34.   
  35.     @Override  
  36.     public String intercept(ActionInvocation invocation) throws Exception {  
  37.         // TODO Auto-generated method stub  
  38.         System.out.println("----intercept()------");  
  39.         Map<String, Object> session= invocation.getInvocationContext().getSession();  
  40.         if(session.get("username")!=null){  
  41.             System.out.println("登陆成功！");          
  42.             //session.put("username",user.getUsername());  
  43.             return invocation.invoke();  
  44.         }else{  
  45.             System.out.println("登陆失败！");  
  46.             return "checkError";  
  47.         }  
  48.     }  
  49.   
  50. }  


       （3）经过前面两步后，拦截器已经配置完成，最后一部就是使用拦截器了，在显示页面上添加相应的标签，并为标签指定上面创建的名为demo的action，然后执行页面即可在控制台中打印出相应的拦截器内容。

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"%>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www./TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  7. <title>Insert title here</title>  
  8. </head>  
  9. <body>  
  10.     <form action="demo">  
  11.         用户名：<input type="text" name="username"><br>  
  12.         密  码：<input type="text" name="password"><br>  
  13.         <input type="submit" name="ok" value="提交">  
  14.     </form>  
  15. </body>  
  16. </html>  

打印输出内容：

        分析输出结果，程序编译阶段首先会去读取配置文件struts.xml，在该配置文件action中顺序查找是否添加了拦截器，如果添加了拦截器则根据拦截器名称在<interceptors>中查找是否定义了该拦截器或者拦截器栈，如果发现定义的是拦截器则根据拦截器查找对应的注册的class，最后在包内查找注册的class并执行相应的init()方法；程序运行阶段的大致流程和编译阶段类似，用户在前台提交请求后，会按照注册的action在struts.xml中查找与之相对应的，如果查找到将会查找拦截器，没有查找到的话会相应的抛错，最后执行拦截器注册类的intercept方法。


  3、拦截器栈


       拦截器同样有栈的概念，它是将使用的拦截器定义到共有的状态下来实现统一管理，这样在package中就可以做到拦截器的共享了，大大便利了拦截器的使用。在一个package中往往会用到重复的interceptor，如果每次都在Action中添加interceptor-ref的话就会很麻烦，那么拦截器栈就是为了解决这个问题而产生的，具体配置如下：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.         <!-- 拦截器 -->  
  3.         <interceptors>  
  4.             <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.             <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.             <interceptor-stack name="defaultstack1">  
  7.                 <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.                 <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.             </interceptor-stack>  
  10.         </interceptors>  
  11.           
  12.         <action name="demo" class="com.action.LoginAction">  
  13.             <result name="error" type="redirect">/error.jsp</result>  
  14.             <result name="success">/success.jsp</result>  
  15.             <result name="checkError">/checkSession.jsp</result>  
  16.             <interceptor-ref name="defaultstack1"></interceptor-ref>  
  17.         </action>  
  18. </package>  

        实例中使用了interceptor-stack来定义了一个名称为defaultstack1的拦截器栈，在该栈中添加了要执行的拦截器，把拦截器做了封装，在Action中直接调用该拦截器栈即可，实现了拦截器栈的共享。


  4、默认拦截器栈


        另外可以定义默认的拦截器栈，即：如果某个Action中没有定义拦截器，那么它会默认执行该公共的拦截器。它和interceptors标签属于同一等级的，使用default-interceptor-ref定义。

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.         <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.         <interceptor-stack name="defaultinter">  
  7.             <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.         </interceptor-stack>  
  10.     </interceptors>  
  11.       
  12.     <!-- 定义默认的拦截器栈，会自动注册到action中 -->  
  13.     <default-interceptor-ref name="defaultinter"></default-interceptor-ref>  
  14.       
  15.     <action name="demo" class="com.action.LoginAction">  
  16.         <result name="error" type="redirect">/error.jsp</result>  
  17.         <result name="success">/success.jsp</result>  
  18.         <result name="checkError">/checkSession.jsp</result>  
  19.     </action>  
  20. </package>  

      定义的默认的拦截器栈只是在Action没有指定拦截器的情况下才执行自定义默认的拦截器栈的，如果在Action中重定义了拦截器，那么它会覆盖自定义默认的拦截器栈的。

  5、不执行任何拦截器


      还有一种情况是一个package中定义了默认的拦截器，但是在编写的某个Action中并不需要执行任何拦截器，那么此时可以在相应的Action中添加一个名称为defaultStack的拦截器即可，它是系统默认的拦截器，不会有任何操作。

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.         <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.         <interceptor-stack name="defaultinter">  
  7.             <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.         </interceptor-stack>  
  10.     </interceptors>  
  11.       
  12.     <!-- 定义默认的拦截器栈，会自动注册到action中 -->  
  13.     <default-interceptor-ref name="defaultinter"></default-interceptor-ref>  
  14.       
  15.     <action name="demo" class="com.action.LoginAction">  
  16.         <result name="error" type="redirect">/error.jsp</result>  
  17.         <result name="success">/success.jsp</result>  
  18.         <result name="checkError">/checkSession.jsp</result>  
  19.           
  20.         <!-- 添加defaultStack保证不执行拦截器 -->  
  21.         <interceptor-ref name="defaultStack"></interceptor-ref>  
  22.     </action>  
  23. </package>  


  6、拦截方法


      6.1 用法

        上面的拦截器只是实现了对Action的拦截，其实拦截器的功能很强大，它也可以拦截相应Action方法。和拦截Action不同的是想要拦截方法就必须继承类MethodFilterInterceptor，该类封存在xwork-core.jar中，又一次证明了WebWork是Struts2的核心。另外还需要在配置文件中添加相应的属性来确定拦截的方法和不拦截的方法，具体配置方法如下：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <package name="testLogin" namespace="/" extends="struts-default">  
  2.     <!-- 拦截器 -->  
  3.     <interceptors>  
  4.         <interceptor name="myInterceptor" class="com.interceptor.MyInterceptor"></interceptor>  
  5.         <!-- 定义公共的拦截器链，在action标签中只需要引用拦截器链 -->  
  6.         <interceptor-stack name="defaultinter">  
  7.             <interceptor-ref name="myInterceptor"></interceptor-ref>  
  8.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  9.         </interceptor-stack>  
  10.     </interceptors>  
  11.       
  12.     <action name="demo" class="com.action.LoginAction">  
  13.         <result name="error" type="redirect">/error.jsp</result>  
  14.         <result name="success">/success.jsp</result>  
  15.         <result name="checkError">/checkSession.jsp</result>  
  16.           
  17.         <!-- 在defaultStack中配置拦截方法，参数includeMethods中添加被拦截的方法名称，excludeMethods中添加不需要拦截的名称 -->  
  18.         <interceptor-ref name="defaultStack">  
  19.             <param name="includeMethods">添加要拦截的方法名称</param><!-- 拦截方法 -->  
  20.             <param name="excludeMethods">添加不需要拦截的方法名称</param><!-- 不拦截方法 -->  
  21.         </interceptor-ref>  
  22.     </action>  
  23. </package>  

      继承MethodFilterInterceptor类的相应拦截方法的类中的代码：

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package com.interceptor;  
  2.   
  3. import java.util.Map;  
  4. import com.opensymphony.xwork2.ActionContext;  
  5. import com.opensymphony.xwork2.ActionInvocation;  
  6. import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;  
  7.   
  8. public class inter extends MethodFilterInterceptor {  
  9.   
  10.     @Override  
  11.     public String doIntercept(ActionInvocation invocation) throws Exception {  
  12.         System.out.println("--intercept()--");  
  13.         //获取相应的Session  
  14.         Map<String,Object> session=invocation.getInvocationContext().getSession();  
  15.           
  16.         Map request=(Map)ActionContext.getContext().get("request");  
  17.           
  18.         String username=(String)request.get("user.username");  
  19.         if(session.get("username") != null){  
  20.             String result=invocation.invoke();  
  21.               
  22.             System.out.println("--end()--");  
  23.             return result;  
  24.         }  
  25.     }  
  26.   
  27. }  

    6.2 Demo

       来看一个拦截方法的实例，并对结果进行分析。下面的实例演示拦截方法的输出结果，在实例中分别创建了一个loginAction类，添加Action要执行的方法；Inter类，拦截器中重写MethodFilterInterceptor方法，在控制台中输出是否对某个方法进行拦截；login.jsp文件，添加三个按钮，分别演示三个方法的执行。

      （1）struts.xml内方法拦截器的定义，在package中定义了一个名称为inter的拦截器，在拦截器中指定了参数，includeMethods用来拦截Method1，excludeMethods中的Method2表示不拦截Methods2方法，具体配置如下代码：

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <!DOCTYPE struts PUBLIC  
  2.           "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  3.           "http://struts./dtds/struts-2.0.dtd">  
  4. <struts>  
  5.     <constant name="struts.action.extension" value=","></constant>  
  6.       
  7.     <package name="login" extends="struts-default">    
  8.         <interceptors>  
  9.             <interceptor name="inter" class="com.interceptor.inter">  
  10.                 <param name="includeMethods">Method1</param> <!-- 拦截Method1方法 -->  
  11.                 <param name="excludeMethods">Method2</param>  
  12.             </interceptor>  
  13.             <interceptor-stack name="myInterceptor">  
  14.                 <interceptor-ref name="inter"></interceptor-ref>  
  15.                 <interceptor-ref name="defaultStack"></interceptor-ref>  
  16.             </interceptor-stack>  
  17.         </interceptors>  
  18.               
  19.         <action name="loginaction" class="com.action.loginAction">  
  20.             <result name="success">success.jsp</result>  
  21.             <result name="error">error.jsp</result>  
  22.             <result name="cancel" type="redirectAction">Welcome</result>  
  23.             <interceptor-ref name="inter"></interceptor-ref>  
  24.             <interceptor-ref name="defaultStack"></interceptor-ref>  
  25.         </action>  
  26.     </package>  
  27. </struts>  

       （2）loginAction类，配置login.jsp中的action，分别在该类中添加Method1-Method3三个方法，其中Method1被拦截，Method2和Method3不被拦截，最后我们查看输出结果。

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package com.action;  
  2.   
  3. import com.opensymphony.xwork2.ActionSupport;  
  4.   
  5. public class loginAction extends ActionSupport {  
  6.     @Override  
  7.     public String execute() throws Exception {  
  8.         if(this.username.equals("admin") && this.password.equals("admin")){  
  9.             return "success";  
  10.         }else if(this.username.equals("cancel") && this.password.equals("cancel")){  
  11.             return "cancel";  
  12.         }else{  
  13.             return "error";  
  14.         }  
  15.     }  
  16.       
  17.     public void Method1(){  
  18.         System.out.println("执行方法:Method1");  
  19.     }  
  20.       
  21.     public void Method2(){  
  22.         System.out.println("执行方法:Method2");  
  23.     }  
  24.       
  25.     public void Method3(){  
  26.         System.out.println("执行方法:Method3");  
  27.     }  
  28.       
  29.     private String username;  
  30.     private String password;  
  31.       
  32.     public String getUsername(){  
  33.         return this.username;  
  34.     }  
  35.       
  36.     public void setUsername(String username){         
  37.         this.username=username;  
  38.     }  
  39.       
  40.     public String getPassword(){  
  41.         return this.password;  
  42.     }  
  43.       
  44.     public void setPassword(String password){  
  45.         this.password=password;  
  46.     }  
  47.       
  48.       
  49. }  

        （3）inter类，继承MethodFilterInterceptor类，用来实现拦截方法。重写doIntercept方法，在该方法中添加拦截的相应信息。
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. package com.interceptor;  
  2.   
  3. import java.util.Date;  
  4. import java.util.Map;  
  5.   
  6. import com.action.loginAction;  
  7. import com.opensymphony.xwork2.ActionContext;  
  8. import com.opensymphony.xwork2.ActionInvocation;  
  9. import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;  
  10.   
  11. public class inter extends MethodFilterInterceptor {  
  12.       
  13.     @Override  
  14.     protected String doIntercept(ActionInvocation invocation) throws Exception {  
  15.         // TODO Auto-generated method stub    
  16.          System.out.println("拦截器在Action执行前拦截"+new Date());    
  17.          String result=invocation.invoke();  //执行Action方法  
  18.          System.out.println("拦截器在Action执行后拦截"+new Date());    
  19.         return result;    
  20.   
  21.     }  
  22.   
  23. }  

     （4）login.jsp，在jsp页面上添加三个按钮，分别演示三个方法，判断拦截器对方法的拦截情况。三个按钮在点击后回发的action是在javascript中动态的进行添加的，这样做达到了一个form中执行不同的action的方法，当然还有其它的方法，将会在下篇文章中讨论。
[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"%>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www./TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  7. <title>Insert title here</title>  
  8. <script type="text/javascript">  
  9.       
  10.     //方法1，定义被拦截的方法的实例  
  11.     function method1(){  
  12.         var form=document.forms[0];  
  13.         form.action="loginaction!Method1";  
  14.         form.submit();  
  15.     }  
  16.       
  17.     //方法2，为按钮2添加不拦截的方法  
  18.     function method2(){  
  19.         var form=document.forms[0];  
  20.         form.action="loginaction!Method2";  
  21.         form.submit();  
  22.     }  
  23.       
  24.     //方法3，为按钮3添加不拦截的方法  
  25.     function method3(){  
  26.         var form=document.forms[0];  
  27.         form.action="loginaction!Method3";  
  28.         form.submit();  
  29.     }  
  30. </script>  
  31. </head>  
  32. <body>  
  33.     <form>  
  34.         用户名：<input type="text" name="username"><br>  
  35.         密     码：<input type="text" name="password"><br>  
  36.         <input type="submit" name="ok" value="按钮1" onclick="method1()">  
  37.         <input type="submit" name="ok1" value="按钮2" onclick="method2()">  
  38.         <input type="submit" name="ok2" value="按钮3" onclick="method3()">  
  39.     </form>  
  40. </body>  
  41. </html>  

        运行完成后的页面视图：
              
       （5）分析运行结果，分别单击按钮1、2、3，在控制台中输出结果，按钮1是绑定的method1，该方法在struts.xml中进行了拦截如果结果正确的话会显示被拦截的结果，而相应的按钮2和3只输出运行结果，因为它们没有被拦截。那看下面的结果图：

        结果图正好正是了我们的分析结果，按钮1被拦截了，执行了inter类中的doIntercept方法，二相应的按钮2和3没有被拦截。也就是说，Method1被放到了方法拦截器的白名单内，执行要拦截该方法；Method2被放到了拦截器黑名单内，不需要拦截该方法；Method3不做任何处理。

结语


        对于拦截器的内容就总结到这里，拦截器提供了很强大的功能，使得开发人员能够在运行时控制输出结果，增加了编程的灵活性。另外对于任何理论性的东西都不要试图去记忆，一定要理性的去分析，多多实践，动手做几个实例，分析结果更深刻的理解。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 夜空小雄 > 《知识点》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多