JavaWeb基础学习笔记15——Filter（过滤器）

啊噢1231

已于 2022-02-26 18:49:14 修改

阅读量302

点赞数 1

分类专栏： JavaWeb 文章标签：学习

于 2022-02-25 19:46:01 首次发布

本文链接：https://blog.csdn.net/weixin_44623055/article/details/123139893

版权

JavaWeb 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

1、Filter（过滤器）概述

web中的过滤器：当访问服务器的资源时，过滤器可以将请求拦截下来，完成一些特殊的功能。

过滤器Filter的作用：一般用于完成通用的操作，如：登录验证、统一编码处理、敏感字符的过滤...；

2、Filter快速入门

2.1、步骤

定义一个类，实现Filter接口；
重写方法；
配置拦截路径：① web.xml配置；② 注解配置。

package com.clp.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.*;
import java.io.IOException;

/**
 * 过滤器快速入门
 */
//@WebFilter(filterName = "/demo.jsp") //只有访问demo.jsp时，才会执行该过滤器
@WebFilter("/*") //访问所有资源之前，都会执行该过滤器
public class FilterDemo1 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("filterDemo1被执行了...");

        //放行
        chain.doFilter(request,response);
    }
}

3、Filter细节

3.1、web.xml配置

    <filter>
        <filter-name>demo1</filter-name>
        <filter-class>com.clp.web.filter.FilterDemo1</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>demo1</filter-name>
        <!-- 拦截路径 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

3.2、过滤器执行流程

1、执行过滤器；
2、执行放行后的资源；
3、回来执行过滤器放行代码下边的代码。

package com.clp.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.*;
import java.io.IOException;

//@WebFilter("/*")
public class FilterDemo2 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 {
        //对request的请求消息增强
        System.out.println("filterDemo2执行了...");

        //放行
        chain.doFilter(request, response);

        //对response的响应消息增强
        System.out.println("filterDemo2回来了...");
    }
}

3.3、过滤器生命周期方法

1、init()：
在服务器启动后，会创建Filter对象，然后调用init()方法。用于加载资源。

2、doFilter()：
每一次请求被拦截资源时，会执行。执行多次。

3、destroy()：
在服务器关闭后，Filter对象被销毁，如果服务器是正常关闭，则会执行destroy()方法。用于释放资源。

package com.clp.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.*;
import java.io.IOException;

@WebFilter("/*")
public class FilterDemo3 implements Filter {
    /**
     * 在服务器启动后，会创建Filter对象，然后调用init()方法。用于加载资源
     * @param config
     * @throws ServletException
     */
    public void init(FilterConfig config) throws ServletException {
        System.out.println("init..");
    }

    /**
     * 在服务器关闭后，Filter对象被销毁，如果服务器是正常关闭，则会执行destroy()方法。用于释放资源
     */
    public void destroy() {
        System.out.println("destroy...");
    }

