Java进阶知识03 Struts2下的拦截器（interceptor）和 过滤器（Filter）

一、拦截器  

1.1、首先创建一个拦截器类  

package com.bw.bms.interceptor;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.ActionProxy;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

/**
 * @author DSHORE/2019-9-5
 * 拦截器：拦截action
 */
public class LoginInterceptor extends AbstractInterceptor {

    @Override   //对Action的方法的拦截（核心方法），注：这里，其他方法都删掉了，只留了核心方法
    public String intercept(ActionInvocation invocation) throws Exception {
        // 拿到当前执行的方法名，判断，只要当前方法名不是login，就要进行验证
        // 获取ActionContext对象
        ActionContext context = invocation.getInvocationContext();
        // 获取action的代理对象
        ActionProxy proxy = invocation.getProxy();
        // 获取当前执行的方法名
        String methodName = proxy.getMethod();
        // 判断
        //System.out.println("methodName:" + methodName);
        if (!"login".equals(methodName)) {
            // 先获取当前登录的用户
            String account = (String) context.getSession().get("account");
            System.out.println("account:" + account);
            if (account == null) { // 未登录
                return "input";
            } else { // 当前用户已经登录
                return invocation.invoke();   //invocation.invoke():返回值 success/error
            }
        } else {
            // 正在执行login操作
            return invocation.invoke();
        }
    }
}

1.2、配置拦截器 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>
    <!-- true支持动态方法调用 -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    <constant name="struts.devMode" value="true" /> <!-- true -->



    <package name="manager" namespace="/manager" extends="struts-default">

<!-- -------------------------------------------------------------- -->
        <!-- 【拦截器配置，开始】 -->
        <interceptors>
            <!-- 配置用户自定义的拦截器 -->
            <interceptor name="loginInterceptor" class="com.bw.bms.interceptor.LoginInterceptor"></interceptor>
            <!-- 自定义一个栈： 要引用默认栈、自定义的拦截器 -->
            <interceptor-stack name="loginStack">
                <!-- 引用默认栈 (一定要放到第一行) -->
                <interceptor-ref name="defaultStack"></interceptor-ref>
                <!-- 引用自定义拦截器 -->
                <interceptor-ref name="loginInterceptor"></interceptor-ref>
                <!-- 指定拦截哪些方法需要防止表单重复提交(add) -->
                <interceptor-ref name="token">
                    <param name="includeMethods">login,add,update,delete</param>   <!-- excludeMethods：指定哪些不拦截 -->
                </interceptor-ref>
            </interceptor-stack>
        </interceptors>  <!-- 【拦截器配置，结束】 -->

        <!-- 【执行拦截器】 -->
        <default-interceptor-ref name="loginStack"></default-interceptor-ref>
<!-- -------------------------------------------------------------- -->

        <action name="*_*" class="com.bw.bms.action.{1}Action" method="{2}">
            <result name="success">/manager/{1}_{2}_Success.jsp</result><!-- 登陆成功、查询所有 -->
            <result name="error">/manager/{1}_{2}_Error.jsp</result><!-- 登录时，账号或密码错误 -->
            <result name="input" type="redirect">/index.jsp</result><!-- 用户不存在、注销成功、未登录转态 -->
            <result name="operateSuccess" type="redirectAction">Book_list</result><!-- 添加、删除、修改操作 -->
            <result name="update">/manager/Book_update.jsp</result><!-- 根据id查询指数据 -->
            
            <!-- 防止表单重复提交，第三步： 如果用户重复提交了跳转到指定的错误页面 -->
            <result name="invalid.token" type="redirectAction">Book_list</result>
        </action>
    </package>
</struts>

1.3、登录和注销的代码  

package com.bw.bms.action;

import java.util.Map;

import com.bw.bms.model.Admin;
import com.bw.bms.service.IAdminService;
import com.bw.bms.service.impl.AdminService;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;

/**
 * @author DSHORE/2019-9-5
 * 
 */
public class AdminAction extends ActionSupport implements ModelDriven<Admin> {
    // 使用了模型驱动进行传参，对象必须创建
    private Admin admin = new Admin();

    IAdminService adminService = new AdminService();

    @Override
    public Admin getModel() {
        return admin;
    }

    //登录
    public String login() {
        String account = admin.getAccount().trim();
        String password = admin.getPassword().trim();
        Admin adm = adminService.findByAccount(account);
        if (adm == null) { // 用户不存在，重新登录
            return INPUT;
        } else {
            if (password.equals(adm.getPassword())) {
                ActionContext.getContext().getSession().put("account", account);
                return SUCCESS;
            } else { // 密码错误，重新登录
                return ERROR;
            }
        }
    }

