2. 程式人生 > >Springboot專案全域性異常統一處理

Springboot專案全域性異常統一處理

阿新 • • 發佈：2019-01-23

最近在做專案時需要對異常進行全域性統一處理，主要是一些分類入庫以及記錄日誌等，因為專案是基於Springboot的，所以去網路上找了一些部落格文件，然後再結合專案本身的一些特殊需求做了些許改造，現在記錄下來便於以後檢視。

在網路上找到關於Springboot全域性異常統一處理的文件部落格主要是兩種方案：

1、基於@ControllerAdvice註解的Controller層的全域性異常統一處理

以下是網上一位博主給出的程式碼示例，該部落格地址為：https://www.cnblogs.com/magicalSam/p/7198420.html

import org.springframework.ui.Model;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * controller 增強器
 *
 * @author sam
 * @since 2017/7/17
 */
@ControllerAdvice
public class MyControllerAdvice {

    /**
     * 全域性異常捕捉處理
     * @param ex
     * @return
     */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public Map errorHandler(Exception ex) {
        Map map = new HashMap();
        map.put("code", 100);
        map.put("msg", ex.getMessage());
        return map;
    }
    
    /**
     * 攔截捕捉自定義異常 MyException.class
     * @param ex
     * @return
     */
    @ResponseBody
    @ExceptionHandler(value = MyException.class)
    public Map myErrorHandler(MyException ex) {
        Map map = new HashMap();
        map.put("code", ex.getCode());
        map.put("msg", ex.getMsg());
        return map;
    }

}

這個程式碼示例寫的非常淺顯易懂，但是需要注意的是：基於@ControllerAdvice註解的全域性異常統一處理只能針對於Controller層的異常，意思是隻能捕獲到Controller層的異常，在service層或者其他層面的異常都不能捕獲。

根據這段示例程式碼以及結合專案本身的實際需求，對該例項程式碼做了稍微改造（其實幾乎沒做改造，只是業務處理不一樣而已）：

@ControllerAdvice
public class AdminExceptionHandler {

    private static final Logger logger = LoggerFactory.getLogger(AdminExceptionHandler.class);

    /**
      * @Author: gmy
      * @Description: 系統異常捕獲處理
      * @Date: 16:07 2018/5/30
      */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public APIResponse javaExceptionHandler(Exception ex) {//APIResponse是專案中對外統一的出口封裝，可以根據自身專案的需求做相應更改
        logger.error("捕獲到Exception異常",ex);
        //異常日誌入庫

        return new APIResponse(APIResponse.FAIL,null,ex.getMessage());
    }

    /**
      * @Author: gmy
      * @Description: 自定義異常捕獲處理
      * @Date: 16:08 2018/5/30
      */
    @ResponseBody
    @ExceptionHandler(value = MessageCenterException.class)//MessageCenterException是自定義的一個異常
    public APIResponse messageCenterExceptionHandler(MessageCenterException ex) {
        logger.error("捕獲到MessageCenterException異常",ex.getException());
        //異常日誌入庫

        return ex.getApiResponse();
    }

}
 
public class MessageCenterException extends RuntimeException {

    public MessageCenterException(APIResponse apiResponse, Exception exception){
        this.apiResponse = apiResponse;
        this.exception = exception;
    }

    private Exception exception;
    private APIResponse apiResponse;

    public Exception getException() {
        return exception;
    }

    public void setException(Exception exception) {
        this.exception = exception;
    }

    public APIResponse getApiResponse() {
        return apiResponse;
    }

    public void setApiResponse(APIResponse apiResponse) {
        this.apiResponse = apiResponse;
    }
}

經過測試發現可以捕獲到Controller層的異常，當前前提是Controller層沒有對異常進行catch處理，如果Controller層對異常進行了catch處理，那麼在這裡就不會捕獲到Controller層的異常了，所以這一點要特別注意。

在實際測試中還發現，如果在Controller中不做異常catch處理，在service中丟擲異常（service中也不錯異常catch處理），那麼也是可以在這裡捕獲到異常的。

