JavaWeb学习-过滤器

客官°小女子只卖身不卖艺 2023-09-24 14:49 56阅读 0赞

**基本介绍**

> 过滤器，顾名思义就是对事物进行过滤的，在Web中的过滤器，当然就是对请求进行过滤，我们使用过滤器，就可以对请求进行拦截，然后做相应的处理，实现许多特殊功能。如登录控制，权限管理，过滤敏感词汇等.

**过滤器原理**  
当我们使用过滤器时，过滤器会对游览器的请求进行过滤，过滤器可以动态的分为3个部分，1.放行之前的代码，2.放行，3.放行后的代码，这3个部分分别会发挥不同作用。

*  第一部分代码会对游览器请求进行第一次过滤，然后继续执行
 *  第二部分代码就是将游览器请求放行，如果还有过滤器，那么就继续交给下一个过滤器
 *  第三部分代码就是对返回的Web资源再次进行过滤处理

我们使用过滤器，也就是说，不止请求会经过过滤器，我们的响应也会经过过滤器。

![bd73cf6082ad4853804b80aa874b2f91.png][]

**过滤器(Filter)接口**  
我们学习过滤器，肯定就要先看一下官方给我们提供的过滤器接口。下面我们使用Idea来查看Filter。

![06bb4a3033914b2686ab9b85d805f8c1.png][]

![a4070bc9a6e84ded93c421df72bbac90.png][]

> 我们通过官方提供的过滤器可以看出过滤器(Filter)使用起来还是比较简单的，下面我们就来学习如何使用过滤器(Filter)

**使用过滤器(Filter)**

> 我们使用过滤器肯定要导入相应的jar包才行，Filter就在servlet-api.jar中，我们将该jar包放到WEB-INF下的lib目录下面，然后加入项目。

**创建过滤器(Fliter)**

> 我们创建Filter，只需要继承Filter接口就行。

import javax.servlet.*;
    import java.io.IOException;
     
    public class MyFilter implements Filter {
     
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
     
        }
    }

> Filter接口有3个方法，但是只有一个方法没有实现，我们只需要实现这个方法就行。我们可以发现，我们实现了一个doFilter方法，这个方法就是我们写过滤代码的地方，具体逻辑就是和上面介绍的过滤器原理一样的。

### 使用过滤器(Filter) ###

我们先来感受一下如何使用过滤器，细节我们后面慢慢说明。我们在上面创建的类中写入以下代码，并且加一个WebFIlter注解

import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import java.io.IOException;
     
    @WebFilter("/*")
    public class MyFilter implements Filter {
        
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("对request进行过滤");
            //下面这行代码就是放行
            filterChain.doFilter(servletRequest,servletResponse);
            System.out.println("对response进行过滤");
        }
    }

> 我简单介绍下上面的代码，WebFilter("/\*")表示对所有请求进行过滤,而在doFilter中的放行代码，也就是filterChain.doFilter(servletRequest,servletResponse);这行代码就是对拦截进行放行，细节我们后面讲，现在先怎么理解就行。
> 
> 启动服务器，然后我们在游览器中输入http://localhost:8080/filter/abc,注意，filter是我们自己配置的web工程路径，后面的abc随便输入的。我们下面来查看游览器后控制台输出。

**游览器输出**

![9538012ffe544db399d1e573e7995a8f.png][]

**控制台输出**

![dc44b0728cb24752b24d9515276a2ec7.png][]

**现在，我们就已经可以得出两个结论了，过滤器并不会管资源是否存在，而只会对配置的拦截路径进行拦截。拦截不仅会对请求进行拦截，而且还会对相应进行拦截。**

### 配置过滤器(Filter)拦截路径 ###

配置Filter的拦截路径有2种方式，一种是注解，一种是[xml][]方式，我们分别进行讲解。

#### 注解方式 ####

我们如果使用注解来进行配置，那么我们就需要使用@WebFilter，我们不说废话，直接看该注解的源码。

![d2586af183944622815a9268588770e3.png][]

里面的配置项还是有很多的，下面我对常用配置项进行说明：

