需要了解的过滤器

樵夫垒码

于 2023-04-10 00:08:13 发布

阅读量368

点赞数

分类专栏： java 文章标签： servlet java

本文链接：https://blog.csdn.net/qq_44816731/article/details/130050711

版权

java 专栏收录该内容

16 篇文章 2 订阅

订阅专栏

过滤器

1. 概念

过滤器：从名字上理解就是对于事件的过滤操作，在web 中的过滤器，就是对于请求进行过滤操作，我们使用过滤器，就可以对于请求进行拦截操作，然后进行响应的处理操作，实现很多的特殊的功能，比如登录控制、权限控制操作、过滤敏感词汇.

2. 过滤器原理

流程：

浏览器和web 资源之间存在一个过滤器，对于资源进行处理操作，浏览器进行Http请求操作，首先经过过滤器，然后携带放行的request 和 Reponse 进入到web 资源，然后将资源进行返回操作，http 进行响应。

注意拦截器的工作不仅仅对于请求进行拦截操作，而且也会对响应进行拦截操作。

3. 配置

过滤器的使用总共有两种方式：一种是通过注解的形式进行实现操作。一种是通过web.xml进行实现。需要相关的配置文件Filter就在servlet-api.jar中，我们将该jar包放到WEB-INF下的lib目录下面，然后加入项目。如果是使用的maven 则需要进行如下的操作
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

3.1 注解式配置

对于注解的源码进行分析

String[] value() default {};
String[] urlPatterns() default {};
// 其中两者的含义是相同的，urlPatterns和value只能配置一个，不能两个都配置，两个都配置就会报错。

进行条件的过滤操作的时候，设置过滤器的限制过滤的条件路径。

@WebFilter(urlPatterns = {"/Day45/user", "/Day45/admin"})

@WebFilter("/Day45/user") ==> 注解中的value属性

3.2 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_3_1.xsd"
         version="3.1">
    <filter>
        <!-- 当前过滤器名字 -->
        <filter-name>BFilter</filter-name>
        <!-- 对应当前过滤器的.class文件 -->
        <filter-class>com.java.a_filter.BFilter</filter-class>
    </filter>
    <filter-mapping>
        <!-- 对应过滤器的名字 -->
        <filter-name>BFilter</filter-name>
        <!-- 限制过滤路径 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter-mapping>
        <!-- 对应过滤器的名字 -->
        <filter-name>BFilter</filter-name>
        <!-- 限制过滤路径 -->
        <url-pattern>/andmin/user</url-pattern>
    </filter-mapping>
</web-app>

4. 过滤器链

FilterChain

过滤器链就是在浏览器和 web 资源之间有多个过滤器组成的一条过滤器链，返回的数据会经过每一个过滤器，中间多个过滤器形成一个过滤器链。

4.1 执行顺序

过滤器链的执行顺序，两种情况下需要进行考虑操作：

使用注解的方式进行配置过滤器，这个时候需要考虑的是类的名称在字典中的顺序，顺序在前的优先进行执行操作。在后的将靠后进行执行操作。
使用web.xml 文件进行配置filter 过滤器，根据在web.xml文件中的顺序来决定过滤器链的执行流程。靠前的优先进行执行操作。
如果两者进行混合使用，那么在web.xml 文件中的配置会优先进行操作执行。

4.2 FilterChain

通过查看源码能够得到的结论是： FilterChain 就只有一个方法。其实这个方法就是用来对于拦截进行放行操作的，如果有多个拦截器，那么就会继续调用下一个Filter 进行拦截。doFilter 方法需要传入个参数，一个是ServletRequest 参数，一个是ServletReponse 参数，这个直接进行传入就行。

Tomcat 在调用过滤器的时候，默认会传入Request 和 Reponse ，这个参数封装了请求和响应，我们直接使用就行。ServletResquest和ServletResponse可以直接强转成HttpServletRequest和HttpServletResponse，然后使用相应的方法。
//将ServletRequest 转换为 HttpServletRequest 

HttpServletRequest httpServletRequest =(HttpServletRequest) servletRequest;

@WebFilter("/*")
public class Filter01 implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("调用过滤器01对请求进行过滤~~~~");
        //放行,如果还有过滤器，那么就执行下一个过滤器
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("调用过滤器01对响应进行过滤~~~~");
    }
 
    @Override
    public void destroy() {
    }
}

@WebFilter("/*")
public class Filter02 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("调用过滤器02对请求进行过滤~~~~");
        //放行,如果还有过滤器，那么就执行下一个过滤器
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("调用过滤器02对响应进行过滤~~~~");
    }
 
    @Override
    public void destroy() {
    }
}

