springboot如何统一处理Filter、Servlet中的异常信息

这篇文章将为大家详细讲解有关spring boot 如何统一处理Filter、Servlet中的异常信息，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。

成都创新互联公司是一家集网站建设,和平企业网站建设,和平品牌网站建设,网站定制,和平网站建设报价,网络营销,网络优化,和平网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

一、过滤器 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 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> error(HttpServletRequest request) {
        Map 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  String getMsgByCode(Integer code, Class t){
        for(T item: t.getEnumConstants()){
            if(item.getCode() == code){
                return item.getMsg();
            }
        }
        return "";
    }

    public static  Integer getCodeByMsg(String msg, Class 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 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  Result ok() {
        return restResult(null, SUCCESS_CODE, SUCCESS_MSG);
    }

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

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

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

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

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

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

    private static  Result restResult(T data, int code, String msg) {
        Result 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() 方法是挺好的实现方式。

关于spring boot 如何统一处理Filter、Servlet中的异常信息就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。

文章标题：springboot如何统一处理Filter、Servlet中的异常信息
链接URL：http://cdxtjz.cn/article/gjgjpj.html