版本：

springboot：2.2.7

一、过滤器 Filter

1、过滤器的作用或使用场景：

• 用户权限校验

• 用户操作的日志记录

• 黑名单、白名单

• 等等…

可以使用过滤器对请求进行预处理，预处理完毕之后，再执行 chain.doFilter() 将程序放行。

2、自定义过滤器

自定义过滤器，只需要实现 javax.servlet.Filter 接口即可。

public class TestFilter implements Filter {

    private static final Logger log = LoggerFactory.getLogger(TestFilter.class);

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        log.info("test filter;");

        // 代表过滤通过，必须添加以下代码，程序才可以继续执行
        chain.doFilter(request, response);
    }
}

Filter 接口有三个方法：init()、doFilter()、destroy()。

• init()：项目启动初始化的时候会被加载。

• doFilter()：过滤请求，预处理。

• destroy()：项目停止前，会执行该方法。

其中 doFilter() 需要自己必须实现，其余两个是 default 的，可以不用实现。

注意：如果 Filter 要使请求继续被处理，就一定要调用 chain.doFilter() ！

3、配置 Filter 被 Spring 管理

让自定义的 Filter 被 Spring 的 IOC 容器管理，常用的实现方式有两种，分别为：

1）@WebFilter + @ServletComponentScan

• 在 TestFilter 类上添加 @WebFilter 注解，

• 然后在启动类上增加 @ServletComponentScan 注解，就可以了。

其中在 @WebFilter 注解上可以指定过滤器的名称和匹配的 url 数组，如下图所示：

这种方式虽然可以指定 filter 名称和匹配的 url ，但是不能指定各 filter 之间的执行顺序。

2）JavaConfig 配置

通过 JavaConfig 配置实现 Filter 被 Spring 管理，推荐使用这种方式，该种方式可以指定各 filter 之间的执行顺序。setOrder 的值越小，越优先执行。

@Configuration
public class FilterConfiguration {

    @Bean
    public Filter testFilter() {
        return new TestFilter();
    }

    @Bean
    public FilterRegistrationBean registrationTestFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new DelegatingFilterProxy("testFilter"));
        registration.setName("testFilter");
        registration.addUrlPatterns("/v1/*");
        registration.addUrlPatterns("/v2/*");
        registration.setOrder(1);
        return registration;
    }

}

通过 JavaConfig 显式配置 Filter ，功能强大，配置灵活。只需要把每个自定义的 Filter 声明成 Bean 交给 Spring 管理即可，还可以设置匹配的 URL 、指定 Filter 的先后顺序。

另外通过这种方式，还可以实现在自定义 filter 中自动装配一些对象 @Autowired 。

二、Servlet

1、Servlet 是什么：

servlet是一个Java编写的程序，此程序是基于http协议的，在服务器端（如Tomcat）运行的，是按照servlet规范编写的一个Java类。

客户端发送请求至服务器端，服务器端将请求发送至servlet，servlet生成响应内容并将其传给服务器。

2、Servlet 的作用：

处理客户端的请求并将其结果发送到客户端。

3、自定义 Servlet

自定义 servlet 需要继承一个抽象类，那就是 javax.servlet.http.HttpServlet。

然后在类上添加 @WebServlet 注解即可。

@WebServlet(name = "TestServlet", urlPatterns = {"/v1/*", "/v2/*"})
public class TestServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.service(req, resp);
    }
}

然后在启动类上增加 @ServletComponentScan 注解，自定义 Servlet 就完成了。

HttpServlet 中有很多方法，常用的还是重写 service(HttpServletRequest req, HttpServletResponse resp) 方法，进行请求处理返回。

4、HttpServletRequest 与 HttpServletResponse

HttpServletRequest 用来接收请求参数，HttpServletResponse 用来返回请求结果。

1）获取 header

某个 header 值：

String clientid = req.getHeader("clientid");

遍历所有 header 值：

Enumeration<String> headerNames = req.getHeaderNames();
while(headerNames.hasMoreElements()){
    String headerKey = headerNames.nextElement();
    log.info("{} : {}", headerKey, req.getHeader(headerKey));
}

2）获取请求 uri

String requestUri = req.getRequestURI();

3）获取请求类型

String methodType = req.getMethod();

4）获取请求 params

String queryString = req.getQueryString();
if (!StrUtil.isBlank(queryString)) {
    log.info("请求行中的参数部分为: {}", queryString);
    url = url + "?" + queryString;
}

5）获取请求 body

private String getBody(HttpServletRequest request) {
    //获取body数据
    StringBuilder sb = null;
    try {
        BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream()));
        String line = null;
        sb = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            sb.append(line);
        }
        return sb.toString();
    } catch (IOException e) {
        log.error("获取请求体异常：", e);
        return "";
    }
}

