在struts2中使用拦截器（Interceptor）控制登录和权限

最新推荐文章于 2022-05-25 15:50:46 发布
最新推荐文章于 2022-05-25 15:50:46 发布
阅读量226 收藏
点赞数
文章标签： interceptor struts session cookies url servlet

在jsp servlet中我们通常使用Servlet Filter控制用户是否登入， 是否有权限转到某个页面。在struts2中我们应该会想到他的拦截器（Interceptor）， Interceptor在struts2中起着非常重要的作用。 很多struts2中的功能都是使用Interceptor实现的。 

需求：简单的登入界面，让用户输入用户名、密码、记住密码（remember me）。 如果用户选中remember me的话， 下次就不需要再登入了（使用cookie实现， 用需要点击logout取消remeber me功能）。 如果用户起始输入的地址不是登入页面的话，在用户登入之后需要转到用户输入的起始地址。 

我们先看看LoginInterceptor.java

  1. package  com.javaeye.dengyin2000.wallet.interceptor;  
  2.   
  3. import  java.util.Map;  
  4.   
  5. import  javax.servlet.http.Cookie;  
  6. import  javax.servlet.http.HttpServletRequest;  
  7.   
  8. import  org.apache.commons.lang.StringUtils;  
  9. import  org.apache.struts2.StrutsStatics;  
  10.   
  11. import  com.javaeye.dengyin2000.wallet.dao.UserDAO;  
  12. import  com.javaeye.dengyin2000.wallet.dao.UserNotFoundException;  
  13. import  com.javaeye.dengyin2000.wallet.domains.User;  
  14. import  com.opensymphony.xwork2.ActionContext;  
  15. import  com.opensymphony.xwork2.ActionInvocation;  
  16. import  com.opensymphony.xwork2.interceptor.AbstractInterceptor;  
  17.   
  18. public   class  LoginInterceptor  extends  AbstractInterceptor {  
  19.     public   static   final  String USER_SESSION_KEY= "wallet.session.user" ;  
  20.     public   static   final  String COOKIE_REMEMBERME_KEY= "wallet.cookie.rememberme" ;  
  21.     public   static   final  String GOING_TO_URL_KEY= "GOING_TO" ;  
  22.       
  23.     private  UserDAO userDao;  
  24.   
  25.     @Override   
  26.     public  String intercept(ActionInvocation invocation)  throws  Exception {  
  27.           
  28.         ActionContext actionContext = invocation.getInvocationContext();  
  29.         HttpServletRequest request= (HttpServletRequest) actionContext.get(StrutsStatics.HTTP_REQUEST);  
  30.           
  31.         Map session = actionContext.getSession();  
  32.         if  (session !=  null  && session.get(USER_SESSION_KEY) !=  null ){  
  33.             return  invocation.invoke();  
  34.         }  
  35.           
  36.         Cookie[] cookies = request.getCookies();  
  37.         if  (cookies!= null ) {  
  38.             for  (Cookie cookie : cookies) {  
  39.                 if  (COOKIE_REMEMBERME_KEY.equals(cookie.getName())) {  
  40.                     String value = cookie.getValue();  
  41.                     if  (StringUtils.isNotBlank(value)) {  
  42.                         String[] split = value.split("==" );  
  43.                         String userName = split[0 ];  
  44.                         String password = split[1 ];  
  45.                         try  {  
  46.                             User user = userDao  
  47.                                     .attemptLogin(userName, password);  
  48.                             session.put(USER_SESSION_KEY, user);  
  49.                         } catch  (UserNotFoundException e) {  
  50.                             setGoingToURL(session, invocation);  
  51.                             return   "login" ;  
  52.                         }  
  53.                     } else  {  
  54.                         setGoingToURL(session, invocation);  
  55.                         return   "login" ;  
  56.                     }  
  57.                     return  invocation.invoke();  
  58.                 }  
  59.             }  
  60.         }  
  61.         setGoingToURL(session, invocation);  
  62.         return   "login" ;  
  63.     }  
  64.   
  65.     private   void  setGoingToURL(Map session, ActionInvocation invocation){  
  66.         String url = "" ;  
  67.         String namespace = invocation.getProxy().getNamespace();  
  68.         if  (StringUtils.isNotBlank(namespace) && !namespace.equals( "/" )){  
  69.             url = url + namespace;  
  70.         }  
  71.         String actionName = invocation.getProxy().getActionName();  
  72.         if  (StringUtils.isNotBlank(actionName)){  
  73.             url = url + "/"  + actionName +  ".action" ;  
  74.         }  
  75.         session.put(GOING_TO_URL_KEY, url);  
  76.     }  
  77.       
  78.     public  UserDAO getUserDao() {  
  79.         return  userDao;  
  80.     }  
  81.   
  82.     public   void  setUserDao(UserDAO userDao) {  
  83.         this .userDao = userDao;  
  84.     }  
  85. }

