Struts2牛逼的拦截器，卧槽这才是最牛的核心！

时间 2019-12-05

原文原文链接

struts 拦截器

一拦截器简介及简单的拦截器实例

　　Struts2拦截器是在访问某个Action或者Action的某个方法，在字段前或者以后实施拦截，而且Struts2拦截器是能够插拔的，拦截器是AOP的一种实现。前端

优势：通用功能的封装，提供可重用性。在struts-default.xml文件中能够看到拦截器栈basicStack.咱们在引用的时候引用的是默认的拦截器栈 <default-interceptor-ref name=”defaultStack”/>咱们写一个拦截器的例子：看一下拦截器是如何运行的，首先咱们创建一个HelloAction：java

 1 public class HelloAction extends ActionSupport{  2     private String name;  3     public String getName() {  4         return name;  5  }  6     public void setName(String name) {  7         this.name = name;  8  }  9     private static final long serialVersionUID = 1L; 10  @Override 11     public String execute() throws Exception { 12         This.name=”你好，构造器！”; 13         System.out.println("默认执行了Action的默认方法"); 14         return SUCCESS; 15  } 16 }

以后定义咱们本身的拦截器MyInterceptor:session

 1 public class Myinterceptor implements Interceptor{  2  @Override  3     public void destroy() {  4         // TODO Auto-generated method stub
 5         System.out.println("拦截器销毁");  6  }  7  @Override  8     public void init() {  9         // TODO Auto-generated method stub
10         System.out.println("拦截器初始化"); 11  } 12  @Override 13     public String intercept(ActionInvocation invocation) throws Exception { 14         // TODO Auto-generated method stub
15         System.out.println("Action以前调用拦截器！"); 16         String result=invocation.invoke(); 17         System.out.println("Action以后调用拦截器！"); 18         return result; 19  } 20 }

result可以返回Action默认方法的调用结果。Struts.xml文件中的配置：jsp

 1 <struts>
 2  <constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
 3     <package name="manage" namespace="/" extends="struts-default">
 4     <interceptors>
 5 <interceptor  6 name="myInterceptor" class="com.java1234.Interceptor.Myinterceptor">
 7 </interceptor>
 8     </interceptors>
 9         <global-results>
10             <result name="error">error.jsp</result>
11         </global-results>
12         <action name="hello" class="com.java1234.Action.HelloAction">
13             <result name="success">success.jsp</result>
14             <interceptor-ref name="myInterceptor"></interceptor-ref>
15             <interceptor-ref name="defaultStack"></interceptor-ref>//默认的拦截器是必须的！ 16         </action>
17     </package>
18 </struts>

Success.jsp核心代码：ide

1 <body>
2 Name:${name }
3 </body>

error.jsp代码：post

1 <body>
2     错误信息：${error } <br/>
3 </body>

运行结果显示：this

① 拦截器首先会被初始化：spa

②以后访问http://localhost:8080/Struts2Chap04/hello：code

先访问的是拦截器Myinterceptor------->接着访问HelloAction--------->访问拦截器，根据result的值为success进行模板页面跳转到success.jsp页面。拦截器Myinterceptor中的String result=invocation.invoke();能够获取到Action执行后的结果！出现结果为：orm

二简单的拦截器实例（登陆验证拦截器）

　　咱们有一个简单功能，就是登陆验证，对于登陆的用户能够直接访问gril.未登陆的用户会跳转到错误页面，须要登陆才能由此功能！

So，咱们开始吧：首先是建一个Model,命名为User:

 1 public class User {  2     private String userName;  3     private String password;  4     public String getUserName() {  5         return userName;  6  }  7     public void setUserName(String userName) {  8         this.userName = userName;  9  } 10     public String getPassword() { 11         return password; 12  } 13     public void setPassword(String password) { 14         this.password = password; 15  } 16 }

service判断，UserService:

1 public class UserService {
2     public boolean login(User user){
3         if("java".equals(user.getUserName())&&"123456".equals(user.getPassword())){
4             return true;
5         }else{
6             return false;
7         }
8     }
9 }

UserAction：

 1 public class UserAction extends ActionSupport{  2     private User user;  3     private UserService userService=new UserService();  4     private String error;  5     public User getUser() {  6         return user;  7  }  8     public void setUser(User user) {  9         this.user = user; 10  } 11     public String getError() { 12         return error; 13  } 14     public void setError(String error) { 15         this.error = error; 16  } 17     private static final long serialVersionUID = 1L; 18  @Override 19     public String execute() throws Exception { 20         // TODO Auto-generated method stub
21         if(userService.login(user)){ 22             ActionContext actionContext=ActionContext.getContext(); 23             Map<String, Object>session=actionContext.getSession(); 24             session.put("currentUser", user); 25             return SUCCESS; 26         }else{ 27             this.error="用户名或者密码错误"; 28             return "error"; 29  } 30  } 31 }