2、基於Springboot自身的全域性異常統一處理，主要是實現ErrorController介面或者繼承AbstractErrorController抽象類或者繼承BasicErrorController類

以下是網上一位博主給出的示例程式碼，部落格地址為：https://blog.csdn.net/king_is_everyone/article/details/53080851

@Controller
@RequestMapping(value = "error")
@EnableConfigurationProperties({ServerProperties.class})
public class ExceptionController implements ErrorController {

    private ErrorAttributes errorAttributes;

    @Autowired
    private ServerProperties serverProperties;


    /**
     * 初始化ExceptionController
     * @param errorAttributes
     */
    @Autowired
    public ExceptionController(ErrorAttributes errorAttributes) {
        Assert.notNull(errorAttributes, "ErrorAttributes must not be null");
        this.errorAttributes = errorAttributes;
    }


    /**
     * 定義404的ModelAndView
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(produces = "text/html",value = "404")
    public ModelAndView errorHtml404(HttpServletRequest request,
                                  HttpServletResponse response) {
        response.setStatus(getStatus(request).value());
        Map<String, Object> model = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        return new ModelAndView("error/404", model);
    }

    /**
     * 定義404的JSON資料
     * @param request
     * @return
     */
    @RequestMapping(value = "404")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> error404(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String, Object>>(body, status);
    }

    /**
     * 定義500的ModelAndView
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(produces = "text/html",value = "500")
    public ModelAndView errorHtml500(HttpServletRequest request,
                                  HttpServletResponse response) {
        response.setStatus(getStatus(request).value());
        Map<String, Object> model = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        return new ModelAndView("error/500", model);
    }


    /**
     * 定義500的錯誤JSON資訊
     * @param request
     * @return
     */
    @RequestMapping(value = "500")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> error500(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.TEXT_HTML));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String, Object>>(body, status);
    }


    /**
     * Determine if the stacktrace attribute should be included.
     * @param request the source request
     * @param produces the media type produced (or {@code MediaType.ALL})
     * @return if the stacktrace attribute should be included
     */
    protected boolean isIncludeStackTrace(HttpServletRequest request,
                                          MediaType produces) {
        ErrorProperties.IncludeStacktrace include = this.serverProperties.getError().getIncludeStacktrace();
        if (include == ErrorProperties.IncludeStacktrace.ALWAYS) {
            return true;
        }
        if (include == ErrorProperties.IncludeStacktrace.ON_TRACE_PARAM) {
            return getTraceParameter(request);
        }
        return false;
    }


    /**
     * 獲取錯誤的資訊
     * @param request
     * @param includeStackTrace
     * @return
     */
    private Map<String, Object> getErrorAttributes(HttpServletRequest request,
                                                   boolean includeStackTrace) {
        RequestAttributes requestAttributes = new ServletRequestAttributes(request);
        return this.errorAttributes.getErrorAttributes(requestAttributes,
                includeStackTrace);
    }

    /**
     * 是否包含trace
     * @param request
     * @return
     */
    private boolean getTraceParameter(HttpServletRequest request) {
        String parameter = request.getParameter("trace");
        if (parameter == null) {
            return false;
        }
        return !"false".equals(parameter.toLowerCase());
    }

    /**
     * 獲取錯誤編碼
     * @param request
     * @return
     */
    private HttpStatus getStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request
                .getAttribute("javax.servlet.error.status_code");
        if (statusCode == null) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        try {
            return HttpStatus.valueOf(statusCode);
        }
        catch (Exception ex) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
    }

    /**
     * 實現錯誤路徑,暫時無用
     * @see ExceptionMvcAutoConfiguration#containerCustomizer()
     * @return
     */
    @Override
    public String getErrorPath() {
        return "";
    }

}

該示例寫的也是非常簡單明瞭的，但是結合本身專案的實際需求，也是不能直接拿來用的，需要做相應的改造，改造主要有以下方面：

1、因為專案是前後端分離的，所以Controller層不會有ModelAndView返回型別，需要返回自身的APIResponse返回型別

