系统开发实践-Spring Cloud 异常封装及传递处理

异常体系定义#

异常编码的设计使用#

这里采用了精简异常代码设计的形式

ServiceException业务异常, 异常编码默认使用BIZ_ERROR, 异常文字提示根据实际情况抛出, 例如

1
private void checkParameter(TApprovalResult result) {
2
    if (Objects.isNull(result)) {
3
        throw new ServiceException("审批结果不能为null");
4
    }
5
    try {
6
        CheckParameterUtil.checkParameter(result);
7
    } catch (Exception e) {
8
        ServiceException exception = new ServiceException("参数校验异常");
9
        exception.addSuppressed(e);
10
        throw exception;
11
    }
12
}

系统设计上, 会针对业务异常, 日志记录上做 WARN 级别设置

系统异常默认使用SYSTEM_ERROR, 提示系统忙, 请稍后再试, 默认非 ServiceException 的异常, 都归属于系统异常, 需要做告警提示并及时修复

异常类型	默认异常 code	默认异常 message	日志记录级别
`ServiceException`	`BIZ_ERROR`	无	WARN
`SystemException`	`SYSTEM_ERROR`	`系统忙, 请稍后再试`	ERROR

Spring Boot 异常捕捉扩展#

spring boot 的 ErrorMvcAutoConfiguration 有参考实现, 我们对其进行扩展, 个性化输出内容

1
@Order(Ordered.HIGHEST_PRECEDENCE)
2
@Slf4j
3
public class CustomErrorAttributes implements ErrorAttributes, HandlerExceptionResolver, Ordered {
4

5
    private static final String ERROR_ATTRIBUTE = CustomErrorAttributes.class.getName() + ".ERROR";
6

7
    private String errorPath;
8

9
    public CustomErrorAttributes(String errorPath) {
10
        this.errorPath = errorPath;
11
    }
12

13
    @Override
14
    public int getOrder() {
15
        return Ordered.HIGHEST_PRECEDENCE;
16
    }
17

18
    @Override
19
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
20
        Exception ex) {
21
        // 在发生异常时，传递异常类型
22
        response.addHeader(HttpHeaderConstants.HEADER_EXCEPTION_NAME, ex.getClass().getName());
23
        storeErrorAttributes(request, ex);
24
        // 如果是业务异常, 日志级别为 warn
25
        if (ex instanceof ServiceException) {
26
            log.warn(ex.getMessage(), ex);
27
            request.setAttribute(ErrorAttributeConstans.ATTR_STATUS, 500);
28
            request.setAttribute(ErrorAttributeConstans.SERVLET_ERROR_STATUS_CODE, 500);
29
            return new ModelAndView(this.errorPath);
30
        }
31
        return null;
32
    }
33

34
    private void storeErrorAttributes(HttpServletRequest request, Exception ex) {
35
        request.setAttribute(ERROR_ATTRIBUTE, ex);
36
    }
37

38
    @Override
39
    public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
40
        Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
41
        errorAttributes.put(ErrorAttributeConstans.ATTR_TIMESTAMP, new Date());
42
        addStatus(errorAttributes, webRequest);
43
        addErrorCode(errorAttributes, webRequest, getError(webRequest));
44
        addErrorDetails(errorAttributes, webRequest, includeStackTrace);
45
        addPath(errorAttributes, webRequest);
46
        return errorAttributes;
47
    }
48

49
    private void addStatus(Map<String, Object> errorAttributes, RequestAttributes requestAttributes) {
50
        Integer status = getAttribute(requestAttributes, ErrorAttributeConstans.SERVLET_ERROR_STATUS_CODE);
51
        if (status == null) {
52
            errorAttributes.put(ErrorAttributeConstans.ATTR_STATUS, 999);
53
            errorAttributes.put(ErrorAttributeConstans.ATTR_ERROR, "None");
54
            return;
55
        }
56
        errorAttributes.put(ErrorAttributeConstans.ATTR_STATUS, status);
57
        try {
58
            errorAttributes.put(ErrorAttributeConstans.ATTR_ERROR, HttpStatus.valueOf(status).getReasonPhrase());
59
        } catch (Exception ex) {
60
            // Unable to obtain a reason
61
            errorAttributes.put(ErrorAttributeConstans.ATTR_ERROR, "Http Status " + status);
62
        }
63
    }
64

