Struts 拦截器

        拦截器可以说是Struts2的核心，大部分功能都是通过拦截器来实现的，只要我们的包继承了 struts-default 包<package name="struts2" extends="struts-default">，就可以使用struts-defaul 里的拦截器。

自定义拦截器的步骤：
1） 编写拦截器类，需要实现Interceptor接口，并实现该接口的三个方法：init、intercept、destroy
       或者继承 AbstractInterceptor抽象类 ，并实现 intercept 方法就够了
       或者继承 MethodFilterInterceptor抽象类，并实现 doIntercept方法
       MethodFilterInterceptor抽象类继承  AbstractInterceptor抽象类 实现  Interceptor接口
2） 在struts.xml 文件中定义拦截器
3） 在struts.xml 文件中的action标签内引用 拦截器
如果使用了自定义的拦截器，则在拦截器的最后还要加个默认拦截器 <interceptor-ref name="defaultStack"></interceptor-ref> ，当自定义拦截器执行了，则默认拦截器不会执行。如果在action内没加任何拦截器，则默认使用默认拦截器

1.1自定义拦截器的第一种方式：实现 Interceptor接口

1. //定义一个拦截器1  
2. public class Interceptor1 implements  
3.         com.opensymphony.xwork2.interceptor.Interceptor {    
4.     @Override  
5.     public void destroy() {  
6.         // TODO Auto-generated method stub    
7.     }    
8.     @Override  
9.     public void init() {  
10.         // TODO Auto-generated method stub    
11.     }    
12.     @Override  
13.     public String intercept(ActionInvocation invocation) throws Exception {            
14.         System.out.println("Interceptor1 before");  
15.         String str = invocation.invoke() ;  
16.         System.out.println("Interceptor1 after");         
17.         return str;  
18.     }    
19. }    

1.2自定义拦截器的第二种方式：继承AbstractInterceptor抽象类

1. public class Interceptor2 extends AbstractInterceptor {    
2.     @Override  
3.     public String intercept(ActionInvocation invocation) throws Exception {            
4.         System.out.println("Interceptor2 before");  
5.         String str = invocation.invoke() ;  
6.         System.out.println("Interceptor2 after");  
7.         return str;  
8.     }    
9. }

1.3自定义拦截器的第三种方式：继承MethodFilterInterceptor抽象类

//定义一个拦截器3,可以拦截自定义的方法，而其他拦截器只拦截 execute方法  

1. public class Interceptor3 extends MethodFilterInterceptor {    
2.     @Override  
3.     protected String doIntercept(ActionInvocation invocation) throws Exception {            
4.         System.out.println("Interceptor3 before");  
5.         String str = invocation.invoke() ;  
6.         System.out.println("Interceptor3 after");  
7.         return str;  
8.     }    
9. }

2、在struts.xml 文件中定义拦截器（action标签外）

<struts>        

1.    <package name="struts2" extends="struts-default">          
2.       <!-- 定义拦截器 -->  
3.       <interceptors>  
4.           <interceptor name="interceptor1" class="com.struts2.interceptor.Interceptor1"></interceptor>           
5.           <interceptor name="interceptor2" class="com.struts2.interceptor.Interceptor2"></interceptor>           
6.           <interceptor name="interceptor3" class="com.struts2.interceptor.Interceptor3"></interceptor>  
7.       </interceptors></span>  

3、在struts.xml 文件中 的 action标签内引用 拦截器

1. <action name="action1" class="com.struts2.Action1" method="myExecute">  
2.     <result name="success" type="redirectAction">            
3.        <param name="actionName">action2</param> <!-- 重定向到 action2 -->           
4.        <!-- 重定向到 action2 并要携带的参数如下， -->  
5.        <param name="usename">${usename}</param>  
6.        <param name="password">${password}</param>            
7.     </result>        
8.     <!-- 引用拦截器 -->  
9.     <interceptor-ref name="interceptor1"></interceptor-ref>  
10.     <interceptor-ref name="interceptor2"></interceptor-ref>  
11.     <interceptor-ref name="interceptor3">  
12.        <param name="excludeMethods"></param>         
13.        <param name="includeMethods">execute</param>     
14.     </interceptor-ref>  
15.     <interceptor-ref name="defaultStack"></interceptor-ref>  
16. </action>  

假如用第三种方式定义拦截器的话，引用拦截器的时候还可以指定拦截的方法，excludeMethods 指定排除方法的拦截，includeMethods 把要拦截的方法包含进来，二者都可以排除多个方法，和包含多个方法，方法名用逗号‘  ，’隔开。就如上面引用拦截器的第三个来说，action 是执行自定义的myExecute()方法的，但 includeMethods包含是execute方法，所以interceptor3拦截器不会执行，如果没有指定拦截器的参数，默认会拦截全部方法应用一（登录，判断用户是否登录）：

1、定义一个拦截器类：