首先判断session中有没有用户信息， 如果有的话继续， 如果没有的话，检查cookie中有没有rememberme的值，如果有的话，用==分割， 取得用户名密码进行登入。如果没有这个用户的话，记录下request的action地址然后转到登入页面。如果验证有这个用户，则继续下面的interceptor。 如果cookie中没有信息的话，则记录request的action地址然后转到登入页面。  以上就是LoginInterceptor的全部代码。 

下面我们看看struts.xml

  1. <?xml version= "1.0"  encoding= "UTF-8" ?>  
  2.   
  3. <!DOCTYPE struts PUBLIC   
  4.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"   
  5.     "http://struts.apache.org/dtds/struts-2.0.dtd" >  
  6.   
  7. <struts>  
  8.     <package  name= "default"   extends = "struts-default" >  
  9.         <interceptors>  
  10.             <interceptor name="loginInterceptor"   class = "loginInterceptor" ></interceptor>  
  11.             <interceptor-stack name="loginDefaultStack" >  
  12.                 <interceptor-ref name="loginInterceptor" ></interceptor-ref>  
  13.                 <interceptor-ref name="defaultStack" ></interceptor-ref>  
  14.             </interceptor-stack>  
  15.         </interceptors>  
  16.         <default -interceptor-ref name= "loginDefaultStack" ></ default -interceptor-ref>  
  17.         <global-results>  
  18.             <result name="login"  type= "redirect" >/login.jsp</result>  
  19.         </global-results>       
  20.         <action name="index"   class = "indexAction" >  
  21.             <result>/index.jsp</result>  
  22.         </action>  
  23.         <action name="logout"   class = "logoutAction" ></action>  
  24.           
  25.         <action name="login"   class = "loginAction"  method= "login" >  
  26.             <result type="redirect" >${goingToURL}</result>  
  27.             <result name="input" >/login.jsp</result>  
  28.             <interceptor-ref name="defaultStack" ></interceptor-ref>  
  29.         </action>  
  30.           
  31.         <action name="register"   class = "registerAction" >  
  32.             <result type="redirect" >/login.jsp</result>  
  33.             <result name="input" >/register.jsp</result>  
  34.             <interceptor-ref name="defaultStack" ></interceptor-ref>  
  35.         </action>  
  36.     </package >  
  37. </struts> 

