温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

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

发布时间:2021-12-02 15:28:06 来源:亿速云 阅读:187 作者:柒染 栏目:大数据

这篇文章将为大家详细讲解有关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 数组,如下图所示:

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

这种方式虽然可以指定 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 遇到错误的时候,拥有自己的一套错误提示逻辑,分为两种情况:

  • 页面访问形式

spring boot 如何统一处理Filter、Servlet中的异常信息  
  • 接口调用访问形式

spring boot 如何统一处理Filter、Servlet中的异常信息  
 
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);
}
 

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

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

参考博客: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中的异常信息就分享到这里了,希望以上内容可以对大家有一定的帮助,可以学到更多知识。如果觉得文章不错,可以把它分享出去让更多的人看到。

向AI问一下细节

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

AI