Struts2拦截器

发布于 2020-04-14  321 热度

Struts2执行流程

客户端向服务器发送一个Action的请求
执行核心过滤器的doFilter()方法。
在doFilter()方法中，调用executeAction()方法，
在executeAction()内部调用dispatcher.serviceAction();
在serviceAction()内部创建一个Action代理，
最终执行的是Action代理中的execute(),
在代理中执行的execute方法中调用ActionInvocation的invoke方法。
在invoke方法内部递归执行一组拦截器（完成部分功能），如果没有下一个拦截器，就会执行目标Action，根据Action的返回的结果进行页面跳转。
Struts2拦截器

拦截器与过滤器

拦截器

什么是拦截器

拦截器，在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。
在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。
谈到拦截器，还有一个词大家应该知道——拦截器链（Interceptor Chain，在Struts 2中称为拦截器栈 Interceptor Stack）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

拦截器的实现原理

大部分时候，拦截器方法都是通过代理的方式来调用的。Struts 2的拦截器实现相对简单。当请求到达Struts 2的ServletDispatcher时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后形成一个拦截器栈，一个一个地调用列表中的拦截器。

过滤器

什么是过滤器

过滤器是一个程序，它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息。在这之后，过滤器可以作如下的选择：
①以常规的方式调用资源（即，调用servlet或JSP页面）。
②利用修改过的请求信息调用资源。
③调用资源，但在发送响应到客户机前对其进行修改。
④阻止该资源调用，代之以转到其他的资源，返回一个特定的状态代码或生成替换输出。

Servlet过滤器的基本原理

在Servlet作为过滤器使用时，它可以对客户的请求进行处理。处理完成后，它会交给下一个过滤器处理，这样，客户的请求在过滤链里逐个处理，直到请求发送到目标为止。例如，某网站里有提交“修改的注册信息”的网页，当用户填写完修改信息并提交后，服务器在进行处理时需要做两项工作：判断客户端的会话是否有效；对提交的数据进行统一编码。这两项工作可以在由两个过滤器组成的过滤链里进行处理。当过滤器处理成功后，把提交的数据发送到最终目标；如果过滤器处理不成功，将把视图派发到指定的错误页面。

拦截器与过滤器的区别

  1. 拦截器是基于java的反射机制的，而过滤器是基于函数回调。
  2. 拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
  3. 拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
  4. 拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
  5. 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次

拦截器入门

搭建Struts2的环境

编写Action类

ActionDemo1.java:

package com.itheima.web.action;
import com.opensymphony.xwork2.ActionSupport;
public class ActionDemo1 extends ActionSupport{
    @Override
    public String execute() throws Exception {
        System.out.println("ActionDemo1执行了...");
        return super.execute();
    }
}

编写JSP

demo1.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>demo1.jsp</h1>
<%
    System.out.println("demo1.jsp执行了...");
%>
</body>
</html>

编写拦截器类

编写一个类实现Interceptor接口或者继承AbstractInterceptor类。

InterceptorDemo1.java:

package com.itheima.web.interceptor;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
/**
 * 自定义的拦截器一
 * @author jt
 *
 */
public class InterceptorDemo1 extends AbstractInterceptor{
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("InterceptorDemo1执行了...");
        String obj = invocation.invoke();
        System.out.println("InterceptorDemo1执行结束了...");
        return obj;
    }
}

InterceptorDemo2.java:

package com.itheima.web.interceptor;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
/**
 * 自定义的拦截器一
 * @author jt
 *
 */
public class InterceptorDemo2 extends AbstractInterceptor{
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("InterceptorDemo2执行了...");
        String obj = invocation.invoke();
        System.out.println("InterceptorDemo2执行结束了...");
        return obj;
    }
}

编写配置文件

有两种方式。
第一种，直接引入需要的拦截器：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <package name="demo1" extends="struts-default" namespace="/">
        <!-- 定义拦截器========== -->
        <interceptors>
            <interceptor name="interceptorDemo1" class="com.itheima.web.interceptor.InterceptorDemo1"/>
            <interceptor name="interceptorDemo2" class="com.itheima.web.interceptor.InterceptorDemo2"/>
        </interceptors> 

        <action name="actionDemo1" class="com.itheima.web.action.ActionDemo1">
            <result>/demo1/demo1.jsp</result>

            <!-- 引入拦截器(一旦引入自定义拦截器，默认拦截器栈的拦截器就不执行了。)=========== -->
            <!-- 所以必须自己配置引入默认拦截器栈 -->
            <interceptor-ref name="defaultStack"/>
            <interceptor-ref name="interceptorDemo1"/>
            <interceptor-ref name="interceptorDemo2"/>
        </action>
    </package>
</struts>

第二种，创建自定义拦截器栈

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>

    <package name="demo1" extends="struts-default" namespace="/">
        <!-- 定义拦截器========== -->
        <interceptors>
            <interceptor name="interceptorDemo1" class="com.itheima.web.interceptor.InterceptorDemo1"/>
            <interceptor name="interceptorDemo2" class="com.itheima.web.interceptor.InterceptorDemo2"/>
            <!-- 定义拦截器栈 -->
            <interceptor-stack name="myStack">
                <interceptor-ref name="defaultStack"/>
                <interceptor-ref name="interceptorDemo1"/>
                <interceptor-ref name="interceptorDemo2"/>
            </interceptor-stack>
        </interceptors> 

        <action name="actionDemo1" class="com.itheima.web.action.ActionDemo1">
            <result>/demo1/demo1.jsp</result>
            <!-- 引入拦截器（栈）=========== -->
            <interceptor-ref name="myStack"/>
        </action>
    </package>