65
    private void addErrorCode(Map<String, Object> errorAttributes, RequestAttributes requestAttributes,
66
        Throwable error) {
67
        String code = getAttribute(requestAttributes, ErrorCoded.ATTR_ERROR_CODE);
68
        if (code == null && error instanceof ErrorCoded) {
69
            ErrorCoded errorCoded = (ErrorCoded)error;
70
            code = errorCoded.getErrorCode();
71
        }
72
        if (StringUtils.hasText(code)) {
73
            errorAttributes.put(ErrorAttributeConstans.ATTR_ERROR_CODE, code);
74
        }
75
    }
76

77
    private void addErrorDetails(Map<String, Object> errorAttributes, WebRequest webRequest,
78
        boolean includeStackTrace) {
79
        Throwable error = getError(webRequest);
80
        if (error != null) {
81
            while (error instanceof ServletException && error.getCause() != null) {
82
                error = error.getCause();
83
            }
84
            errorAttributes.put(ErrorAttributeConstans.ATTR_EXCEPTION, error.getClass().getName());
85
            addErrorMessage(errorAttributes, error);
86
            if (includeStackTrace) {
87
                addStackTrace(errorAttributes, error);
88
            }
89
        }
90
        Object message = getAttribute(webRequest, ErrorAttributeConstans.ATTR_MESSAGE);
91
        if (message == null) {
92
            message = getAttribute(webRequest, ErrorAttributeConstans.SERVLET_ERROR_MESSAGE);
93
        }
94
        if ((!StringUtils.isEmpty(message)) && !(error instanceof BindingResult)) {
95
            errorAttributes.put(ErrorAttributeConstans.ATTR_MESSAGE,
96
                StringUtils.isEmpty(message) ? "No message available" : message);
97
        }
98
    }
99

100
    private void addErrorMessage(Map<String, Object> errorAttributes, Throwable error) {
101
        BindingResult result = extractBindingResult(error);
102
        if (result == null) {
103
            if (error instanceof ErrorCodedException) {
104
                errorAttributes.put(ErrorAttributeConstans.ATTR_MESSAGE, error.getMessage());
105
                return;
106
            }
107
            errorAttributes.put(ErrorAttributeConstans.ATTR_MESSAGE, "系统忙, 请稍后再试");
108
            errorAttributes.put(ErrorAttributeConstans.ATTR_ERROR_MESSAGE, error.getMessage());
109
            return;
110
        }
111
        if (result.getErrorCount() > 0) {
112
            errorAttributes.put(ErrorAttributeConstans.ATTR_ERROR, result.getAllErrors());
113
            errorAttributes.put(ErrorAttributeConstans.ATTR_MESSAGE, getBindingResultMessage(result));
114
        } else {
115
            errorAttributes.put(ErrorAttributeConstans.ATTR_MESSAGE, "参数绑定失败");
116
        }
117
    }
118

119
    private String getBindingResultMessage(BindingResult result) {
120
        StringBuilder sb = new StringBuilder();
121
        for (ObjectError objectError : result.getAllErrors()) {
122
            if (objectError instanceof FieldError) {
123
                sb = appendFieldError(sb, (FieldError)objectError);
124
            } else {
125
                sb = appendObjectError(sb, objectError);
126
            }
127
            sb.append("\n");
128
        }
129
        return sb.toString();
130
    }
131

132
    private StringBuilder appendFieldError(StringBuilder sb, FieldError fieldError) {
133
        return sb.append(fieldError.getObjectName()).append(".").append(fieldError.getField()).append(":")
134
            .append(fieldError.getDefaultMessage());
135
    }
136

137
    private StringBuilder appendObjectError(StringBuilder sb, ObjectError objectError) {
138
        return sb.append(objectError.getObjectName()).append(":").append(objectError.getDefaultMessage());
139
    }
140

141
    private BindingResult extractBindingResult(Throwable error) {
142
        if (error instanceof BindingResult) {
143
            return (BindingResult)error;
144
        }
145
        if (error instanceof MethodArgumentNotValidException) {
146
            return ((MethodArgumentNotValidException)error).getBindingResult();
147
        }
148
        return null;
149
    }
150

151
    private void addStackTrace(Map<String, Object> errorAttributes, Throwable error) {
152
        StringWriter stackTrace = new StringWriter();
153
        error.printStackTrace(new PrintWriter(stackTrace));
154
        stackTrace.flush();
155
        errorAttributes.put(ErrorAttributeConstans.ATTR_TRACE, stackTrace.toString());
156
    }
157

