Springboot Filter 多过滤器的使用

前言

在springboot配置过滤实现方案有两种，一种是基于serlvet 的注解 @WebFilter 进行配置，一种是使用Springboot提供的 FilterRegistrationBean注册自定义过滤器。

该篇使用的方案是后者，因为按照我以前使用的记忆里，这种方式可以避免一些偶然出现的小问题，如：过滤器没生效；生效后url匹配不生效等。

正文

在开始敲代码前，先从上帝视角看看我们这次实践案例，做了些什么：

BodyReaderHttpServletRequestWrapper

名字显然是随便取的，但是从字面意义来看，就是关于body内容的读取。

为什么要写一个这样的东西？

简单讲讲：

@RequestBody 这个注解大家并不陌生，post请求里，规定参数传递使用application/json 流数据传递（序列化后的json字符串）。

正因为这个请求体重的流数据，流数据只能读取一次。

而我们这次实践案例中，过滤器读取一次，接口还需要读取一次，如果不整点手法，那么这个流数据明显不够用。

因此，我们采取了继承HttpServletRequestWrapper ，创建 BodyReaderHttpServletRequestWrapper 来

将流数据进行复制存储起来。当无论第一次第二次需要使用到流数据时，都去当前存储起来的body数据里去读取。

上代码，新建 BodyReaderHttpServletRequestWrapper.java ：

import org.apache.commons.lang3.StringUtils;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.Map;
import java.util.Vector;

/**
 * @Author : JCccc
 * @CreateTime : 2020/3/27
 * @Description :
 **/
public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final byte[] body;

    /**
     * 所有参数的集合
     */
    private Map<String, String[]> parameterMap;


    public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        BufferedReader reader = request.getReader();
        body = readBytes(reader);
        parameterMap = request.getParameterMap();
    }


    @Override
    public BufferedReader getReader() throws IOException {

        ServletInputStream inputStream = getInputStream();

        if (null == inputStream) {
            return null;
        }

        return new BufferedReader(new InputStreamReader(inputStream));
    }

    @Override
    public Enumeration<String> getParameterNames() {
        Vector<String> vector = new Vector<>(parameterMap.keySet());
        return vector.elements();
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {

        if (body == null) {
            return null;
        }

        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
        return new ServletInputStream() {

            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener listener) {

            }

            @Override
            public int read() throws IOException {
                return bais.read();
            }
        };
    }

    /**
     * 通过BufferedReader和字符编码集转换成byte数组
     *
     * @param br
     * @return
     * @throws IOException
     */
    private byte[] readBytes(BufferedReader br) throws IOException {
        String str;
        StringBuilder retStr = new StringBuilder();
        while ((str = br.readLine()) != null) {
            retStr.append(str);
        }
        if (StringUtils.isNotBlank(retStr.toString())) {
            return retStr.toString().getBytes(StandardCharsets.UTF_8);
        }
        return null;
    }
}

接着，自定义第一个过滤器， CheckUserFilter.java：

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;

/**
 * @Author : JCccc
 * @CreateTime : 2020/3/27
 * @Description :
 **/

public class CheckUserFilter implements Filter {


    @Override
    public void init(FilterConfig filterConfig) {
        System.out.println("过滤器一初始化");
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("进入到第一个过滤器,执行相关逻辑处理");

        HttpServletRequest request = (HttpServletRequest) req;

        String path = request.getRequestURI();
        String method = request.getMethod();
        System.out.println(method);

        //排除一些url的拦截
        if (path.equals("/test/testContext")) {
            filterChain.doFilter(request, res);
        }

        if ("POST".equals(method)) {

            BodyReaderHttpServletRequestWrapper requestWrapper = new BodyReaderHttpServletRequestWrapper(request);

            // 从Request的包装类中读取数据
            BufferedReader reader = requestWrapper.getReader();

            StringBuilder sb = new StringBuilder();

            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            reader.close();

            System.out.println(sb.toString());

            filterChain.doFilter(requestWrapper, res);
        }

    }


    @Override
    public void destroy() {
        System.out.println("过滤器一销毁了");
    }

}

然后再自定义一个过滤器，CheckUserFilterNext.java ：

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;

/**
 * @Author : JCccc
 * @CreateTime : 2020/3/27
 * @Description :
 **/

public class CheckUserFilterNext implements Filter {


    @Override
    public void init(FilterConfig filterConfig) {
        System.out.println("过滤器二初始化");
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("进入到第二个过滤器,执行相关逻辑处理");

        HttpServletRequest request = (HttpServletRequest) req;

        String path = request.getRequestURI();
        String method = request.getMethod();
        System.out.println(method);
        //排除一些url的拦截
        if (path.equals("/test/testContext")) {
            filterChain.doFilter(request, res);
        }

        if ("POST".equals(method)) {

            BodyReaderHttpServletRequestWrapper requestWrapper = new BodyReaderHttpServletRequestWrapper(request);

            // 从Request的包装类中读取数据
            BufferedReader reader = requestWrapper.getReader();

            StringBuilder sb = new StringBuilder();

            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            reader.close();

            System.out.println(sb.toString());

            filterChain.doFilter(requestWrapper, res);
        }

    }


    @Override
    public void destroy() {
        System.out.println("过滤器二销毁了");
    }

}

然后是将这两个过滤器都丢进spring容器里面去，顺便配置一些拦截的url和执行顺序（毕竟是两个过滤器，肯定有执行顺序）：

那么我们来到 application加上相关代码：

/**
     * 第一个过滤器配置
     *
     */

    @Bean
    CheckUserFilter getCheckUserFilter(){
        return new CheckUserFilter();
    }

    @Bean("checkUserFilter")
    public FilterRegistrationBean<CheckUserFilter> checkUserFilter(CheckUserFilter checkUserFilter) {
        FilterRegistrationBean<CheckUserFilter> registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(checkUserFilter);
        registrationBean.addUrlPatterns("/test/*"); //url拦截
        registrationBean.setOrder(1);
        registrationBean.setAsyncSupported(true);
        return registrationBean;
    }


    /**
     * 第二个过滤器配置
     *
     */


    @Bean
    CheckUserFilterNext getCheckUserFilterNext(){
        return new CheckUserFilterNext();
    }

    @Bean("checkUserFilterNext")
    public FilterRegistrationBean<CheckUserFilterNext> checkUserFilterNext(CheckUserFilterNext checkUserFilterNext) {
        FilterRegistrationBean<CheckUserFilterNext> registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(checkUserFilterNext);
        registrationBean.addUrlPatterns("/test/*"); //url拦截
        registrationBean.setOrder(2);
        registrationBean.setAsyncSupported(true);
        return registrationBean;
    }

若想要配置第三个过滤器，那么也是一样，自定义一个过滤器继承Filter，然后再一样注册到application里面去。

接下来我们开始写点接口去测试一下，

新建一个 MyTestController.java ：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

/**
 * @Author : JCccc
 * @CreateTime : 2020/3/27
 * @Description :
 **/

@Controller
@RequestMapping("/test")
public class MyTestController {


    @ResponseBody
    @RequestMapping(value="testFilter",method={RequestMethod.POST})

    public void testFilter(@RequestBody  String jsonStr) {
        System.out.println("aaaaa");
        System.out.println(jsonStr);

    }


}

项目跑起来，可以看到：

咱们刚刚配置的过滤器都已经初始化准备好了，

接下来我们调用一下测试接口：

直接看结果：

Springboot Filter 多过滤器的使用

前言

正文

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method