Filter过滤器详解-CSDN博客

本文链接：https://blog.csdn.net/khmff/article/details/126222988

（4）Filter执行流程（浏览器->Filter->服务器->Filter->浏览器）。

（5）Filter的生命周期。

（6）Filter的拦截方式：注解和web.xml配置。

javaWeb三大组件：Servlet、Filter、Listener。

一、Filter过滤器。

（1）Filter的基本使用。

（2）使用Filter实现的案例。

（2.1）案例一：登录验证。

@WebFilter("/*")
public class LoginFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //0.强制转换
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        //1.获取资源请求路径
        String uri = req.getRequestURI();
        //2.判断是否包含登录相关资源路径
        if (uri.contains("/login.jsp") || uri.contains("/loginServlet") || uri.contains("/checkCodeServlet")){
            //包含，证明用户就是想登录，放行
            filterChain.doFilter(servletRequest,servletResponse);
        }else {
            //不包含，需要验证用户是否登录
            //3.从session中获取User对象
            Object user = req.getSession().getAttribute("user");
            if (user != null){
                //登录了，放行
                filterChain.doFilter(servletRequest,servletResponse);
            }else {
                //没有登录，跳转登录页面
                req.setAttribute("login_msg","您尚未登录，请先登录！");
                req.getRequestDispatcher("/login.jsp").forward(req,servletResponse);
            }
        }
    }
    public void destroy() {

    }
}

（2.2）案例二、敏感词汇过滤。

package web.Filter;
@WebFilter("/*")
public class SensitiveWordsFilter implements Filter {
    private List<String> list = new ArrayList<String>();//敏感词汇集合
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        try {
            //1.获取文件真实路径
            ServletContext servletContext = filterConfig.getServletContext();
            //参数是真实路径的后续路径
            String realPath = servletContext.getRealPath("/WEB-INF/classes/敏感词汇.txt");
            System.out.println(realPath);
            //2.读取文件,这个字符流默认是gbk流
            BufferedReader br = new BufferedReader(new FileReader(new File(realPath)));
            String line = null;
            while ((line = br.readLine()) != null){
                list.add(line);
            }
            br.close();
            System.out.println(list);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //1.创建代理对象，增强getParameter方法
        ServletRequest req = (ServletRequest) Proxy.newProxyInstance(servletRequest.getClass().getClassLoader(), servletRequest.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //增强getParameter方法
                //判断是否是getParameter方法
                //判断是否是getParameterMap方法
                //判断是否是getParameterValue方法
                if (method.getName().equals("getParameter")) {
                    //增强返回值
                    //获取返回值
                    String value = (String) method.invoke(servletRequest, args);
                    if (value != null) {
                        for (String str : list) {
                            if (value.contains(str)) {
                                //替换字符,参数是第一个是正则表达式，即匹配条件的字符，第二个是替换的参数
                                value.replaceAll(str, "***");
                            }
                        }
                    }
                    return value;
                }
                return method.invoke(servletRequest, args);
            }
        });
        //注意：这里要传入代理对象，不然调用的还是原对象，而不是代理对象
        filterChain.doFilter(req, servletResponse);
    }
    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

（3）动态代理（与真实类实现相同的接口）

理解：代理方法代替了原方法，代理方法里面可以调用原方法（只执行代理方法，不执行原方法）

package proxy_动态代理;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {
        //1.创建真实对象
        Lenovo lenovo = new Lenovo();
        //2动态代理增强lenovo对象
        /**
         * 三个参数：
         *  1.类加载器：真实对象.getClass().getClassLoader()
         *  2.接口数组：真实对象.getClass().getInterfaces()
         *  3.处理器： new InvocationHandler()
         */
        SaleComputer proxy_lenove = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {
            /*
                代理逻辑编写的方法：代理对象调用的所有方法都会触发该方法执行(调用接口方法时：代理方法会代替执行)
                    参数：
                        1.proxy：代理对象
                        2.method：代理对象调用的方法（接口方法），被封装为Method对象
                        3.args：代理对象调用方法执行时，传递的实际参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                System.out.println("该方法执行了...");//该方法执行了...
//                System.out.println(method.getName());//sale
//                System.out.println(args[0]);//8000.0
                //判断是否是sale方法
                if (method.getName().equals("sale")){
                    //1.增强参数
                    double money = (double) args[0];
                    money = money * 0.85;
                    System.out.println("专车接你....");
                    //2.使用真实对象调用该方法
                    String obj = (String) method.invoke(lenovo, money);
                    System.out.println("免费送货....");
                    return obj + "_鼠标垫";
                }else {
                    Object obj = method.invoke(lenovo, args);
                    return obj;
                }
            }
        });
        //3.调用方法
        String computer = proxy_lenove.sale(8000);
        System.out.println(computer);
//        proxy_lenove.show();
    }
}

（4）Filter执行流程（浏览器->Filter->服务器->Filter->浏览器）。

@Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        //对request对象请求消息增强（request有数据，response对象还没数据）
        System.out.println("filterDemo2执行了....");
        //放行，允许进去服务器
        chain.doFilter(request, response);
        //服务器响应后先进来这里，执行下面的代码（对response对象的响应消息增强）再出去到浏览器（request有数据，response对象也有数据）
        System.out.println("filterDemo2回来了....");
    }

（5）Filter的生命周期。

@WebFilter("/*")
public class FilterDemo3 implements Filter {
    /**
     * 在服务器启动后，会创建Filter对象，然后调用init方法，只执行一次。
     * 用于加载资源
     */
    public void init(FilterConfig config) throws ServletException {
        System.out.println("init...");
    }
    /**
     * 在服务器关闭后（应该是关闭时执行完才关闭结束），Filter对象被销毁，如果服务器正常关闭，则会执行destroy方法，只执行一次。
     * 用于释放资源
     */
    public void destroy() {
        System.out.println("destroy...");
    }
    /**
     * 每一次请求被拦截资源时，会执行。（拦截一次执行一次）
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("dofilter...");
        chain.doFilter(request, response);
    }
}

（6）Filter的拦截方式：注解和web.xml配置。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <filter>
        <filter-name>demo1</filter-name>
        <filter-class>Filter_快速入门.FilterDemo1</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>demo1</filter-name>
        <url-pattern>/*</url-pattern>
<!--        <dispatcher>REQUEST</dispatcher>这个配置必须在这里才可以，在外面没有这个标签-->
        <dispatcher>REQUEST</dispatcher>
    </filter-mapping>
</web-app>

package javax.servlet;
public enum DispatcherType {
    FORWARD,
    INCLUDE,
    REQUEST,
    ASYNC,
    ERROR;

    private DispatcherType() {
    }
}

//浏览器直接请求index.jsp资源时，该过滤器会被执行,不配置默认是DispatcherType.REQUEST
//@WebFilter(value = "/index.jsp",dispatcherTypes = DispatcherType.REQUEST)
//只有转发访问index.jsp时，该过滤器才会被执行
//@WebFilter(value = "/index.jsp",dispatcherTypes = DispatcherType.FORWARD)
//配置多个值，浏览器直接请求index.jsp资源时或者转发访问index.jsp时，该过滤器都会被执行
@WebFilter(value = "/index.jsp",dispatcherTypes = {DispatcherType.FORWARD,DispatcherType.FORWARD})
public class FilterDemo5 implements Filter {
    public void init(FilterConfig config) throws ServletException {

    }
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("filterDemo5.....");
        chain.doFilter(request, response);
    }
}