1. package com.struts2.interceptor;  
2.   
3. import java.util.Map;    
4. import com.opensymphony.xwork2.Action;  
5. import com.opensymphony.xwork2.ActionInvocation;  
6. import com.opensymphony.xwork2.interceptor.AbstractInterceptor;  
7. import com.struts2.LoginAction;  
8.   
9. public class LoginInterceptor extends AbstractInterceptor {    
10.     @Override  
11.     public String intercept(ActionInvocation invocation) throws Exception {            
12.         // 这个 LoginAction 是处理登陆的，当然不用检查session了  
13.         //invocation.getAction() 获取  action类的具体包  
14.         if(LoginAction.class == invocation.getAction().getClass() )  {  
15.             return invocation.invoke();  
16.         }            
17.         Map map =invocation.getInvocationContext().getSession();            
18.         if(null == map.get("usename"))  {  
19.              return Action.LOGIN; //如果用户还没登陆，跳到login页面  
20.         }            
21.         return invocation.invoke();  
22.     }    
23. }  

2、在struts.xml中定义 拦截器，和一个拦截器栈，注意 拦截器栈后也要加一个默认拦截器，接着再把我们定义的拦截器栈，设为默认的拦截器，这样的作用是拦截全部action，很显然拦截全部action不是我们所要的，我们还需要一些action不被拦截，上面的拦截器已经处理了，就在 intercept方法内，加了if(LoginAction.class == invocation.getAction().getClass() )  { return invocation.invoke();  }  就可以不对其进行 判断有没session。

在struts.xml中定义拦截器，和一个拦截器栈，默认的拦截器：注意 默认拦截器 定义的位置，是在interceptor外的。

1. <struts>        
2.    <package name="struts2" extends="struts-default">          
3.       <!-- 定义拦截器 -->  
4.       <interceptors>                     
5.           <interceptor name="LoginInterceptor" class="com.struts2.interceptor.LoginInterceptor">  
6.           </interceptor>              
7.           <!-- 定义一个拦截器栈 ， -->  
8.           <interceptor-stack name="MyDefaultInterceptor">  
9.               <interceptor-ref name="LoginInterceptor"></interceptor-ref>  
10.               <!-- 记得加上默认拦截器 -->  
11.               <interceptor-ref name="defaultStack"></interceptor-ref>  
12.           </interceptor-stack>             
13.       </interceptors>          
14.           <!-- 定义自己的默认拦截器 -->  
15.           <default-interceptor-ref name="MyDefaultInterceptor">             
16.           </default-interceptor-ref>  

3、定义一个全局的结果，在package标签下定义：

1. <global-results>  
2.     <result name="myexception1">/error.jsp</result>  
3.     <result name="login">/logingo.jsp</result>  
4. </global-results>  

这个全局结果 <result name="login">/logingo.jsp</result> 会被 LoginInterceptor拦截器的  Action.LOGIN;  找到

4、具体处理登录的action类

1. package com.struts2;  
2.   
3. import java.util.Map;    
4. import com.exception.MyException ;  
5. import com.opensymphony.xwork2.ActionContext;  
6.   
7. public class LoginAction {  
8.       
9.     private String usename ;  
10.     private String password ;  
11.       
12.     public String getUsename() {  
13.         return usename;  
14.     }  
15.     public void setUsename(String usename) {  
16.         this.usename = usename;  
17.     }  
18.     public String getPassword() {  
19.         return password;  
20.     }  
21.     public void setPassword(String password) {  
22.         this.password = password;  
23.     }  
24.       
25.     //这个方法不可少  
26.     public String execute() throws Exception  
27.     {  
28.         if(!"hello".equals(usename) || !"world".equals(password))  
29.         {  
30.             throw new MyException("用户名或密码错误，您发现了吧！");  
31.         }  
32.         Map session = ActionContext.getContext().getSession();  
33.         session.put("usename", usename) ;  
34.         return "success" ;  
35.     }  
36. }  

5、登陆界面logingo.jsp

1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
2. <%  
3. String path = request.getContextPath();  
4. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";  
5. %>    
6. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
7. <html>  
8.   <head>  
9.     <base href="<%=basePath%>">        
10.     <title>My JSP 'logingo.jsp' starting page</title>        
11.     <meta http-equiv="pragma" content="no-cache">  
12.     <meta http-equiv="cache-control" content="no-cache">  
13.     <meta http-equiv="expires" content="0">      
14.     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">  
15.     <meta http-equiv="description" content="This is my page">  
16.     <!-- 
17.     <link rel="stylesheet" type="text/css" href="styles.css"> 
18.     -->    
19.   </head>  
20.   <body>  
21.     <form action="login">  
22.         <input type="text" name="usename" /><br/>  
23.         <input type="password" name="password" /><br/>  
24.         <input type="submit" value="登录"/>  
25.     </form>      
26.   </body>  
27. </html>