`

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

StrutsBeanApacheServletJSP 
阅读更多

在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/>   
<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> 
<%@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>


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> 

 

分享到：
| 使用 Spring 2.5 注释驱动的 IoC 功能(2 ...
评论
发表评论

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

相关推荐

    在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