我们是使用的默认的interceptor stack是loginInterceptor， 如果你需要让不登入的用户也能访问的话，你需要配置你的action使用defaultStack。 我们这里的login, register使用的就是defaultStack。 这里要注意的是success的result是我们用LoginInterceptor设过来的值。 这样我们就能够转到用户输入的起始页面。 下面我们再来看看login.jsp 和 loginAction

  1. <% @taglib  prefix= "s"  uri= "/struts-tags"  %>  
  2. <%@ page language="java"  contentType= "text/html; charset=UTF-8"   
  3.     pageEncoding="UTF-8" %>  
  4. <html>  
  5. <head>  
  6.     <meta http-equiv="Content-Type"  content= "text/html; charset=UTF-8" >  
  7.     <title>Wallet-Login</title>  
  8. </head>  
  9. <body>  
  10. <h2>Login</h2>   
  11. <s:actionmessage/>  
  12. <s:actionerror/>  
  13. <s:form action="login"  method= "post"  validate= "false"  theme= "xhtml" >  
  14. <s:textfield name="loginName"  label= "Username" ></s:textfield><br/>  
  15. <s:password name="password"  label= "Password" ></s:password><br/>  
  16. <s:checkbox label="Remember Me"  name= "rememberMe" ></s:checkbox>  
  17. <s:submit value="%{'Login'}" ></s:submit>   
  18. </s:form>  
  19. <a href="register.jsp" >Register</a>  
  20. </body>  
  21. </html>

  1. package  com.javaeye.dengyin2000.wallet.actions;  
  2.   
  3. import  java.util.Map;  
  4.   
  5. import  javax.servlet.http.Cookie;  
  6. import  javax.servlet.http.HttpServletRequest;  
  7. import  javax.servlet.http.HttpServletResponse;  
  8.   
  9. import  org.apache.commons.lang.StringUtils;  
  10. import  org.apache.struts2.interceptor.CookiesAware;  
  11. import  org.apache.struts2.interceptor.ServletRequestAware;  
  12. import  org.apache.struts2.interceptor.ServletResponseAware;  
  13. import  org.apache.struts2.interceptor.SessionAware;  
  14.   
  15. import  com.javaeye.dengyin2000.wallet.dao.UserDAO;  
  16. import  com.javaeye.dengyin2000.wallet.dao.UserNotFoundException;  
  17. import  com.javaeye.dengyin2000.wallet.domains.User;  
  18. import  com.javaeye.dengyin2000.wallet.interceptor.LoginInterceptor;  
  19. import  com.opensymphony.xwork2.ActionSupport;  
  20.   
  21. public   class  LoginAction  extends  ActionSupport  implements  ServletResponseAware, ServletRequestAware, SessionAware, CookiesAware{  
  22.   
  23.     private  UserDAO userDao;  
  24.     private  String loginName;  
  25.     private  String password;  
  26.     private   boolean  rememberMe;  
  27.     private  HttpServletResponse response;  
  28.     private  HttpServletRequest request;  
  29.     private  Map session;  
  30.     private  Map cookies;  
  31.     private  String goingToURL;  
  32.     public  String getGoingToURL() {  
  33.         return  goingToURL;  
  34.     }  
  35.     public   void  setGoingToURL(String goingToURL) {  
  36.         this .goingToURL = goingToURL;  
  37.     }  
  38.     public   boolean  isRememberMe() {  
  39.         return  rememberMe;  
  40.     }  
  41.     public   void  setRememberMe( boolean  rememberMe) {  
  42.         this .rememberMe = rememberMe;  
  43.     }  
  44.     public  String getLoginName() {  
  45.         return  loginName;  
  46.     }  
  47.     public   void  setLoginName(String loginName) {  
  48.         this .loginName = loginName;  
  49.     }  
  50.     public  String getPassword() {  
  51.         return  password;  
  52.     }  
  53.     public   void  setPassword(String password) {  
  54.         this .password = password;  
  55.     }  
  56.       
  57.       
  58.     public  String login() throws  Exception{  
  59.         try  {  
  60.             User user = userDao.attemptLogin(loginName, password);  
  61.             if  (rememberMe){  
  62.                 Cookie cookie = new  Cookie(LoginInterceptor.COOKIE_REMEMBERME_KEY, user.getLoginName() +  "=="  + user.getPassword());  
  63.                 cookie.setMaxAge(60  *  60  *  24  *  14 );  
  64.                 response.addCookie(cookie);  
  65.             }  
  66.             session.put(LoginInterceptor.USER_SESSION_KEY, user);  
  67.             String goingToURL = (String) session.get(LoginInterceptor.GOING_TO_URL_KEY);  
  68.             if  (StringUtils.isNotBlank(goingToURL)){  
  69.                 setGoingToURL(goingToURL);  
  70.                 session.remove(LoginInterceptor.GOING_TO_URL_KEY);  
  71.             }else {  
  72.                 setGoingToURL("index.action" );  
  73.             }  
  74.             return  SUCCESS;  
  75.         } catch  (UserNotFoundException e) {  
  76.             addActionMessage("user name or password is not corrected." );  
  77.             return  INPUT;  
  78.         }  
  79.     }  
  80.     public  UserDAO getUserDao() {  
  81.         return  userDao;  
  82.     }  
  83.     public   void  setUserDao(UserDAO userDao) {  
  84.         this .userDao = userDao;  
  85.     }  
  86.     public   void  setServletResponse(HttpServletResponse response) {  
  87.         this .response = response;  
  88.     }  
  89.     public   void  setServletRequest(HttpServletRequest request) {  
  90.         this .request = request;  
  91.     }  
  92.     public   void  setSession(Map session) {  
  93.         this .session = session;  
  94.     }  
  95.     public   void  setCookiesMap(Map cookies) {  
  96.         this .cookies = cookies;  
  97.     }  
  98. } 

 