*  filterName：该filter的名字
 *  initParams：初始化参数
 *  displayName：filter显示名称
 *  servletNames：指定对哪些servlet进行过滤
 *  asyncSupported：是否支持异步模式
 *  urlPatterns：指定拦截路径
 *  value：指定拦截路径

**注意：urlPatterns和value是一样的。urlPatterns和value只能配置一个，不能两个都配置，两个都配置就会报错。**

对于使用**@WebFilter**,里面的多个参数用 **,** 进行分隔。

![7193bc9c647f49228e445ff08cd975c2.png][]

**说明：如果我们仅仅需要配置一个拦截路径，那么我们可以直接简写@WebLister("拦截路径")，如@WebFilter("/\*")就是拦截所有请求。**

#### xml方式 ####

xml方式可以说是和Servlet使用xml配置方式一样了，这里就不废话，直接配置一个。

<filter>
            <filter-name>myFilter</filter-name>
            <filter-class>com.clucky.filter.MyFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>myFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

这个就是xml配置方式，只不过把注解换成了xml标签来配置，里面属性都是一样的，这个和Servlet的配置方式基本一样，这里就不再赘述了。

**过滤器(Filter)生命周期**  
我们都知道Servlet有一个生命周期，当然Filter也有一个生命周期，下面我们就来探讨一下Filter的生命周期。

Filter的生命周期和Servlet也十分相似，如果大家对Servlet的生命周期不怎么熟悉，那么可以看一下这篇文章Servlet生命周期。

我们创建一个类，实现Filter的所有方法。

import javax.servlet.*;
    import java.io.IOException;
     
    public class LifeCycleFilter implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
        }
     
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        }
     
        @Override
        public void destroy() {
        }
    }

**理论说明**   
Filter有3个阶段，分别是初始化，拦截和过滤，销毁。

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

代码演示  
Filter的三个阶段就对应着Filter的3个方法，init方法会在Filter创建时调用，doFilter方法会在请求和拦截匹配时调用，destroy方法会在Filter销毁时调用。我们来对这些方法进行编写验证。

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

**启动服务器控制台输出**

![ae610491dd464ff1bec891bc12034349.png][]

**进行拦截时控制台输出**

![76f148ae07f749d389b86fcc67fdfa38.png][]

**关闭服务器控制台输出**

![3851a3338873452d85f2876ed9ed2822.png][]

都和我们预想的一样，到此，我们就成功验证了Filter的生命周期。

**FilterConfig和FilterChain说明**  
FilterConfig和FilterConfig这2个对象是由服务器(Tomcat)在创建和调用Filter对象时所传入的，这2个对象十分有用，FilterConfig对象可以读取我们配置的初始参数，FilterChain可以实现多个Filter之间的连接。

### FilterConfig ###

老规矩，我们要学习一个对象，首先查看类图和源代码

![e2854c5ff0084c71bfb19ce35b1a0cd8.png][]

![b52e87834eca44eab456f5a2cc9515fa.png][]

里面的方法就4个，下面我们分别进行讲解

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

#### FilterConfig实例运用 ####

我们在init方法中使用FilterConfig来读取配置的数据库的信息，然后输出。

**java代码**

import javax.servlet.*;
    import java.io.IOException;
    import java.util.Enumeration;
     
    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() {
        }
    }

**xml配置**

<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>

**启动服务器，控制台输出**

![e692cb340f6c46f884c18890f5ac4afc.png][]

我们使用FilterConfig提供的方法就成功实现了功能，FilterConfig就是用来读取配置文件的。

### FilterChain ###

一样，我们还是先来查看源代码以及类图

![5a2077e8edf94a20bd58cd6022e0cefb.png][]

![0e3fa2f5a61f4fb2b3865a92bd82f4c1.png][]

> 我们查看类图，可以发现FilterChain就只有一个方法，其实这个方法就是用来对拦截进行放行的，如果有多个拦截器，那么就会继续调用下一个Filter进行拦截。doFilter方法需要传入个参数，一个是ServletRequest，一个是ServletResponse参数，这个直接传入进行。
> 
> Tomcat在调用过滤器时，默认就会传入Request和Response，这个参数封装了请求和响应，我们直接使用就行。ServletResquest和ServletResponse可以直接强转成HttpServletRequest和HttpServletResponse，然后使用相应的方法。