2、專案需要統計全部的異常，而不只是404或者500的異常

3、捕獲到異常之後需要做特殊化的業務處理

所以基於以上幾方面對示例程式碼做了改造，具體改造程式碼如下：

/**
 * @Author: gmy
 * @Description: Springboot全域性異常統一處理
 * @Date: 2018/5/30
 * @Time: 16:41
 */
@RestController
@EnableConfigurationProperties({ServerProperties.class})
public class ExceptionController implements ErrorController {

    private ErrorAttributes errorAttributes;

    @Autowired
    private ServerProperties serverProperties;


    /**
     * 初始化ExceptionController
     * @param errorAttributes
     */
    @Autowired
    public ExceptionController(ErrorAttributes errorAttributes) {
        Assert.notNull(errorAttributes, "ErrorAttributes must not be null");
        this.errorAttributes = errorAttributes;
    }


    @RequestMapping(value = "/error") 
    @ResponseBody
    public APIResponse error(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.ALL));
        HttpStatus status = getStatus(request);
        return new APIResponse(APIResponse.FAIL,null,body.get("message").toString());
    }




    /**
     * Determine if the stacktrace attribute should be included.
     * @param request the source request
     * @param produces the media type produced (or {@code MediaType.ALL})
     * @return if the stacktrace attribute should be included
     */
    protected boolean isIncludeStackTrace(HttpServletRequest request,
                                          MediaType produces) {
        ErrorProperties.IncludeStacktrace include = this.serverProperties.getError().getIncludeStacktrace();
        if (include == ErrorProperties.IncludeStacktrace.ALWAYS) {
            return true;
        }
        if (include == ErrorProperties.IncludeStacktrace.ON_TRACE_PARAM) {
            return getTraceParameter(request);
        }
        return false;
    }


    /**
     * 獲取錯誤的資訊
     * @param request
     * @param includeStackTrace
     * @return
     */
    private Map<String, Object> getErrorAttributes(HttpServletRequest request,
                                                   boolean includeStackTrace) {
        RequestAttributes requestAttributes = new ServletRequestAttributes(request);
        return this.errorAttributes.getErrorAttributes(requestAttributes,
                includeStackTrace);
    }

    /**
     * 是否包含trace
     * @param request
     * @return
     */
    private boolean getTraceParameter(HttpServletRequest request) {
        String parameter = request.getParameter("trace");
        if (parameter == null) {
            return false;
        }
        return !"false".equals(parameter.toLowerCase());
    }

    /**
     * 獲取錯誤編碼
     * @param request
     * @return
     */
    private HttpStatus getStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request
                .getAttribute("javax.servlet.error.status_code");
        if (statusCode == null) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        try {
            return HttpStatus.valueOf(statusCode);
        }
        catch (Exception ex) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
    }

    /**
     * 實現錯誤路徑,暫時無用
     * @return
     */
    @Override
    public String getErrorPath() {
        return "";
    }

}

經過測試，可以捕獲到所有層面上的異常，當前前提仍然是沒有對異常進行catch處理，否則這裡也是捕獲不到

以上為網路上常用的兩種全域性異常統一處理方案，經過實際測試發現都可以實現滿足要求。

其實基於AOP也可以實現異常的全域性處理，自己相應的做了測試發現也滿足要求，相應的程式碼如下：

/**
 * @Author: gmy
 * @Description: 基於AOP的全域性異常統一處理
 * @Date: 2018/6/1
 * @Time: 13:46
 */
@Component
@Aspect
public class ExceptionAspectController {
    public static final Logger logger = LoggerFactory.getLogger(ExceptionAspectController.class);

    @Pointcut("execution(* com.test.test.*.*(..))")//此處基於自身專案的路徑做具體的設定
    public void pointCut(){}