    //注销
    public String logout() {
        Map<String, Object> session = ActionContext.getContext().getSession();
        //String acc = (String) session.get("account");   //Map<"account","huang">
        if (session.get("account") != null) {
            session.remove("account");
        }
        return INPUT;
    }

    public Admin getAdmin() {
        return admin;
    }

    public void setAdmin(Admin admin) {
        this.admin = admin;
    }
}

1.4、其他代码（上方struts.xml配置文件中action里面相关的代码） 

package com.bw.bms.action;

import java.util.ArrayList;
import java.util.List;

import com.bw.bms.model.Book;
import com.bw.bms.service.IBookService;
import com.bw.bms.service.impl.BookService;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.opensymphony.xwork2.util.ValueStack;

/**
 * @author DSHORE/2019-9-5
 * 
 */
public class BookAction extends ActionSupport implements ModelDriven<Book> {
    private Book book = new Book();
    private List<Book> books = new ArrayList<Book>();

    IBookService bookService = new BookService();

    //查询所有
    public String list() {
        books = bookService.listAll();
        return SUCCESS;
    }

    //添加
    public String add() {
        bookService.add(book);
        return "operateSuccess";
    }
    
    //删除
    public String delete() {
        Integer id = book.getId();
        bookService.delete(id);
        return "operateSuccess";
    }
    
    //查询指定id的数据（执行修改操作前，需要先查询出要修改的那条数据）
    public String toUpdate() {
        Integer id = book.getId();
        Book updateBook = bookService.findById(id);
        ValueStack valueStack = ActionContext.getContext().getValueStack();// 先进后出
        valueStack.pop(); // 移除栈顶元素
        valueStack.push(updateBook); // 压栈
        return "update";
    }

    //修改
    public String update() {
        bookService.update(book);
        return "operateSuccess";
    }

    @Override
    public Book getModel() {
        return book;
    }

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }

    public List<Book> getBooks() {
        return books;
    }

    public void setBooks(List<Book> books) {
        this.books = books;
    }
}

二、过滤器  

2.1、自定义一个过滤器（和上面的拦截器是一套代码里面的）  

EntranceFilter.Java 类

package com.bw.bms.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * @author DSHORE/2019-9-5
 * 过滤器：过滤页面（jsp、html等页面）
 */
public class EntranceFilter implements Filter {

    @Override
    public void destroy() {
        // TODO Auto-generated method stub
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest servletRequest = (HttpServletRequest) request;
        HttpServletResponse servletResponse = (HttpServletResponse) response;
        HttpSession session = servletRequest.getSession();

        // 获得用户请求的URI
        String path = servletRequest.getRequestURI();
        System.out.println("###########path:" + path);
        // 从session里取
        String account = (String) session.getAttribute("account");
        // 判断当前的jsp是否是index.jsp，如果是放行，否则的话：（1）已经登录——放行、（2）未登录——index.jsp
        if ((path.indexOf("login.action") > -1 ) || (path.indexOf("index.jsp") > -1 )) {
            /**
             * index.jsp 不需要过过滤  Admin_login.action 不需要过过滤，
             * Admin_login_Success.jsp 需要过滤，不允许进来 Admin_login_Error.jsp
             */
            System.out.println("!!!!!!!!!!!!!path:" + path);
            chain.doFilter(servletRequest, servletResponse);
            return;
        } else {
            // 判断如果没有取到管理员信息,就跳转到登陆页面
            if (account == null || "".equals(account)) { // account.equals("")错误
                // 跳转到登陆页面
                String basePath = request.getScheme() + "://"
                        + request.getServerName() + ":"
                        + request.getServerPort()
                        + ((HttpServletRequest) request).getContextPath();
                servletResponse.sendRedirect(basePath + "/index.jsp");
            } else { // 通过
                // 已经登陆,继续此次请求
                chain.doFilter(request, response);
            }
        }
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
        // TODO Auto-generated method stub
    }
}

web.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <display-name></display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    
    <filter><!--  自定义过滤器  开始-->
        <filter-name>EntranceFilter</filter-name>
        <filter-class>com.bw.bms.filter.EntranceFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>EntranceFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <url-pattern>/manager/*</url-pattern>
    </filter-mapping><!--  自定义过滤器  结束-->
    
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

Servlet下的过滤器（filter）

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/11469227.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）