6）组装返回结果

返回结果是用 HttpServletResponse 来组装。如下述代码所示：

resp.setCharacterEncoding("UTF-8");
resp.setContentType("application/json; charset=utf-8");
PrintWriter printWriter = resp.getWriter();
printWriter.append(JSON.toJSONString(resultObj, SerializerFeature.WriteMapNullValue));
printWriter.close();

三、Filter 与 Servlet 的执行顺序

filter1 -> filter2 -> servlet，  之后 servlet 处理完，再回传到 filter2 -> filter1 。

• 如果 servlet 和 filter 都有 response 返回，返回到前端的是 servlet 的 response。

• 如果 servlet 中没有 response 返回，filter 中有 response 返回。这时 filter 的 response 有效，返回到前端的是 filter 的 response。

filter 到 filter 或 servlet ，是通过 chain.doFilter(request, response); 这条命令来进行通过的。当从 servlet 中返回到 filter 时，chain.doFilter(request, response); 后面的代码会继续被执行。

四、Filter、Servlet 的全局异常统一处理

现在我在 TestFilter 中，添加了一个必报异常的代码，发现使用 @RestControllerAdvice + @ExceptionHandler 并不能捕获该 filter 的异常。

其实 @RestControllerAdvice + @ExceptionHandler 并非可以解决所有异常返回信息，它倒是能拦截 Controller 层的异常报错，但是在 Filter、servlet 中的异常，使用以上注解就失效了，需要从别的方面进行入手。

找了好久的资料，才知道怎么处理，所以也给大家分享一下。

1、spring boot 错误逻辑

我们都知道，当 spring boot 遇到错误的时候，拥有自己的一套错误提示逻辑，分为两种情况：

• 页面访问形式

• 接口调用访问形式

2、继承 BasicErrorController ，重写 error() 方法

对于接口调用访问的形式来说，我们可以来继承 BasicErrorController 类，重写 error() 方法，在 error() 方法里面对全局异常进行统一处理。

通过观察 BasicErrorController 可以发现，它处理的就是 /error 请求。我们继承 BasicErrorController 之后，就只需要重新组装 /error 的请求返回即可。

代码实现如下：

@RestController
public class ErrorController extends BasicErrorController {

    private static final Logger log = LoggerFactory.getLogger(ErrorController.class);

    public ErrorController() {
        super(new DefaultErrorAttributes(), new ErrorProperties());
    }

    /**
     * produces 设置返回的数据类型：application/json
     *
     * @param request 请求
     * @return 自定义的返回实体类
     */
    @Override
    @RequestMapping(value = "", produces = {MediaType.APPLICATION_JSON_VALUE})
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.ALL));
        HttpStatus status = getStatus(request);
        // 获取错误信息
        String message = body.get("message").toString();
        int code = EnumUtil.getCodeByMsg(message, ResultEnum.class);

        HttpStatus httpStatus;
        if (code == 500) {
            // 服务端异常，状态码为500
            httpStatus = HttpStatus.INTERNAL_SERVER_ERROR;
        } else {
            // 其余异常（手动throw）为逻辑校验，状态码为200
            httpStatus = HttpStatus.OK;
        }
        return new ResponseEntity(Result.failed(code, message), httpStatus);
    }

}

其中注解 @RestController 是必填的，@RequestMapping 的 value 值必须为空。

3、全局异常统一处理逻辑

核心：

• 创建 ResultEnum 枚举类，用来存储多个异常信息（ code 和 msg ）。

• 创建自定义异常类 CustomException，让其可以接收 ResultEnum 枚举类内容。方便程序 throw 。

• 创建 Result 类，用于封装返回结果到前端。

• 重写 error() 方法。

在 error() 方法中，我们可以获取到原 /error 请求的返回结果，然后获取 message 报错信息。然后根据 message 来获取枚举类与之对应的 code 值，然后将 code 和 message 填充到 Result 主体，返回到前端。

又对 HttpStatus 请求状态码进行了判断，当手动 throw 抛出的异常，请求状态码为 200；如果是程序预料之外的异常，没有处理的，请求状态码就是 500 。

ResultEnum 枚举类：

/**
 * 统一管理返回数据结果code和message，返回结果枚举
 *
 * @author create17
 * @date 2020/5/13
 */
public enum ResultEnum implements CodeEnum {

    /**
     * clientid expired
     */
    ZERO_EXCEPTION(1052, "/ by zero")
    ;

    private int code;

    private String msg;

    ResultEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    @Override
    public int getCode() {
        return code;
    }

