`
anzn20
  • 浏览: 87575 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

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

StrutsApacheServletJSPDAO 
阅读更多
struts2中使用拦截器（Interceptor）控制登录和权限
转载：http://www.itpub.net/thread-966462-1-1.html

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

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

我们先看看LoginInterceptor.java
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;   
    }   
  
}  

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

Java代码 
<?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>  

<?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

Java代码 
<%@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/>   
<sassword name="password" label="Password"></sassword><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>  

<%@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/>
<sassword name="password" label="Password"></sassword><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>

Java代码 
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;   
    }   
}  

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 

Java代码 
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;   
    }   
  
}  

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 
Java代码 
<?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>
分享到：
| java Tag
评论
3 楼 anzn20 2009-10-19  
gavinxixi 写道
Cookie不起效哦……怎么回事呢？

你看是不是被禁用了嘛。打印Cookie有值没有撒？
2 楼 Irving_wei 2009-10-13  
全部是裸奔的代码！
1 楼 gavinxixi 2009-06-02  
Cookie不起效哦……怎么回事呢？
发表评论

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

相关推荐

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

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

    Struts2拦截器实现权限控制demo

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

    Struts2 拦截器 Interceptor

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

    struts2 Interceptor拦截器

    ### Struts2 Interceptor 拦截器详解 #### 一、概述 在现代Web开发中，特别是基于Java的Web应用程序开发中，Struts2框架因其简洁性和强大的扩展能力而备受青睐。Struts2框架的核心设计理念之一是MVC（Model-View-...

    struts2拦截器实现权限控制

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

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

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

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

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

    struts2 拦截器实现登录控制

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

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

    这篇文章将深入探讨Struts2拦截器的概念、工作原理以及如何在实际应用中使用它们。 **一、什么是Struts2拦截器** 拦截器是基于AOP（面向切面编程）思想的组件，它可以理解为在Action调用前后插入的逻辑处理。在...

    Struts2学习案例(拦截器)

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

    Struts2 配置登陆拦截器

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

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

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

    一个Struts2的核心拦截器例子

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

    struts2 拦截器实例

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

    struts2拦截器

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

    Struts2权限控制

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

    创建自己struts2拦截器

    Struts2中的拦截器是一个实现了`Interceptor`接口或者继承了`AbstractInterceptor`抽象类的Java类。当一个请求到达时，Struts2会按照配置的拦截器栈顺序逐个调用这些拦截器，然后执行Action，最后再按逆序返回。...

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

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

    struts2中拦截器的使用

    在Struts2中，拦截器的使用主要基于两个方面：配置文件中的声明式使用和注解的编程式使用。首先，我们来看看配置文件中的声明式使用。在struts.xml或类似的配置文件中，你可以通过`&lt;interceptor&gt;`元素定义拦截器，并...

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