配置struts.xml文件：

 1 <struts>
 2 <constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
 3     <package name="manage" namespace="/" extends="struts-default">
 4 <interceptors>    
 5 <interceptor name="loginInterceptor" class="com.java1234.Interceptor.Logininterceptor">
 6 </interceptor>
 7 <interceptor-stack name="mystack">
 8     <interceptor-ref name="loginInterceptor"></interceptor-ref>
 9     <interceptor-ref name="defaultStack"></interceptor-ref>
10 </interceptor-stack>
11 </interceptors>
12         
<default-interceptor-ref name="mystack"></default-interceptor-ref> 

　　方法2 直接引用拦截器栈 能够省去<interceptor-ref name="loginInterceptor"></interceptor-ref>

<interceptor-ref name="defaultStack"></interceptor-ref>这部分代码。

14 <global-results>
15         <result name="error">error.jsp</result>
16     </global-results>
17     <action name="user" class="com.java1234.Action.UserAction">
18         <result name="success">success.jsp</result>
19         <interceptor-ref name="defaultStack"></interceptor-ref>
20     </action>
21     <action name="gril" class="com.java1234.Action.GrilAction">
22         <result name="success">success.jsp</result>
23         <interceptor-ref name="loginInterceptor"></interceptor-ref> 24 <interceptor-ref name="defaultStack"></interceptor-ref>

　　　　　　　　方法1 直接引用各个拦截器。直接明了

25 </action>
26     </package>
27 </struts>

Success.jsp文件：

1 <body>
2  当前登陆的用户为：${currentUser.userName } 3 </body>

error.jsp文件

1 <body>
2     错误信息：${error } <br/>
3     <a href="login.jsp">登陆</a>
4 </body>

Login.jsp文件：

1 <body>
2     <form action="user" method="post">
3         用户名：<input type="text" name="user.userName">&nbsp;&nbsp;
4         密  码：<input type="password" name="user.password"><br/>
5                 <input type="submit" value="登陆">
6 </form>
7 </body>

根据前端 http://localhost:8080/Struts2Chap04/login.jsp 显示页面：

输入应户名和密码。这个时候利用user请求，先通过默认拦截器的拦截验证，以后根据action=user，strut.xml文件中的配置action=user 由类UserAction处理 UserAction经过调用UserService来进行登陆判断，进而肯定是否登陆成功？如下两种状况：

①用户名为java 密码为 123456 登陆成功，跳转到success.jsp，显示登陆结果！

②用户名或者密码错误，登陆失败，跳转到error.jsp页面。

GrilAction代码：

1 public class GrilAction extends ActionSupport{ 2     private static final long serialVersionUID = 1L; 3  @Override 4     public String execute() throws Exception { 5         // TODO Auto-generated method stub
6         System.out.println("看美女！"); 7         return SUCCESS; 8  } 9 }

若是在前端输入http://localhost:8080/Struts2Chap04/gril ，会先进行拦截器的判断，进入到Logininterceptor拦截器的拦截判断中，

第一步：进入intercept方法。获取到actionContext，以后利用actionContext获取session,以后利用session获取当前用户，根据当前用户是否为空作出如下两个选择：

①currentUser不为空，那么就是说明已经登陆了，能够直接进行访问，因此这个时候进入到GrilAction中进行访问。

②currentUser为空，那么就是说明没有登陆，就不能直接访问了，这个时候咱们获取到request，利用request设置error，而且传递到前端，result设置为error。以后struts.xml根据result进行处理。

核心代码以下：

 1 ActionContext actionContext=invocation.getInvocationContext();  2         Map<String, Object> session=actionContext.getSession();  3         Object currentUser=session.get("currentUser");  4         String result=null;  5         if(currentUser!=null){  6             result=invocation.invoke();  7         }else{  8             HttpServletRequest request=(HttpServletRequest)invocation.getInvocationContext().get(ServletActionContext.HTTP_REQUEST);  9             request.setAttribute("error", "您未登陆，请先登陆！"); 10             result="error"; 11         }

拦截器先告一段落，咱们还会回来的！

Struts2牛逼的拦截器，卧槽这才是最牛的核心！

struts 拦截器

一 拦截器简介及简单的拦截器实例

二 简单的拦截器实例（登陆验证拦截器）

一拦截器简介及简单的拦截器实例

二简单的拦截器实例（登陆验证拦截器）