**将ServletRequest转成HttpServletRequest**

![de974931a477480d84ad215150b48fb3.png][]

#### FilterChain应用实例 ####

我们前面一直都是一个Filter，现在我们来配置2个Filter，通过FilterChain来进行多个过滤。

**第一个Filter**

import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import java.io.IOException;
     
    @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() {
        }
    }

**第二个过滤器**

import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import java.io.IOException;
     
    @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() {
        }
    }

> 启动服务器，然后我们游览器输入[http://localhost:8080/filter/abc][http_localhost_8080_filter_abc]（filter是我配置的web工程路径）来进行访问，查看控制台输出。

![3e33df8f42af4c16b37bc4b56186a23b.png][]

我们可以看见Filter01先进行过滤，然后交给Filter02，然后访问资源，然后Filter02对响应进行过滤，然后Filter01对响应进行过滤。图示如下：

![ad1e310373914c038484dc0063dcfe8a.png][]

我们先使用Filter01对请求进行过滤，那么很自然的，我们就是使用Filter02先对响应进行过滤。

**多个Filter的执行顺序**  
上面我们配置了2个过滤器，那么我们怎么知道那个过滤器先执行呢？其实大家可以直接使用代码进行验证，培养独立思考的习惯，这里我就直接给出答案了。

*  如果我们是在web.xml中配置的过滤器，那么过滤器的执行顺序就是<filter-mapping>在web配置的顺序，配置在上面那么就会先执行。
 *  如果我们是使用@WebFilter进行配置的，那么执行顺序就是字符比较顺序来执行，例如有2个过滤器，一个是AFilter，一个是BFilter，那么AFilter就会先执行。
 *  如果注解和xml混用，那么在web.xml中配置的会先执行。

**执行顺序验证**  
我这里就验证第一条，也就是web.xml中配置的顺序和<filter-mapping>顺序一样，其他大家感兴趣自己验证。

xml配置顺序 3->1->2

<filter>
            <filter-name>filter03</filter-name>
            <filter-class>com.clucky.filter.Filter03</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>filter03</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
        <filter>
            <filter-name>filter01</filter-name>
            <filter-class>com.clucky.filter.Filter01</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>filter01</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
        <filter>
            <filter-name>filter02</filter-name>
            <filter-class>com.clucky.filter.Filter02</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>filter02</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

**Filter01**

import javax.servlet.*;
    import java.io.IOException;
     
    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() {
        }
    }

**Filter02**

import javax.servlet.*;
    import java.io.IOException;
     
    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() {
        }
    }

**Filter03**

import javax.servlet.*;
    import java.io.IOException;
     
    public class Filter03 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("调用过滤器03对请求进行过滤~~~~");
            //放行,如果还有过滤器，那么就执行下一个过滤器
            filterChain.doFilter(servletRequest,servletResponse);
            System.out.println("调用过滤器03对响应进行过滤~~~~");
        }
     
        @Override
        public void destroy() {
        }
    }

> 我们启动服务器，游览器访问，然后查看控制台输出是不是我们配置的3->1->2的顺序

![ac0eaf6a599a4e56a8c14d2182e58fed.png][]

> 发现执行顺序果然是这样，另外2个的验证大家感兴趣可以自己验证，我这里就不验证了，如果嫌麻烦，那么记住就行了。

## Filter应用实例(实现敏感词汇过滤) ##

我们学了那么多，现在来做一个实例，我们写一个评论页面，可以进行评论，如果评论中含有我们定义的敏感词汇，那么我们就进行过滤，使用\*\*来进行代替。

### 代码实现 ###

**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>

**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);
        }
    }

代码验证

> 我们输入[http://localhost:8080/filter/comment.jsp][http_localhost_8080_filter_comment.jsp]，来访问jsp页面.

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16][]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