差不多就是这么多代码了。 最后看看logoutAction

  1. package  com.javaeye.dengyin2000.wallet.actions;  
  2.   
  3. import  javax.servlet.http.Cookie;  
  4. import  javax.servlet.http.HttpServletRequest;  
  5. import  javax.servlet.http.HttpServletResponse;  
  6. import  javax.servlet.http.HttpSession;  
  7.   
  8. import  org.apache.struts2.interceptor.ServletRequestAware;  
  9. import  org.apache.struts2.interceptor.ServletResponseAware;  
  10.   
  11. import  com.javaeye.dengyin2000.wallet.interceptor.LoginInterceptor;  
  12. import  com.opensymphony.xwork2.ActionSupport;  
  13.   
  14. public   class  LogoutAction  extends  ActionSupport  implements  ServletRequestAware , ServletResponseAware{  
  15.   
  16.     private  HttpServletRequest request;  
  17.     private  HttpServletResponse response;  
  18.   
  19.     public  String execute()  throws  Exception{  
  20.         HttpSession session = request.getSession(false );  
  21.         if  (session!= null )  
  22.             session.removeAttribute(LoginInterceptor.USER_SESSION_KEY);  
  23.           
  24.         Cookie[] cookies = request.getCookies();  
  25.         if  (cookies!= null ) {  
  26.             for  (Cookie cookie : cookies) {  
  27.                 if  (LoginInterceptor.COOKIE_REMEMBERME_KEY.equals(cookie  
  28.                         .getName())) {  
  29.                     cookie.setValue("" );  
  30.                     cookie.setMaxAge(0 );  
  31.                     response.addCookie(cookie);  
  32.                     return   "login" ;  
  33.                 }  
  34.             }  
  35.         }  
  36.         return   "login" ;  
  37.     }  
  38.   
  39.     public   void  setServletRequest(HttpServletRequest request) {  
  40.         this .request = request;  
  41.     }  
  42.   
  43.     public   void  setServletResponse(HttpServletResponse response) {  
  44.         this .response = response;  
  45.     }  
  46.   
  47. } 

这里需要注意的是需要把cookie也清理下。

applicationContext-struts.xml

  1. <?xml version= "1.0"  encoding= "UTF-8" ?>  
  2. <!DOCTYPE beans PUBLIC   
  3.     "-//SPRING//DTD BEAN//EN"    
  4.     "http://www.springframework.org/dtd/spring-beans.dtd" >  
  5.       
  6. <beans>  
  7.     <!-- Example of SAF2 action instantiated by Spring -->  
  8.     <!-- bean id="helloWorldAction"   class = "tutorial.HelloWorldAction"  singleton= "false"  />  
  9.      -->  
  10.      <bean id="indexAction"   class = "com.javaeye.dengyin2000.wallet.actions.IndexAction"  singleton= "false" ></bean>  
  11.      <bean id="loginAction"   class = "com.javaeye.dengyin2000.wallet.actions.LoginAction"  singleton= "false" >  
  12.         <property name="userDao"  ref= "userDao"  />  
  13.      </bean>  
  14.        
  15.      <bean id="logoutAction"   class = "com.javaeye.dengyin2000.wallet.actions.LogoutAction"  singleton= "false" ></bean>  
  16.        
  17.      <bean id="registerAction"   class = "com.javaeye.dengyin2000.wallet.actions.RegisterAction"  singleton= "false" ></bean>  
  18.        
  19.      <!-- the following is struts2 interceptors -->  
  20.      <bean id="loginInterceptor"   class = "com.javaeye.dengyin2000.wallet.interceptor.LoginInterceptor" >  
  21.         <property name="userDao"  ref= "userDao"  />  
  22.      </bean>  
  23.        
  24.      <bean id="userDao"   class = "com.javaeye.dengyin2000.wallet.dao.UserDAOImpl" >  
  25.      </bean>  
  26. </beans> 

 