</struts>

执行效果

访问actionDemo1.action，控制台打印：

InterceptorDemo1执行了...
InterceptorDemo2执行了...
ActionDemo1执行了...
demo1.jsp执行了...
InterceptorDemo2执行结束了...
InterceptorDemo1执行结束了...

使用拦截器实现权限拦截

用拦截器实现用户未登录时拦截并跳转到登录页。

创建表和实体

创建表

sys_user:

CREATE TABLE `sys_user` (
  `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `user_code` varchar(32) NOT NULL COMMENT '用户账号',
  `user_name` varchar(64) NOT NULL COMMENT '用户名称',
  `user_password` varchar(32) NOT NULL COMMENT '用户密码',
  `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

创建实体

User.java:

public class User {
    private Long user_id;
    private String user_code;
    private String user_name;
    private String user_password;
    private String user_state;
    //get、set、toString省略
}

提交数据到Action

UserAction.java:

package com.itheima.web.action;

import org.apache.struts2.ServletActionContext;

import com.itheima.domain.User;
import com.itheima.service.UserService;
import com.itheima.service.impl.UserServiceImpl;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;

/**
 * 用户的Action的类
 * @author jt
 *
 */
public class UserAction extends ActionSupport implements ModelDriven<User>{
    // 接收数据:
    private User user = new User();
    @Override
    public User getModel() {
        return user;
    }

    /**
     * 用户登录的方法:
     */
    public String login(){
        System.out.println(user);
        // 调用业务层:
        UserService userService = new UserServiceImpl();
        User existUser = userService.login(user);
        // 根据结果页面跳转：
        if(existUser == null){
            // 登录失败
            // ActionError、FieldError、ActionMessage
            this.addActionError("用户名或密码错误！");
            return LOGIN;
        }else{
            // 登录成功
            // ActionContext.getContext().getSession().put("existUser", "existUser");
            ServletActionContext.getRequest().getSession().setAttribute("existUser", existUser);
            return SUCCESS;
        }
    }
}

Service

UserServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;
import com.itheima.domain.User;
import com.itheima.service.UserService;
/**
 * 用户的业务层的实现类
 * @author jt
 *
 */
public class UserServiceImpl implements UserService {

    @Override
    // 业务层用户登录的方法:
    public User login(User user) {
        UserDao userDao = new UserDaoImpl();
        return userDao.login(user);
    }
}

Dao

UserDaoImpl.java

package com.itheima.dao.impl;

import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.itheima.dao.UserDao;
import com.itheima.domain.User;
import com.itheima.utils.HibernateUtils;
/**
 * 用户DAO的实现类
 * @author jt
 *
 */
public class UserDaoImpl implements UserDao {

    @Override
    // 用户的DAO的登录的方法:
    public User login(User user) {
        Session session = HibernateUtils.getCurrentSession();
        Transaction tx = session.beginTransaction();

        Query query = session.createQuery("from User where user_code=? and user_password=?");
        // 设置参数:
        query.setParameter(0, user.getUser_code());
        query.setParameter(1, user.getUser_password());
        List<User> list = query.list();
        if(list.size()>0){
            return list.get(0);
        }
        tx.commit();
        return null;
    }
}

JSP页面

login.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/frameset.dtd">
<HTML xmlns="http://www.w3.org/1999/xhtml">
    <BODY>
        <FORM action="${ pageContext.request.contextPath }/user_login.action" method=post>
            <s:actionerror/>
            登 录 名：<INPUT type="text" name="user_code"/><br/>
            登录密码：<INPUT type="password" name="user_password"/><br/>
            <INPUT type="submit"/>
        </FORM>
    </BODY>
</HTML>

index.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/frameset.dtd">
<HTML>
<HEAD>
<TITLE>首页</TITLE>
</HEAD>
<body>
    这是首页！
</body>
</HTML>

拦截器

PrivilegeInterceptor.java:

package com.itheima.web.interceptor;

import org.apache.struts2.ServletActionContext;

import com.itheima.domain.User;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

/**
 * 权限拦截器
 * 
 * @author jt
 */
public class PrivilegeInterceptor extends MethodFilterInterceptor {
    @Override
    protected String doIntercept(ActionInvocation invocation) throws Exception {
        // 判断session中是否存在用户数据:
        User existUser = (User) ServletActionContext.getRequest().getSession().getAttribute("existUser");
        // 判断从session中获取的用户的信息是否为空:
        if(existUser == null){
            // 没有登录
            // 给出提示信息
            ActionSupport actionSupport = (ActionSupport) invocation.getAction();
            actionSupport.addActionError("没有登录！没有权限访问！");
            // 回到登录页面
            return actionSupport.LOGIN;
        }else{
            // 已经登录
            return invocation.invoke();
        }
    }
}

配置文件

struts.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!-- 配置Struts2的常量 -->
    <constant name="struts.action.extension" value="action"/>

    <package name="crm" extends="struts-default" namespace="/">
        <!-- 定义拦截器 -->
        <interceptors>
            <interceptor name="privilegeInterceptor" class="com.itheima.web.interceptor.PrivilegeInterceptor"/>
        </interceptors>

        <global-results>
            <result name="login">/login.jsp</result>
        </global-results>

        <action name="user_*" class="com.itheima.web.action.UserAction" method="{1}">
            <result name="success" type="redirect">/index.jsp</result>

            <!-- 引入拦截器 -->
            <interceptor-ref name="privilegeInterceptor">
                <param name="excludeMethods">login</param>
            </interceptor-ref>
            <interceptor-ref name="defaultStack"/>
        </action>
    </package>
</struts>

我一直在开辟我的天空