158
    private void addPath(Map<String, Object> errorAttributes, RequestAttributes requestAttributes) {
159
        String path = getAttribute(requestAttributes, ErrorAttributeConstans.SERVLET_ERROR_REQUEST_URI);
160
        if (path != null) {
161
            errorAttributes.put(ErrorAttributeConstans.ATTR_PATH, path);
162
        }
163
    }
164

165
    @Override
166
    public Throwable getError(WebRequest webRequest) {
167
        Throwable exception = getAttribute(webRequest, ERROR_ATTRIBUTE);
168
        if (exception == null) {
169
            exception = getAttribute(webRequest, ErrorAttributeConstans.SERVLET_ERROR_EXCEPTION);
170
        }
171
        return exception;
172
    }
173

174
    @SuppressWarnings("unchecked")
175
    private <T> T getAttribute(RequestAttributes requestAttributes, String name) {
176
        return (T)requestAttributes.getAttribute(name, RequestAttributes.SCOPE_REQUEST);
177
    }
178
}

同时配合 spring boot 的 AutoConfiguration 机制, 让我们的 CustomErrorAttributes 生效

1
@Configuration
2
@ConditionalOnWebApplication
3
@ConditionalOnClass({Servlet.class, DispatcherServlet.class})
4
// Load before the main WebMvcAutoConfiguration so that the error View is available
5
@AutoConfigureBefore(ErrorMvcAutoConfiguration.class)
6
public class CustomErrorMvcAutoConfiguration {
7

8
    @Value("${server.error.path:${error.path:/error}}")
9
    private String errorPath;
10

11
    @Bean
12
    @ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
13
    public CustomErrorAttributes customErrorAttributes() {
14
        return new CustomErrorAttributes(this.errorPath);
15
    }
16
}

Spring Cloud 的 openfeign 异常传递改造#

spring cloud 微服务, 我们用的 openfeign 声明式调用, 还需要对异常传递进行扩展, 实现在调用方调用服务时, 能够获取服务提供方抛出的异常

1
@Slf4j
2
public class ErrorCodedExceptionErrorDecoder implements ErrorDecoder {
3

4
    private static final String SERVICE_EXCEPTION_NAME = ServiceException.class.getName();
5

6
    @Override
7
    public Exception decode(String methodKey, Response response) {
8
        int status = response.status();
9

10
        String exceptionName = null;
11

12
        Collection<String> list = response.headers().get(HttpHeaderConstants.HEADER_EXCEPTION_NAME);
13
        if (!CollectionUtils.isEmpty(list)) {
14
            for (String s : list) {
15
                if (StringUtils.hasText(s)) {
16
                    exceptionName = s;
17
                    log.info("捕捉到 feign 异常类型: {}", exceptionName);
18
                    break;
19
                }
20
            }
21
        }
22

23
        if (404 == status) { // 服务 url 不正确, 抛出特殊异常
24
            throw new ServiceNotFoundException(
25
                String.format("Service %s not found for %s", response.request().url(), methodKey));
26
        }
27

28
        String errorCode = null;
29
        String message = null;
30
        HttpStatus httpStatus = HttpStatus.valueOf(status);
31
        if (httpStatus.is4xxClientError()) {
32
            errorCode = String.valueOf(status);
33
            message = errorCode + ": " + httpStatus.getReasonPhrase();
34
        } else if (httpStatus.is5xxServerError()) {
35
            try {
36
                ErrorBody errorBody = JacksonUtils.jsonToObject(response.body().asInputStream(), ErrorBody.class);
37
                errorCode = errorBody.getErrorCode();
38
                if (errorBody.getErrorMessage() != null) {
39
                    message = errorBody.getErrorMessage();
40
                } else {
41
                    message = errorBody.getMessage();
42
                }
43
            } catch (IOException e) {
44
                log.error("读取二进制流失败", e);
45
            }
46
        }
47

48
        if (SERVICE_EXCEPTION_NAME.equalsIgnoreCase(exceptionName)) {
49
            return new ServiceException(message);
50
        } else {
51
            return new SystemException(errorCode, message);
52
        }
53
    }
54

55
    @Data
56
    private static class ErrorBody implements ErrorCoded {
57

58
        private String errorCode;
59

60
        private String message;
61

62
        private String errorMessage;
63
    }
64
}

系统开发实践-Spring Cloud 异常封装及传递处理

异常体系定义#

异常编码的设计使用#

Spring Boot 异常捕捉扩展#

Spring Cloud 的 openfeign 异常传递改造#

文章分享