## 总结 ##

**通过上面的学习，相信大家对Filter的掌握肯定也上了一个台阶，但是理论知识的掌握并不能代码大家已经真正学会了，打开编译器，开始练习吧，技术就就是靠一行行代码堆起来的！！！**

原文链接：https://blog.csdn.net/m0\_51545690/article/details/123677340

[bd73cf6082ad4853804b80aa874b2f91.png]: https://img-blog.csdnimg.cn/bd73cf6082ad4853804b80aa874b2f91.png
[06bb4a3033914b2686ab9b85d805f8c1.png]: https://img-blog.csdnimg.cn/06bb4a3033914b2686ab9b85d805f8c1.png
[a4070bc9a6e84ded93c421df72bbac90.png]: https://img-blog.csdnimg.cn/a4070bc9a6e84ded93c421df72bbac90.png
[9538012ffe544db399d1e573e7995a8f.png]: https://img-blog.csdnimg.cn/9538012ffe544db399d1e573e7995a8f.png
[dc44b0728cb24752b24d9515276a2ec7.png]: https://img-blog.csdnimg.cn/dc44b0728cb24752b24d9515276a2ec7.png
[xml]: https://so.csdn.net/so/search?q=xml&spm=1001.2101.3001.7020
[d2586af183944622815a9268588770e3.png]: https://img-blog.csdnimg.cn/d2586af183944622815a9268588770e3.png
[7193bc9c647f49228e445ff08cd975c2.png]: https://img-blog.csdnimg.cn/7193bc9c647f49228e445ff08cd975c2.png
[ae610491dd464ff1bec891bc12034349.png]: https://img-blog.csdnimg.cn/ae610491dd464ff1bec891bc12034349.png
[76f148ae07f749d389b86fcc67fdfa38.png]: https://img-blog.csdnimg.cn/76f148ae07f749d389b86fcc67fdfa38.png
[3851a3338873452d85f2876ed9ed2822.png]: https://img-blog.csdnimg.cn/3851a3338873452d85f2876ed9ed2822.png
[e2854c5ff0084c71bfb19ce35b1a0cd8.png]: https://img-blog.csdnimg.cn/e2854c5ff0084c71bfb19ce35b1a0cd8.png
[b52e87834eca44eab456f5a2cc9515fa.png]: https://img-blog.csdnimg.cn/b52e87834eca44eab456f5a2cc9515fa.png
[e692cb340f6c46f884c18890f5ac4afc.png]: https://img-blog.csdnimg.cn/e692cb340f6c46f884c18890f5ac4afc.png
[5a2077e8edf94a20bd58cd6022e0cefb.png]: https://img-blog.csdnimg.cn/5a2077e8edf94a20bd58cd6022e0cefb.png
[0e3fa2f5a61f4fb2b3865a92bd82f4c1.png]: https://img-blog.csdnimg.cn/0e3fa2f5a61f4fb2b3865a92bd82f4c1.png
[de974931a477480d84ad215150b48fb3.png]: https://img-blog.csdnimg.cn/de974931a477480d84ad215150b48fb3.png
[http_localhost_8080_filter_abc]: http://localhost:8080/filter/abc
[3e33df8f42af4c16b37bc4b56186a23b.png]: https://img-blog.csdnimg.cn/3e33df8f42af4c16b37bc4b56186a23b.png
[ad1e310373914c038484dc0063dcfe8a.png]: https://img-blog.csdnimg.cn/ad1e310373914c038484dc0063dcfe8a.png
[ac0eaf6a599a4e56a8c14d2182e58fed.png]: https://img-blog.csdnimg.cn/ac0eaf6a599a4e56a8c14d2182e58fed.png
[http_localhost_8080_filter_comment.jsp]: http://localhost:8080/filter/comment.jsp
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/5626704aa5764843b78f99161368dfe1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/cf26e9b1fd7540cf894779c4a07bcdd3.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/ed131f4ca3ea437585b0511adbba8249.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5LiN5pyN6L6T55qE5bCR5bm0,size_20,color_FFFFFF,t_70,g_se,x_16