    @Override
    public String getMsg() {
        return msg;
    }

}

CustomException 自定义异常类：

/**
 * 自定义异常类
 *
 * @author create17
 * @date 2020/5/13
 */
@EqualsAndHashCode(callSuper = true)
@Data
public class CustomException extends RuntimeException {

    private int code;

    private String msg;

    public CustomException(ResultEnum resultEnum) {
        // 自定义错误栈中显示的message
        super(resultEnum.getMsg());
        this.code = resultEnum.getCode();
        this.msg = resultEnum.getMsg();
    }

    public CustomException(int code, String msg) {
        // 自定义错误栈中显示的message
        super(msg);
        this.code = code;
        this.msg = msg;
    }
}

CodeEnum 接口：

/**
 * @author create17
 * @date 2020/7/24
 */
public interface CodeEnum {

    int getCode();

    String getMsg();

}

EnumUtil 工具类：

/**
 * 通过code找到msg, 通过msg找到code
 * 
 * @author create17
 * @date 2020/7/24
 */
public class EnumUtil {

    public static <T extends CodeEnum> String getMsgByCode(Integer code, Class<T> t){
        for(T item: t.getEnumConstants()){
            if(item.getCode() == code){
                return item.getMsg();
            }
        }
        return "";
    }

    public static <T extends CodeEnum> Integer getCodeByMsg(String msg, Class<T> t){
        for(T item: t.getEnumConstants()){
            if(StrUtil.equals(item.getMsg(),msg)){
                return item.getCode();
            }
        }
        return 500;
    }

}

Result 类：

/**
 * 响应信息主体
 *
 * @author create17
 * @date 2020/5/28
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> implements Serializable {
    private static final long serialVersionUID = 1L;

    public static final int SUCCESS_CODE = 0;

    public static final int FAIL_CODE = 1;

    public static final String SUCCESS_MSG = "success";

    public static final String FAIL_MSG = "error";

    /**
     * 返回标记：成功标记=0，失败标记=1
     */
    private int code;

    /**
     * 返回信息
     */
//    @JsonProperty("message")
    private String message;

    /**
     * 数据
     */
//    @JsonProperty("results")
    private T results;

    public static <T> Result<T> ok() {
        return restResult(null, SUCCESS_CODE, SUCCESS_MSG);
    }

    public static <T> Result<T> ok(T data) {
        return restResult(data, SUCCESS_CODE, SUCCESS_MSG);
    }

    public static <T> Result<T> ok(T data, String msg) {
        return restResult(data, SUCCESS_CODE, msg);
    }

    public static <T> Result<T> failed() {
        return restResult(null, FAIL_CODE, FAIL_MSG);
    }

    public static <T> Result<T> failed(String msg) {
        return restResult(null, FAIL_CODE, msg);
    }

    public static <T> Result<T> failed(int code, String msg) {
        return restResult(null, code, msg);
    }

    public static <T> Result<T> failed(ResultEnum resultEnum) {
        return restResult(null, resultEnum.getCode(), resultEnum.getMsg());
    }

    private static <T> Result<T> restResult(T data, int code, String msg) {
        Result<T> apiResult = new Result<>();
        apiResult.setCode(code);
        apiResult.setResults(data);
        apiResult.setMessage(msg);
        return apiResult;
    }
}

4、测试

好了，到这里我们的全局异常就统一处理完了，filter 和 servlet 的异常不出意外的话，都会经过 ErrorController 类。我先现在测试一下。

在 TestFilter 中，添加以下代码：

try {
    int aa = 1/0;
} catch (Exception e) {
    throw new CustomException(ResultEnum.ZERO_EXCEPTION);
}

不出意外的话，异常会被拦截处理，如下图所示：

参考博客：https://blog.csdn.net/Chen_RuiMin/article/details/104418904

五、总结

不总结的文章不是好文章，我们最后来总结一下。

首先是讲解了过滤器 Filter 的使用场景，实现方式，然后提供了两种 Filter 被 Spring 管理的方法，其中特别推荐使用 JavaConfig 配置使 Filter 被 Spring 管理，因为这样不仅可以指定多个 Filter 之间的执行顺序，还能实现在 Filter 里面自动装配一些对象。

第二又介绍了 Servlet 的实现方式，HttpServletRequest 与 HttpServletResponse 的使用。

第三是概述了一下 Filter 与 Servlet 的执行顺序。

第四是文章中最想分享的地方，那就是如何统一处理 Filter 与 Servlet 的全局异常，尝试了很多方法，最终认为继承 BasicErrorController，重写 error() 方法是挺好的实现方式，所以就赶快分享给大家喽~