    /**
     * 每一次请求被拦截资源时，会执行。执行多次
     * @param request
     * @param response
     * @param chain
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        System.out.println("doFilter...");
        chain.doFilter(request, response);
    }
}

3.4、过滤器配置详解

1、拦截路径配置：
    1）具体资源路径：如 index.jsp ，只有访问index.jsp资源时，过滤器才会被执行。
    2）拦截目录：如 /user/* 。访问/user下的所有资源时，过滤器都会被执行。
    3）后缀名拦截：如 *.jsp ，访问所有后缀名为jsp的资源时，过滤器都会被执行。
    4）拦截所有资源：如 /* ，访问所有资源时，过滤器都会被执行。

拦截方式：资源被访问的方式。
2、拦截方式配置：
    1）注解配置；
        设置dispatcherTypes属性：
            ① RESUEST：默认值。浏览器直接请求资源。
            ② FORWARD：转发访问资源。
            ③ INCLUDE：包含访问资源。
            ④ ERROR：错误跳转资源。
            ⑤ ASYNC：异步访问资源。
    2）web.xml配置：
        设置<dispatcher></dispatcher>标签即可，取值同上。
        <filter>
            <filter-name>demo1</filter-name>
            <filter-class>com.clp.web.filter.FilterDemo1</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>demo1</filter-name>
            <url-pattern>/*</url-pattern>
            <dispatcher>FORWARD</dispatcher>
        </filter-mapping>

3.5、过滤器链（配置多个过滤器）

1、过滤器执行顺序：如果有两个过滤器：过滤器1和过滤器2，执行顺序为：
    1、过滤器1；
    2、过滤器2；
    3、资源执行；
    4、过滤器2；
    5、过滤器1。

2、过滤器的先后顺序问题：
    1）注解配置；按照类名的字符串比较规则比较，值小的先执行。
        如：AFilter 和 BFilter ，AFilter就先执行了。 
    2）web.xml配置：<filter-mapping>谁定义在上边，谁先执行。

4、案例1：登录验证

需求：

访问FilterProject案例的资源，验证其是否登录；
如果登录了，则直接放行；
如果没有登录，则跳转到登录页面，提示“您尚未登录，请先登录”。

5、案例2：过滤敏感词汇

需求：

对Filter案例录入的数据进行敏感词汇过滤；
敏感词汇参考《敏感词汇.txt》；
如果是敏感词汇，替换为 ***。

分析：

对request对象进行增强，增强获取参数相关方法；
放行，传递代理对象。

增强对象的功能：
*设计模式：一些通用的解决固定问题的方式。比如：
    一、装饰模式：
    二、代理模式：
        *概念：
            1、真实对象：被代理的对象；
            2、代理对象：
            3、代理模式：代理对象代理真实对象，达到增强真实对象功能的目的。
        *实现方式：
            1、静态代理：有一个类文件描述代理模式。
            2、动态代理：在内存中形成代理类。
                *实现步骤：
                    1）代理对象和真实对象实现相同的接口；
                    2）代理对象 = Proxy.newProxyInstance();
                    3）使用代理对象调用方法；
                    4）增强方法。
                *增强方式：
                    1）增强参数列表；
                    2）增强返回值类型；
                    3）增强方法体逻辑：

动态代理代码演示：
package com.clp.proxy;

public interface SaleComputer {
    public String sell(double money);
    public void show();
}
/**************************************************************************/
package com.clp.proxy;

/**
 * 真实类
 */
public class Lenovo implements SaleComputer{

    @Override
    public String sell(double money) {
        System.out.println("花了"+money+"元买了一台联想电脑。。。");
        return "联想电脑";
    }

    @Override
    public void show() {
        System.out.println("展示电脑...");
    }
}
/**************************************************************************/
package com.clp.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 InvocationHandle()
         */
        SaleComputer proxy_lenovo = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(),
                lenovo.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 代理逻辑编写的方法：代理对象调用的所有方法都会触发该方法执行
                     * @param proxy：代理对象
                     * @param method：代理对象调用的方法，被封装为一个方法对象
                     * @param args：代理对象调用方法时，传递的实际参数
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("该方法执行了...");
                        //判断是否是sell()方法
                        if(method.getName().equals("sell")) {
                            //1、增强参数args
                            double money = (double) args[0];
                            money = money * 0.85;
                            //使用真实对象调用该方法
                            System.out.println("专车接你...");
                            String obj = (String) method.invoke(lenovo, money);
                            System.out.println("免费送货...");
                            //2、增强返回值
                            return obj+"_鼠标垫";
                        }else {
                            //使用真实对象调用该方法
                            Object obj = method.invoke(lenovo, args);
                            return obj;
                        }
                    }
                });

        //2、调用方法
        String computer = proxy_lenovo.sell(8000);
        System.out.println(computer);
    }
}
/**************************************************************************/
结果：
该方法执行了...
专车接你...
花了6800.0元买了一台联想电脑。。。
免费送货...
联想电脑_鼠标垫