`
dengyin2000
  • 浏览: 1228762 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

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

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

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

我们先看看LoginInterceptor.java 
package com.javaeye.dengyin2000.wallet.interceptor;

import java.util.Map;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;
import org.apache.struts2.StrutsStatics;

import com.javaeye.dengyin2000.wallet.dao.UserDAO;
import com.javaeye.dengyin2000.wallet.dao.UserNotFoundException;
import com.javaeye.dengyin2000.wallet.domains.User;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

public class LoginInterceptor extends AbstractInterceptor {
	public static final String USER_SESSION_KEY="wallet.session.user";
	public static final String COOKIE_REMEMBERME_KEY="wallet.cookie.rememberme";
	public static final String GOING_TO_URL_KEY="GOING_TO";
	
	private UserDAO userDao;

	@Override
	public String intercept(ActionInvocation invocation) throws Exception {
		
		ActionContext actionContext = invocation.getInvocationContext();
		HttpServletRequest request= (HttpServletRequest) actionContext.get(StrutsStatics.HTTP_REQUEST);
		
		Map session = actionContext.getSession();
		if (session != null && session.get(USER_SESSION_KEY) != null){
			return invocation.invoke();
		}
		
		Cookie[] cookies = request.getCookies();
		if (cookies!=null) {
			for (Cookie cookie : cookies) {
				if (COOKIE_REMEMBERME_KEY.equals(cookie.getName())) {
					String value = cookie.getValue();
					if (StringUtils.isNotBlank(value)) {
						String[] split = value.split("==");
						String userName = split[0];
						String password = split[1];
						try {
							User user = userDao
									.attemptLogin(userName, password);
							session.put(USER_SESSION_KEY, user);
						} catch (UserNotFoundException e) {
							setGoingToURL(session, invocation);
							return "login";
						}
					} else {
						setGoingToURL(session, invocation);
						return "login";
					}
					return invocation.invoke();
				}
			}
		}
		setGoingToURL(session, invocation);
		return "login";
	}

	private void setGoingToURL(Map session, ActionInvocation invocation){
		String url = "";
		String namespace = invocation.getProxy().getNamespace();
		if (StringUtils.isNotBlank(namespace) && !namespace.equals("/")){
			url = url + namespace;
		}
		String actionName = invocation.getProxy().getActionName();
		if (StringUtils.isNotBlank(actionName)){
			url = url + "/" + actionName + ".action";
		}
		session.put(GOING_TO_URL_KEY, url);
	}
	
	public UserDAO getUserDao() {
		return userDao;
	}

	public void setUserDao(UserDAO userDao) {
		this.userDao = userDao;
	}

}


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

下面我们看看struts.xml 

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC 
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
	<package name="default" extends="struts-default">
		<interceptors>
			<interceptor name="loginInterceptor" class="loginInterceptor"></interceptor>
			<interceptor-stack name="loginDefaultStack">
				<interceptor-ref name="loginInterceptor"></interceptor-ref>
				<interceptor-ref name="defaultStack"></interceptor-ref>
			</interceptor-stack>
		</interceptors>
		<default-interceptor-ref name="loginDefaultStack"></default-interceptor-ref>
		<global-results>
			<result name="login" type="redirect">/login.jsp</result>
		</global-results>		
		<action name="index" class="indexAction">
			<result>/index.jsp</result>
		</action>
		<action name="logout" class="logoutAction"></action>
		
		<action name="login" class="loginAction" method="login">
			<result type="redirect">${goingToURL}</result>
			<result name="input">/login.jsp</result>
			<interceptor-ref name="defaultStack"></interceptor-ref>
		</action>
		
		<action name="register" class="registerAction">
			<result type="redirect">/login.jsp</result>
			<result name="input">/register.jsp</result>
			<interceptor-ref name="defaultStack"></interceptor-ref>
		</action>
	</package>
</struts>


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

<%@taglib prefix="s" uri="/struts-tags" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<title>Wallet-Login</title>
</head>
<body>
<h2>Login</h2> 
<s:actionmessage/>
<s:actionerror/>
<s:form action="login" method="post" validate="false" theme="xhtml">
<s:textfield name="loginName" label="Username"></s:textfield><br/>
<s:password name="password" label="Password"></s:password><br/>
<s:checkbox label="Remember Me" name="rememberMe"></s:checkbox>
<s:submit value="%{'Login'}"></s:submit> 
</s:form>
<a href="register.jsp">Register</a>
</body>
</html>


package com.javaeye.dengyin2000.wallet.actions;

import java.util.Map;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.apache.struts2.interceptor.CookiesAware;
import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.apache.struts2.interceptor.SessionAware;

import com.javaeye.dengyin2000.wallet.dao.UserDAO;
import com.javaeye.dengyin2000.wallet.dao.UserNotFoundException;
import com.javaeye.dengyin2000.wallet.domains.User;
import com.javaeye.dengyin2000.wallet.interceptor.LoginInterceptor;
import com.opensymphony.xwork2.ActionSupport;

public class LoginAction extends ActionSupport implements ServletResponseAware, ServletRequestAware, SessionAware, CookiesAware{

	private UserDAO userDao;
	private String loginName;
	private String password;
	private boolean rememberMe;
	private HttpServletResponse response;
	private HttpServletRequest request;
	private Map session;
	private Map cookies;
	private String goingToURL;
	public String getGoingToURL() {
		return goingToURL;
	}
	public void setGoingToURL(String goingToURL) {
		this.goingToURL = goingToURL;
	}
	public boolean isRememberMe() {
		return rememberMe;
	}
	public void setRememberMe(boolean rememberMe) {
		this.rememberMe = rememberMe;
	}
	public String getLoginName() {
		return loginName;
	}
	public void setLoginName(String loginName) {
		this.loginName = loginName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
	
	public String login()throws Exception{
		try {
			User user = userDao.attemptLogin(loginName, password);
			if (rememberMe){
				Cookie cookie = new Cookie(LoginInterceptor.COOKIE_REMEMBERME_KEY, user.getLoginName() + "==" + user.getPassword());
				cookie.setMaxAge(60 * 60 * 24 * 14);
				response.addCookie(cookie);
			}
			session.put(LoginInterceptor.USER_SESSION_KEY, user);
			String goingToURL = (String) session.get(LoginInterceptor.GOING_TO_URL_KEY);
			if (StringUtils.isNotBlank(goingToURL)){
				setGoingToURL(goingToURL);
				session.remove(LoginInterceptor.GOING_TO_URL_KEY);
			}else{
				setGoingToURL("index.action");
			}
			return SUCCESS;
		} catch (UserNotFoundException e) {
			addActionMessage("user name or password is not corrected.");
			return INPUT;
		}
	}
	public UserDAO getUserDao() {
		return userDao;
	}
	public void setUserDao(UserDAO userDao) {
		this.userDao = userDao;
	}
	public void setServletResponse(HttpServletResponse response) {
		this.response = response;
	}
	public void setServletRequest(HttpServletRequest request) {
		this.request = request;
	}
	public void setSession(Map session) {
		this.session = session;
	}
	public void setCookiesMap(Map cookies) {
		this.cookies = cookies;
	}
}


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

package com.javaeye.dengyin2000.wallet.actions;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;

import com.javaeye.dengyin2000.wallet.interceptor.LoginInterceptor;
import com.opensymphony.xwork2.ActionSupport;

public class LogoutAction extends ActionSupport implements ServletRequestAware , ServletResponseAware{

	private HttpServletRequest request;
	private HttpServletResponse response;

	public String execute() throws Exception{
		HttpSession session = request.getSession(false);
		if (session!=null)
			session.removeAttribute(LoginInterceptor.USER_SESSION_KEY);
		
		Cookie[] cookies = request.getCookies();
		if (cookies!=null) {
			for (Cookie cookie : cookies) {
				if (LoginInterceptor.COOKIE_REMEMBERME_KEY.equals(cookie
						.getName())) {
					cookie.setValue("");
					cookie.setMaxAge(0);
					response.addCookie(cookie);
					return "login";
				}
			}
		}
		return "login";
	}

	public void setServletRequest(HttpServletRequest request) {
		this.request = request;
	}

	public void setServletResponse(HttpServletResponse response) {
		this.response = response;
	}

}


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

applicationContext-struts.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC 
	"-//SPRING//DTD BEAN//EN" 
	"http://www.springframework.org/dtd/spring-beans.dtd">
	
<beans>
	<!-- Example of SAF2 action instantiated by Spring -->
    <!-- bean id="helloWorldAction" class="tutorial.HelloWorldAction" singleton="false" />
     -->
     <bean id="indexAction" class="com.javaeye.dengyin2000.wallet.actions.IndexAction" singleton="false"></bean>
     <bean id="loginAction" class="com.javaeye.dengyin2000.wallet.actions.LoginAction" singleton="false">
     	<property name="userDao" ref="userDao" />
     </bean>
     
     <bean id="logoutAction" class="com.javaeye.dengyin2000.wallet.actions.LogoutAction" singleton="false"></bean>
     
     <bean id="registerAction" class="com.javaeye.dengyin2000.wallet.actions.RegisterAction" singleton="false"></bean>
     
     <!-- the following is struts2 interceptors -->
     <bean id="loginInterceptor" class="com.javaeye.dengyin2000.wallet.interceptor.LoginInterceptor">
     	<property name="userDao" ref="userDao" />
     </bean>
     
     <bean id="userDao" class="com.javaeye.dengyin2000.wallet.dao.UserDAOImpl">
     </bean>
</beans>



参考：http://www.vitarara.org/cms/struts_2_cookbook/creating_a_login_interceptor
分享到：
| maven command to create your application
评论
17 楼 xo_knight 2008-12-16  
谢谢分享,小弟最崇拜的就是大侠你这种无私的人
16 楼 reckyxaut 2008-06-26  
我用aop作自动代理的时候，现在拦截Action的时候老是拦截不到，拦截Service没问题。action我是用DelegatingActionProxy代理，在aop配置中也设置了<property name="proxyTargetClass"><value>true</value></property>和
<property name="exposeProxy"><value>false</value></property>可是就是拦截不到。请指教
15 楼 taelons 2008-04-04  
实现认证/授权/RememberMe/SSO等功能的话，不如用acegi，不用写代码，全部xml配置
14 楼 chirs 2008-03-31  
拦截器是不是一定要写配置文件啊！
我的项目使用零配置文件方式运行的好像不行的！
不知道有没有好的建议！
13 楼 fizzwater 2008-03-24  
我保存cookie
cookieName为xxx
cookieValue为admin==123

在用拦截器读cookie时，只能得到名字xxx的cookie的cookieValue 只有admin
没有了“==123”

请问怎么回事？
12 楼 wangshare 2008-03-11  
用户名和加密后的密码可以保存在cookie里面，认证的时候，直接通过加密的密码来认证，如果有SSO的话，只要做比较方便。
11 楼 hantsy 2008-03-07  
gotoURL算法感觉有点问题，只能是/namespace/actionName.action形式，应该直接取浏览器的URL地址才对。
10 楼 张洪财 2008-02-11  
如果不把jsp放到WEB-INF.哪吗这个interceptor拦截器还能起做用？？ 也就是说这个interceptor能拦截非Action配置的请求？
9 楼 张洪财 2008-02-11  
http://www.iteye.com/topic/161889

8 楼 张洪财 2008-02-11  
如果我不把jsp放到WEB-INF.哪吗这个interceptor拦截器还能器做用？？  也就是说这个interceptor能拦截非Action配置的请求？
7 楼 flyzonemu 2008-01-31  
不错 struts2的interceptor是非常有用的!
6 楼 sunfuli888 2008-01-31  
看来，你很无私的呀，把这么多源代码都发了出来！
5 楼 dengyin2000 2008-01-31  
我这里只是举例而已。

你可以不用把密码保存在cookie中。 你只记住用户名就是了。 下次登入的时候直接用用户名到数据库里找到用户信息  不用匹配密码。
4 楼 xiaoxiaodi5834 2008-01-29  
我现在做的项目也是用Cookie的方式来实现单点登录（有多个应用集群）是记住Cookie的Session值，再将这个值放到数据库中的方式来实现的。
如果将用户名密码放到Cookie中的确存在安全隐患。
3 楼 Readonly 2008-01-29  
出于安全考虑，不应该把密码这种敏感数据保存在客户端cookie
2 楼 dengyin2000 2008-01-29  
这个没有关系。 你想怎么存就怎么存， 只要你能拿到username 和password
1 楼 xiaocheng882000 2008-01-25  
我有个小小的问题想问一下，那个cookie为什么要存为
["wallet.cookie.rememberme" : "username==password"]的形式？

直接存为["username" : "password"]不是更方便吗？

服务器好像会根据域名只拿它自己写到客户端的cookie吧？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    在struts2中使用拦截器(Interceptor)控制登录和权限[汇编].pdf

    在本文中，我们将深入探讨如何在Struts2中使用拦截器来控制登录和权限管理。 首先，让我们了解Interceptor的基本结构。在给出的`LoginInterceptor.java`代码中，可以看到拦截器是继承自`AbstractInterceptor`的。`...

    Struts2拦截器实现权限控制demo

    在Struts2中，拦截器是实现业务逻辑控制和增强功能的重要机制，它们扮演着类似于AOP（面向切面编程）的角色，允许在动作执行前后插入自定义逻辑。在这个“Struts2拦截器实现权限控制demo”中，我们将深入探讨如何...

    Struts2 拦截器 Interceptor

    在Struts2框架中，拦截器（Interceptor）是一种非常重要的机制，它能够帮助开发者实现诸如权限控制、事务管理、日志记录等跨切关注点的功能。通过定义不同的拦截器栈，可以灵活地组合各种功能，从而达到复用代码的...

    struts2 Interceptor拦截器

    在Struts2框架中，**Interceptor（拦截器）**是一个关键组件，它允许开发者在特定的动作（Action）执行前后添加自定义的处理逻辑，极大地增强了应用程序的灵活性。 #### 二、Interceptor 概念与作用 Interceptor ...

    struts2拦截器实现权限控制

    在Struts2中，拦截器扮演着至关重要的角色，它们是实现应用逻辑和业务规则的关键组件，尤其在权限控制方面。这篇博客文章“struts2拦截器实现权限控制”深入探讨了如何利用Struts2的拦截机制来执行用户访问权限的...

    struts2 用拦截器 实现用户权限登录

    在Struts2中，拦截器是实现业务逻辑和控制流程之间解耦的关键组件。本教程将详细介绍如何使用Struts2的拦截器来实现用户权限登录功能。 ### 一、拦截器的原理与作用 1. **原理**：拦截器工作在Action调用之前，它...

    使用struts2拦截器对登陆权限验证

    在Struts2中，拦截器（Interceptor）扮演着至关重要的角色，它允许开发者在动作执行前后插入自定义逻辑，如日志记录、权限验证等。在本案例中，我们将深入探讨如何使用Struts2拦截器实现登录权限验证，同时结合...

    struts2 拦截器实现登录控制

    在Struts2中，拦截器扮演着至关重要的角色，它们是实现业务逻辑、验证、日志、性能优化等核心功能的关键组件。这篇博客“struts2 拦截器实现登录控制”显然会探讨如何利用拦截器来实现用户登录验证，从而保护应用...

    Struts2学习案例(拦截器)

    在Struts2中，拦截器是基于Java的动态AOP（面向切面编程）实现的，它可以在Action调用前后插入额外的逻辑，比如日志记录、权限验证、事务管理等。拦截器通过配置文件或者注解与Action关联，形成一个拦截器栈，每个...

    Struts2拦截器及其用法详细说明

    在Struts2中，拦截器（Interceptors）扮演着核心角色，增强了框架的功能和灵活性。这篇文章将深入探讨Struts2拦截器的概念、工作原理以及如何在实际应用中使用它们。 **一、什么是Struts2拦截器** 拦截器是基于AOP...

    Struts2利用拦截器实现权限控制

    在Struts2中，拦截器是实现业务逻辑控制和增强功能的重要机制，它们扮演着中间件的角色，允许在请求到达Action之前或之后执行特定的操作。在权限控制场景下，拦截器尤为关键，可以用于验证用户是否有权访问特定的...

    Struts2 配置登陆拦截器

    在Struts2中，拦截器是实现业务逻辑控制和处理流程的重要组件，它们可以添加额外的功能，如日志记录、权限检查、事务管理等，而不干扰实际的业务操作。本篇文章将详细介绍如何配置Struts2的登录拦截器，以及其背后的...

    struts2拦截器

    在Struts2中，拦截器（Interceptor）是核心功能之一，用于增强应用的功能和处理业务逻辑。拦截器是基于AOP（面向切面编程）的概念，可以在动作执行前后插入额外的操作，比如日志记录、权限检查、数据验证等。 标题...

    struts2 拦截器实例

    在Struts2中，拦截器（Interceptor）扮演着核心角色，它们允许开发者在Action执行前后插入自定义的逻辑，如日志、权限检查、事务管理等。现在我们将深入探讨Struts2的拦截器机制及其实例应用。 ### 一、Struts2拦截...

    Struts2权限控制

    在Struts2中，拦截器扮演着至关重要的角色，它们是实现业务逻辑和控制流程的核心组件。本知识点主要聚焦于如何利用Struts2的拦截器进行权限控制。 **一、Struts2拦截器原理** 在Struts2中，拦截器是基于Java的动态...

    struts2 拦截器的使用（继承抽象拦截器）

    在Struts2中，拦截器是基于Java的动态代理机制实现的，它们按照配置的顺序形成一个拦截器链。每个拦截器都可以在Action执行之前或之后执行特定的任务，而无需修改Action本身。这遵循了“开闭原则”，使得代码更易于...

    一个Struts2的核心拦截器例子

    - 在Struts2中，拦截器是一个实现了`Interceptor`接口的类，它通过`ActionInvocation`对象来控制动作的执行流程。拦截器链是由多个拦截器按照指定顺序组成的，每个拦截器都可以在执行动作之前或之后进行操作。 2. ...

    创建自己struts2拦截器

    在Struts2中，拦截器是AOP（面向切面编程）的一种实现，它可以监控、修改或增强方法调用的行为。下面我们将详细介绍如何创建自定义的Struts2拦截器。 1. **理解Struts2拦截器工作原理** Struts2中的拦截器是一个...

    在struts1中使用拦截器——saif-0.1.jar

    2. **创建拦截器**：在saif-0.1.jar中，开发者可能已经定义了一些继承自`org.apache.struts.interceptor.Interceptor`接口的类。这些类实现了拦截器的逻辑，如`doIntercept()`方法。 3. **配置拦截器**：在struts-...

Magicbox
Global site tag (gtag.js) - Google Analytics