SpringBoot中如何進(jìn)行全局異常處理方式

更新時間：2024年11月05日 11:34:34 作者：houxian1103

在SpringBoot開發(fā)過程中,全局異常處理能提高程序的魯棒性并降低代碼耦合,通過使用@RestControllerAdvice和@ExceptionHandler注解,可以實(shí)現(xiàn)對程序異常的全局?jǐn)r截和處理,首先需要自定義一個繼承自ResponseEntityExceptionHandler的異常處理類

前言

在SpringBoot的開發(fā)中，為了提高程序運(yùn)行的魯棒性，我們經(jīng)常需要對各種程序異常進(jìn)行處理，但是如果在每個出異常的地方進(jìn)行單獨(dú)處理的話，這會引入大量業(yè)務(wù)不相關(guān)的異常處理代碼，增加了程序的耦合，同時未來想改變異常的處理邏輯，也變得比較困難。這篇文章帶大家了解一下如何優(yōu)雅的進(jìn)行全局異常處理。

為了實(shí)現(xiàn)全局?jǐn)r截，這里使用到了Spring中提供的兩個注解，@RestControllerAdvice和@ExceptionHandler，結(jié)合使用可以攔截程序中產(chǎn)生的異常，并且根據(jù)不同的異常類型分別處理。下面我會先介紹如何利用這兩個注解，優(yōu)雅的完成全局異常的處理，接著解釋這背后的原理。

如何實(shí)現(xiàn)全局?jǐn)r截？

1.1 自定義異常處理類

在下面的例子中，我們繼承了ResponseEntityExceptionHandler并使用@RestControllerAdvice注解了這個類，接著結(jié)合@ExceptionHandler針對不同的異常類型，來定義不同的異常處理方法。

這里可以看到我處理的異常是自定義異常，后續(xù)我會展開介紹。

ResponseEntityExceptionHandler中包裝了各種SpringMVC在處理請求時可能拋出的異常的處理，處理結(jié)果都是封裝成一個ResponseEntity對象。
ResponseEntityExceptionHandler是一個抽象類，通常我們需要定義一個用來處理異常的使用@RestControllerAdvice注解標(biāo)注的異常處理類來繼承自ResponseEntityExceptionHandler。
ResponseEntityExceptionHandler中為每個異常的處理都單獨(dú)定義了一個方法，如果默認(rèn)的處理不能滿足你的需求，則可以重寫對某個異常的處理。

@Log4j2  
@RestControllerAdvice  
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {  

    /**  
     * 定義要捕獲的異常 可以多個 @ExceptionHandler({})     *  
     * @param request  request  
     * @param e        exception  
     * @param response response  
     * @return 響應(yīng)結(jié)果  
     */  
    @ExceptionHandler(AuroraRuntimeException.class)  
    public GenericResponse customExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {  
        AuroraRuntimeException exception = (AuroraRuntimeException) e;  

       if (exception.getCode() == ResponseCode.USER_INPUT_ERROR) {  
           response.setStatus(HttpStatus.BAD_REQUEST.value());  
       } else if (exception.getCode() == ResponseCode.FORBIDDEN) {  
           response.setStatus(HttpStatus.FORBIDDEN.value());  
       } else {  
           response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());  
       }  

        return new GenericResponse(exception.getCode(), null, exception.getMessage());  
    }  

    @ExceptionHandler(NotLoginException.class)  
    public GenericResponse tokenExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {  
        log.error("token exception", e);  
        response.setStatus(HttpStatus.FORBIDDEN.value());  
        return new GenericResponse(ResponseCode.AUTHENTICATION_NEEDED);  
    }  

}

1.2 定義異常碼

這里定義了常見的幾種異常碼，主要用在拋出自定義異常時，對不同的情形進(jìn)行區(qū)分。

@Getter  
public enum ResponseCode {  

    SUCCESS(0, "Success"),  

    INTERNAL_ERROR(1, "服務(wù)器內(nèi)部錯誤"),  

    USER_INPUT_ERROR(2, "用戶輸入錯誤"),  

    AUTHENTICATION_NEEDED(3, "Token過期或無效"),  

    FORBIDDEN(4, "禁止訪問"),  

    TOO_FREQUENT_VISIT(5, "訪問太頻繁，請休息一會兒");  

    private final int code;  

    private final String message;  

    private final Response.Status status;  

    ResponseCode(int code, String message, Response.Status status) {  
        this.code = code;  
        this.message = message;  
        this.status = status;  
    }  

    ResponseCode(int code, String message) {  
        this(code, message, Response.Status.INTERNAL_SERVER_ERROR);  
    }  

}

1.3 自定義異常類

這里我定義了一個AuroraRuntimeException的異常，就是在上面的異常處理函數(shù)中，用到的異常。

每個異常實(shí)例會有一個對應(yīng)的異常碼，也就是前面剛定義好的。

@Getter  
public class AuroraRuntimeException extends RuntimeException {  

    private final ResponseCode code;  

    public AuroraRuntimeException() {  
        super(String.format("%s", ResponseCode.INTERNAL_ERROR.getMessage()));  
        this.code = ResponseCode.INTERNAL_ERROR;  
    }  

    public AuroraRuntimeException(Throwable e) {  
        super(e);  
        this.code = ResponseCode.INTERNAL_ERROR;  
    }  

    public AuroraRuntimeException(String msg) {  
        this(ResponseCode.INTERNAL_ERROR, msg);  
    }  

    public AuroraRuntimeException(ResponseCode code) {  
        super(String.format("%s", code.getMessage()));  
        this.code = code;  
    }  