    @Around("pointCut()")
    public Object handleControllerMethod(ProceedingJoinPoint pjp) {
        Stopwatch stopwatch = Stopwatch.createStarted();

        APIResponse<?> apiResponse;
        try {
            logger.info("執行Controller開始: " + pjp.getSignature() + " 引數：" + Lists.newArrayList(pjp.getArgs()).toString());
            apiResponse = (APIResponse<?>) pjp.proceed(pjp.getArgs());
            logger.info("執行Controller結束: " + pjp.getSignature() + "， 返回值：" + apiResponse.toString());
            logger.info("耗時：" + stopwatch.stop().elapsed(TimeUnit.MILLISECONDS) + "(毫秒).");
        } catch (Throwable throwable) {
            apiResponse = handlerException(pjp, throwable);
        }

        return apiResponse;
    }

    private APIResponse<?> handlerException(ProceedingJoinPoint pjp, Throwable e) {
        APIResponse<?> apiResponse = null;
        if(e.getClass().isAssignableFrom(MessageCenterException.class) ){
            MessageCenterException messageCenterException = (MessageCenterException)e;
            logger.error("RuntimeException{方法：" + pjp.getSignature() + "， 引數：" + pjp.getArgs() + ",異常：" + messageCenterException.getException().getMessage() + "}", e);
            apiResponse = messageCenterException.getApiResponse();
        } else if (e instanceof RuntimeException) {
            logger.error("RuntimeException{方法：" + pjp.getSignature() + "， 引數：" + pjp.getArgs() + ",異常：" + e.getMessage() + "}", e);
            apiResponse = new APIResponse(APIResponse.FAIL,null,e.getMessage());
        } else {
            logger.error("異常{方法：" + pjp.getSignature() + "， 引數：" + pjp.getArgs() + ",異常：" + e.getMessage() + "}", e);
            apiResponse = new APIResponse(APIResponse.FAIL,null,e.getMessage());
        }

        return apiResponse;
    }
}

經過測試，在執行切點中配置的路徑中的方法有異常時，可以被這裡捕獲到。

以上是自己瞭解到並且親自測試可行的全域性異常統一處理方案，如果各位博友有什麼問題或者有什麼新的方案可以一塊探討下

相關推薦

Springboot專案全域性異常統一處理

最近在做專案時需要對異常進行全域性統一處理，主要是一些分類入庫以及記錄日誌等，因為專案是基於Springboot的，所以去網路上找了一些部落格文件，然後再結合專案本身的一些特殊需求做了些許改造，現在記錄下來便於以後檢視。在網路上找到關於Springboot全域性異常統一處理的

springmvc、 springboot 專案全域性異常處理

異常在專案中那是不可避免的，通常情況下，我們需要對全域性異常進行處理，下面介紹兩種比較常用的情況。 準備工作： 在捕獲到異常的時候，我們通常需要返回給前端錯誤碼，錯誤資訊等，所以我們需要手動封裝一個jsonData物件，這裡為了方便，我直接通過返回布林型別來進行判斷成功或失敗，在實際的專案中

SpringMVC全域性異常統一處理

（1）使用Spring MVC提供的簡單異常處理器SimpleMappingExceptionResolver：<!-- springmvc提供的簡單異常處理器 --> <be

小編教您Springboot專案中異常攔截設計與處理

專案執行過程中會出現各種各樣的問題，常見的有以下幾種情況： 業務流程分析疏漏，對業務流程的反向操作、邊界分析設計不充分呼叫外部服務、呼叫外部系統出現的超時、錯誤、返回值與預期不符外部資源連通性問題，db等伺服器出現的網路抖動或宕機無論是分析設計、開發、測試、線上都需要能夠準確定位問題並制定解決方案。 目的

SpringBoot異常統一處理機制

springboot官網說了三種異常處理，分為機器客戶端和瀏覽器客戶端，區別為機器客戶端請求返回的是頭中Accept是"/"或者空，異常返回值json,瀏覽器客戶端請求頭中Accept是"text/html" 返回的是html 如下圖: 機器客戶端: 瀏覽器客戶端: 下面

Springboot-系統異常統一處理（介面程式設計異常處理）