参考：http://www.vitarara.org/cms/struts_2_cookbook/creating_a_login_interceptor

sol929
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Struts2拦截器详解
Marvel__Dead 胡艺宝的博客
03-08 5053
成功的花儿，其间浸透了奋斗的泪水和汗水；然而，用泪水和汗水就可以实现一切的美好。Struts2拦截器概述 拦截器的概念是在Struts2里面有的。在其它地方没有。 Struts2是框架，封装了很多的功能，struts2里面封装的功能都是在拦截器里面。 Struts2里面封装了很多的功能，有很多拦截器，不是每次这些拦截器都执行，每次执行默认的拦截器。 Struts2里面默认的拦截器位置： struts
Struts2之拦截器
Never_Give_Up_Lin
05-08 426
struts2拦截器简单示例
struts2利用拦截器(Interceptor)判断用户是否登录
yeliner的博客
03-31 751
在struts2中，很重要的一个知识点就是拦截器，拦截器在action前后都会执行，主要是针对action的。因此我想到用拦截器来判断用户是否登录，当然这不是一个很好判断用户是否登录的方法，但是我希望可以通过这个例子，来增强对拦截器的认识。 1.自定义一个拦截器 public class ValidateInterceptor extends AbstractInterceptor { ...
struts2拦截器不执行问题
zhb200621的专栏
10-25 912
struts2自定义拦截器的配置博文很多，但按一些文章中配置好自定义拦截器后，设置为默认拦截器栈，拦截器方法intercept()却未被调用的问题，原因多种，以下为我问题的解决方式： 配置struts2.xml加上 原来其他项目中同样的配置却没出现不能被执行的问题，xml配置都差不多，可能深层问题在于action中注解的各项配置引发，有空再验证。 参考：http://struts
struts ajax不跳转页面,struts2 拦截器 跳转页面 ajax
weixin_39915700的博客
08-05 342
当前位置:我的异常网» 热门搜索»struts2 拦截器 跳转页面 ajaxstruts2 拦截器 跳转页面 ajaxwww.myexceptions.net网友分享于：2013-01-21搜索量：108次场景：struts2拦截器中，发现session过期，怎么在拦截到的ajax请求后跳转页面struts2拦截器中，发现session过期，如何在拦截到的ajax请求后跳转页面日前遇...
struts2如何使用拦截器进行用户权限控制实例
08-30
在Struts2中，拦截器可以单独使用或组合使用以实现复杂的逻辑。 在Struts2中，拦截器可以在多个地方进行配置，包括struts.xml文件、Action类和package中。struts.xml文件是Struts2的核心配置文件，用于定义Action、...
在struts2中使用拦截器(Interceptor)控制登录和权限[汇编].pdf
10-29
在本文中，我们将深入探讨如何在Struts2中使用拦截器来控制登录和权限管理。 首先，让我们了解Interceptor的基本结构。在给出的`LoginInterceptor.java`代码中，可以看到拦截器是继承自`AbstractInterceptor`的。`...
struts2 用拦截器 实现用户权限登录
11-14
在Struts2中，拦截器扮演着至关重要的角色，它们是实现业务逻辑和控制流程的核心组件。本教程将深入探讨如何使用Struts2拦截器来实现用户权限登录功能。 首先，了解拦截器的概念。拦截器是AOP（面向切面编程）的一...
Struts2拦截器实现权限控制demo
11-15
在Struts2中，拦截器（Interceptor）是其核心功能之一，它允许开发者在动作执行前后插入自定义的逻辑，比如日志记录、权限验证等。本教程将通过一个简单的“权限控制”拦截器示例，帮助初学者理解Struts2拦截器的...
Struts2拦截器Interceptor的原理与配置实例详解
08-28
例如，如果你有一个登录验证的需求，可以在每个Action执行前，使用拦截器检查用户是否已登录和是否具有相应的访问权限，这样可以避免在每个Action中重复编写相同的代码。 ### 二、Struts2拦截器接口实现 自定义...
struts2拦截器不起作用
King的专栏
05-28 1329
为什么拦截器不起作用
Struts2 拦截器（Interceptor ）原理和配置
别样的风采是我
09-17 725
一、Struts2拦截器原理： Struts2拦截器的实现原理相对简单，当请求struts2的action时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表，最后一个一个地调用列表中的拦截器。 比如：应用要求用户登陆，且必须为指定用户名才可以查看系统中某个视图资源；否则，系统直接转入登陆页面。对于上面的需求，可以在每个Action的执行实际处理逻辑
struts2 中拦截器和Action 参数传递不过去
独断万码
05-25 265
struts2 中拦截器和Action 参数传递不了
Struts2拦截器Interceptor的使用
BullZeng的博客
03-23 969
一、拦截器的使用： 只有用户登录时才可以查看商品，否则点击查看商品时会跳回login登录页面。 struts2.xml中拦截器Interceptor的配置： <interceptors> <!-- 声明自定义的拦截器 --> <interceptor name="myInterceptor" class="Interceptor.MyInterceptor...
struts2用户是否登录拦截器，拦截之后异步跳转到登录页面
a281246240的专栏
08-20 4519
先贴贴代码 struts.xml中代码： <interceptor name="sessionout" class="interceptor.AdminInterceptor"> list*,delete*,update*,save*,find* /pa
Unable to load config class org.apache.struts2.interceptor.debugging.DebuggingInterceptor at interce
德州仪器
03-03 4175
项目启动报错...网上找了半天资料...有一句话提醒了我 “可以删除struts2-core-2.0.11.2.jar包,肯定你服务器里的lib里有这个包,你项目中也存在这个包,所以你启动时就会出现这样的冲突错误,删除一个你服务器lib里的同名包即可”， 终于找到原因所在，先前有个项目我增加了classpath，WEB-INF也有Struts2的Jar包，所以tomcat启动时就报那个错误了。
Struts 2的基石——拦截器（Interceptor）
vvggsky的专栏
12-08 1153
什么是拦截器拦截器，在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提
Struts2学习笔记（八） 拦截器（Interceptor）(上)
java 学习
05-19 164
什么是拦截器（Interceptor） 拦截器是struts2框架最重要的特性之一。它可以让你在Action 方法执行前后（Result执行之后）进行一些功能处理。在前面学习Action和学习Result的时候我们就已经开始学习拦截器了，因此现在我们对如何使用它已经不陌生了。 在学习Spring的时候我们会接触到一种设计思想，叫做面向切面编程(AOP)。也就是说我们将一些通用的功能组件抽取出来...
struts2 存取cookie
心有猛虎,细嗅蔷薇
09-28 1664
1.首先Action要实现CookiesAware接口，包括：添加类型为Map的field（在所示代码中名为cookie），并实现setCookiesMap方法。  1 public class BasicAction extends ActionSupport implements CookiesAware{ 2 3 ... 4 5  private MapString,
深入理解Struts2拦截器Interceptor
"本文将深入探讨Struts2框架中的Interceptor（拦截器）机制，以及其在实际应用中的工作原理。" Struts2 Interceptor是该框架的核心组件之一，它允许开发者在Action执行前后插入自定义逻辑，实现了AOP（面向切面编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值