    public AuroraRuntimeException(ResponseCode code, String msg) {  
        super(msg);  
        this.code = code;  
    }  

}

1.4 自定義返回類型

為了保證各個接口的返回統(tǒng)一，這里專門定義了一個返回類型。

@Getter  
@Setter  
public class GenericResponse<T> {  

    private int code;  

    private T data;  

    private String message;  

    public GenericResponse() {};  

    public GenericResponse(int code, T data) {  
        this.code = code;  
        this.data = data;  
    }  

    public GenericResponse(int code, T data, String message) {  
        this(code, data);  
        this.message = message;  
    }  

    public GenericResponse(ResponseCode responseCode) {  
        this.code = responseCode.getCode();  
        this.data = null;  
        this.message = responseCode.getMessage();  
    }  

    public GenericResponse(ResponseCode responseCode, T data) {  
        this(responseCode);  
        this.data = data;  
    }  

    public GenericResponse(ResponseCode responseCode, T data, String message) {  
        this(responseCode, data);  
        this.message = message;  
    }  
}

實(shí)際測試異常

下面的例子中，我們想獲取到用戶的信息，如果用戶的信息不存在，可以直接拋出一個異常，這個異常會被我們上面定義的全局異常處理方法所捕獲，然后根據(jù)不同的異常編碼，完成不同的處理和返回。

public User getUserInfo(Long userId) {  
    // some logic

    User user = daoFactory.getExtendedUserMapper().selectByPrimaryKey(userId);  
    if (user == null) {  
        throw new AuroraRuntimeException(ResponseCode.USER_INPUT_ERROR, "用戶id不存在");  
    }

    // some logic
    ....
}

以上就完成了整個全局異常的處理過程，接下來重點(diǎn)說說為什么@RestControllerAdvice和@ExceptionHandler結(jié)合使用可以攔截程序中產(chǎn)生的異常？

全局?jǐn)r截的背后原理？

下面會提到@ControllerAdvice注解，簡單地說，@RestControllerAdvice與@ControllerAdvice的區(qū)別就和@RestController與@Controller的區(qū)別類似，@RestControllerAdvice注解包含了@ControllerAdvice注解和@ResponseBody注解。

public class DispatcherServlet extends FrameworkServlet {
    // ......
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);

        // 重點(diǎn)關(guān)注
        initHandlerExceptionResolvers(context);

        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }
    // ......
}

在initHandlerExceptionResolvers(context)方法中，會取得所有實(shí)現(xiàn)了HandlerExceptionResolver接口的bean并保存起來，其中就有一個類型為ExceptionHandlerExceptionResolver的bean，這個bean在應(yīng)用啟動過程中會獲取所有被@ControllerAdvice注解標(biāo)注的bean對象做進(jìn)一步處理，關(guān)鍵代碼在這里：

public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
        implements ApplicationContextAware, InitializingBean {
    // ......
    private void initExceptionHandlerAdviceCache() {
        // ......
        List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
        AnnotationAwareOrderComparator.sort(adviceBeans);

        for (ControllerAdviceBean adviceBean : adviceBeans) {
            ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(adviceBean.getBeanType());
            if (resolver.hasExceptionMappings()) {
                // 找到所有ExceptionHandler標(biāo)注的方法并保存成一個ExceptionHandlerMethodResolver類型的對象緩存起來
                this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
                if (logger.isInfoEnabled()) {
                    logger.info("Detected @ExceptionHandler methods in " + adviceBean);
                }
            }
            // ......
        }
    }
    // ......
}

當(dāng)Controller拋出異常時，DispatcherServlet通過ExceptionHandlerExceptionResolver來解析異常，而ExceptionHandlerExceptionResolver又通過ExceptionHandlerMethodResolver 來解析異常， ExceptionHandlerMethodResolver 最終解析異常找到適用的@ExceptionHandler標(biāo)注的方法是這里：

public class ExceptionHandlerMethodResolver {
    // ......
    private Method getMappedMethod(Class<? extends Throwable> exceptionType) {
        List<Class<? extends Throwable>> matches = new ArrayList<Class<? extends Throwable>>();
        // 找到所有適用于Controller拋出異常的處理方法,例如Controller拋出的異常
        // 是AuroraRuntimeException(繼承自RuntimeException),那么@ExceptionHandler(AuroraRuntimeException.class)和
        // @ExceptionHandler(Exception.class)標(biāo)注的方法都適用此異常
        for (Class<? extends Throwable> mappedException : this.mappedMethods.keySet()) {
            if (mappedException.isAssignableFrom(exceptionType)) {
                matches.add(mappedException);
            }
        }
        if (!matches.isEmpty()) {
        /* 這里通過排序找到最適用的方法,排序的規(guī)則依據(jù)拋出異常相對于聲明異常的深度,例如
    Controller拋出的異常是是AuroraRuntimeException(繼承自RuntimeException),那么AuroraRuntimeException
    相對于@ExceptionHandler(AuroraRuntimeException.class)聲明的AuroraRuntimeException.class其深度是0,
    相對于@ExceptionHandler(Exception.class)聲明的Exception.class其深度是2,所以
    @ExceptionHandler(BizException.class)標(biāo)注的方法會排在前面 */
            Collections.sort(matches, new ExceptionDepthComparator(exceptionType));
            return this.mappedMethods.get(matches.get(0));
        }
        else {
            return null;
        }
    }
    // ......
}

整個@RestControllerAdvice處理的流程就是這樣，結(jié)合@ExceptionHandler就完成了對不同異常的靈活處理。