运行结果：
    调用过滤器01对请求进行过滤
    调用过滤器02对请求进行过滤
    调用过滤器02对响应进行过滤
    调用过滤器01对响应进行过滤

5.过滤器初始化参数

指加载一定的资源的时候，敏感词汇的过滤操作，跟当前的过滤器进行绑定操作，这里能够使用初始化参数，两种方式：

通过注解的方式来完成配置操作。
通过web.xml 实现配置操作

5.1 注解实现初始化

// 注解方式完成
@WebFilter(value = "/*",
        initParams = {@WebInitParam(name = "filename", value = "saolei.properties")})

5.2 xml 实现初始化

<!-- XML配置方式完成  -->
<filter>
    <filter-name>EFilter</filter-name>
    <filter-class>com.qfedu.a_filter.EFilter</filter-class>
    
    <!-- 初始化参数 -->
    
    <init-param>
        <param-name>filename</param-name>
        <param-value>saolei.xml</param-value>
    </init-param>
    
</filter>
<filter-mapping>
    <filter-name>EFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

6. 过滤器的声明周期

过滤器也有声明周期，Filter 的声明周期和Servlet 的声明周期十分相似。

过滤器总共有三个阶段：初始化、拦截过滤、销毁

初始化阶段：当服务器启动的时候，我们的服务器就会读取配置文件，扫描注解，然后来创建我们的过滤器。
拦截和过滤阶段：只要请求资源的路径和拦截的路径相同，则过滤器就会对请求进行过滤操作，这个阶段在服务器运行的过程中会一直循环。
销毁阶段：当服务器进行关闭的时候，服务器创建的过滤器也会随之销毁。

创建一个Filter类，实现其中所有的方法


import javax.servlet.*;
import java.io.IOException;
 
public class LifeCycleFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 该方法是初始化方法、在Filter 创建的时候调用
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 该方法是过滤和拦截的方法，当请求和拦截匹配的时候进行调用
    }
 
    @Override
    public void destroy() {
        // 这个方法是销毁方法，在Filter 销毁前进行调用
    }
}


1.启动服务器时，调用初始化方法
2.进行拦截时调用doFilter方法
3.关闭服务器的时候调用销毁方法

7. FilterConfig

FilterConfig 和 FilterChain 这两个对象是通过服务器在创建和调用Filter 对象的时候所传入的，这两个对象十分有用，FilterConfig 对象能够读取我们的配置的初始化参数、FilterChain 可以实现多个Filter 之间的连接操作。

源码剖析：

getFilterName()：获取filter的名称
getServletContext()：获取ServletContext
getInitparamter(String var1)：获取配置的初始参数的值
getInitParamterNames()：获取配置的所有参数名称

分析：

我们在init方法中使用FilterConfig 来读取配置的数据库信息，然后进行输出操作。FilterConfig 的作用就是用来读取配置文件。

public class MyFilterConfig implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("-----------获取全部key:value------------");
        //得到所有配置参数的名字
        Enumeration<String> names = filterConfig.getInitParameterNames();
        while (names.hasMoreElements()) {
            //得到每一个名字
            String name = names.nextElement();
            System.out.println(name+" = "+filterConfig.getInitParameter(name));
        }
        System.out.println("-----------end.....------------");
    }
    // 输出的结果是配置信息的键值对数据
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    }
 
    @Override
    public void destroy() {
    }
}


<filter>
        <filter-name>myFilterConfig</filter-name>
        <filter-class>com.clucky.filter.MyFilterConfig</filter-class>
        <init-param>
            <param-name>driver</param-name>
            <param-value>com.mysql.jdbc.Driver</param-value>
        </init-param>
        <init-param>
            <param-name>url</param-name>
            <param-value>jdbc:mysql://localhost:3306/equip_employ_manage?serverTimezone=GMT</param-value>
        </init-param>
        <init-param>
            <param-name>username</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>password</param-name>
            <param-value>root</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>myFilterConfig</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

8. 实例实现

8.1 编码操作

@WebFilter("/*")
public class AEncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 获取当前Tomcat服务器版本信息
        String serverInfo = request.getServletContext().getServerInfo();

        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;

        if (serverInfo.startsWith("Apache Tomcat/7") || serverInfo.startsWith("Apache Tomcat/6")) {
            // 存在ISO-8859-1
            // 留下一个小问题
            System.out.println("Tomcat 6 or 7");
        } else {
            // Tomcat 8以及以上处理POST请求中文乱码问题和对应Response响应乱码问题
            System.out.println("Tomcat 8 or 9");
            httpServletRequest.setCharacterEncoding("utf-8");
            httpServletResponse.setContentType("text/html;charset=utf-8");
        }
		// 过滤链进行放行操作
        chain.doFilter(httpServletRequest, httpServletResponse);
    }

    @Override
    public void destroy() {

    }
}