Springboot-系統異常統一處理（介面程式設計異常） 1. 系統異常捕獲 /** * 全域性異常處理 * @Author: wangxc * @GitHub: https://github.com/vector4wang * @CS

springboot下全域性異常處理和自定義異常以及自定義返回值

1.介紹    全域性異常處理，是mvc的一個新特性，避免大量的重複程式碼    自定義異常 ， 方便使用，丟擲自己定義好的異常，配合全域性異常處理使用，效果更佳    自定義返回值，類似異常，返回自己定義的返回值 2.全域性異常處理重點知識 1. 新建一

SpringBoot系列全域性異常處理

1、介紹 在日常開發中發生了異常，往往是需要通過一個統一的異常處理處理所有異常，來保證客戶端能夠收到友好的提示。SpringBoot在頁面 發生異常的時候會自動把請求轉到/error，SpringBoot內建了一個BasicErrorController對異常

spring Aop實現身份驗證和springboot異常統一處理

文章有不當之處，歡迎指正，如果喜歡微信閱讀，你也可以關注我的微信公眾號：好好學java，獲取優質學習資源。 一、spring Aop身份驗證 一般，如果使用者沒有登入的話，使用者只可以檢視商品，但是其他的，比如支付等是不能夠進行操作的，這個時候，我們

SpringBoot的全域性異常處理

今天講解一下如何在SpringBoot實現全域性異常機制,在沒有用springboot大家要實現這一的功能基本上都是通過aop的思想,還是有點麻煩，而現在springboot中對它要進行了一次封裝,開發者使用起來更加的簡單,接下先通過程式碼演示效果,然後再分析一下原理,好了廢

java異常統一處理

出現 actor 錯誤 統一處理 type .get 。。 cfa getc 一般系統拋出的錯誤不含錯誤代碼，出去部分的404，500，400之外，我們如果想吧錯誤代碼定義的更細致，就需要自己繼承RuntimeExeption這個類後，重新定義構造方法定義自己的錯誤信息。

Spring MVC異常統一處理的三種方式

  Spring 統一異常處理有 3 種方式，分別為： 使用 @ ExceptionHandler 註解 實現 HandlerExceptionResolver 介面 使用 @controlleradvice 註解 HandlerExceptionReso

spring boot 系統異常統一處理

1.系統異常捕獲 @ControllerAdvice(annotations = {RestController.class}) public class GlobalExceptionHandler { private Logger logger = LoggerFactory.get

全域性異常捕獲處理

import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.lang.exception.ExceptionUt

SpringMVC下全域性異常統一響應返回JSON及自定義異常

Spring MVC框架下一般會自定義全域性異常，再通過Spring MVC下的全域性異常攔截全部轉化為自定義異常。但在controller層處理異常有很多的try{}catch{}，影響效能。所以為了能夠處理異常的同時返回相同的資料結構，定義一個全域性異常統一響應以返回JS

SpringBoot(6) SpringBoot配置全域性異常

1、全域性異常 @ControllerAdvice 如果是返回json資料 則用 RestControllerAdvice,就可以不加 @ResponseBody //捕獲全域性異常,處理所有不可知的異常 @ExceptionHandler(value=Exception.class) 1 @Re

java專案全域性異常攔截

java專案通常是由多人合作開發，但每個人的水平和想法又不一樣，在開發中並不能有效的避免所有異常都能夠有效的捕捉並處理，所以我們需要一個全域性的異常攔截處理，只需要配置一個攔截器即可。 import java.util.HashMap; import javax.

springmvc中全域性異常的處理

一、處理思路 　　 二、建立全域性異常處理器 import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class GlobalExceptionResolver implements HandlerExceptionReso

spring mvc異常統一處理（實現HandlerExceptionResolver介面）不生效的問題解決

spring mvc異常統一處理常見的有3種方式： 使用 @ ExceptionHandler 註解 實現 HandlerExceptionResolver 介面 使用 @controlleradvice 註解 詳細的使用方法可參考博文：https://blog.c

全域性異常的處理

一、處理思路 二、建立全域性異常處理器 GlobalExceptionReslover public class GlobalExceptionReslover implements HandlerExceptionResolver { Logger logger =