8.2 登录过滤操作

先进行封装操作，使用抽象类能够保证该类不会被实例化，实例化的话只能够使用匿名内部类。

下面是相关的代码总结。

public abstract class BaseFilter implements Filter {
    /**
     * 过滤器的初始化操作
     *
     * @param filterConfig  初始化参数 过滤器的配置
     * @throws ServletException Servlet异常
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    /**
     * 过滤的销毁方法
     */
    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

@WebFilter("/*")
public class MyFilter extends BaseFilter{

    /**
     * 【核心方法】用于制定针对于用户请求和响应的过滤规则，需要通过 FilterChain 进行请求放行操作
     *
     * @param servletRequest  ServletRequest 用户请求符合 Servlet 要求的 request 对象
     * @param servletResponse ServletResponse 根据用户请求绑定创建的符合 Servlet 要求的 Response 对象
     * @param filterChain     FilterChain 过滤器链类型，用于【放行】请求
     * @throws IOException    IO异常
     * @throws ServletException Servlet 异常
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //1.强制类型转换
        HttpServletRequest request = (HttpServletRequest)servletRequest;
        HttpServletResponse response = (HttpServletResponse)servletResponse;

        //3. 获取请求路径
        String uri = request.getRequestURI();
        StringBuffer requestURL = request.getRequestURL();
        System.out.println(requestURL);

        System.out.println(uri);
        //未进行登录时能够放行的操作
        if (uri.endsWith("/")||uri.endsWith("login.html")|| uri.endsWith("loginServlet")){
            // 放行操作
            filterChain.doFilter(request, response);
        } else {
            // 判断是否存在对象，如果存在过
            Object id1 = request.getSession().getAttribute("u_account");
            // 如果已经登录成功
            if (id1 != null){
                filterChain.doFilter(request,response);
            } else {
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("<script>" +"alert('请先登录');"+
                        "location.href='/login.html'</script>");
            }
        }
    }
}

8.3 实现敏感词汇过滤操作

// Filter 代码

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
@WebFilter(servletNames = {"comment"},initParams = {@WebInitParam(name = "sensitiveWord", value = "zz")})
public class CommentFilter implements Filter {
 
    private List<String> sensitiveWords = new ArrayList<>();
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //得到敏感词汇
        String word = filterConfig.getInitParameter("sensitiveWord");
        //加入集合
        sensitiveWords.add(word);
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //设置编码
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=utf-8");
        //得到评论
        String message = servletRequest.getParameter("message");
        for (String sensitiveWord : sensitiveWords) {
            //对所有敏感词汇进行过滤
            if (message.contains(sensitiveWord)){
                //替换敏感词汇
                message = message.replace(sensitiveWord, "**");
            }
        }
        //存入request域
        servletRequest.setAttribute("comment",message);
        //放行
        filterChain.doFilter(servletRequest,servletResponse);
    }
 
    @Override
    public void destroy() {
    }
}

// Servlet 代码

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;
import java.util.HashSet;
 
@WebServlet(name = "comment",value = "/comment")
public class CommentServlet extends HttpServlet {
 
    //记录评论敏感词汇的ip
    private HashSet<String> hashSet = new HashSet<>();
 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String message = request.getParameter("message");
        String comment = (String) request.getAttribute("comment");
        if (message.equals(comment)){
            System.out.println("没有敏感词汇.....");
            //设置名字
            request.setAttribute("name","good boy：");
        }else {
            //有敏感词汇，记录IP
            String localAddr = request.getLocalAddr();
            System.out.println(localAddr);
            hashSet.add(localAddr);
            //设置名字
            request.setAttribute("name","bad boy：");
        }
        //转发到comment.jsp页面
        request.getRequestDispatcher("/comment.jsp").forward(request,response);
    }
 
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

// JSP 页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>评论</title>
</head>
<body>
<h1>输入评论内容</h1>
<form action="${pageContext.request.contextPath}/comment" method="post">
    <textarea name="message" cols="30" rows="10"></textarea>
    <input type="submit" value="提交">
</form>
<p >${requestScope.get("name")}<span style="color: red">${requestScope.get("comment")}</span></p>
</body>
</html>