2. 程式人生 > >Springboot異常資訊統一處理

Springboot異常資訊統一處理

阿新 • • 發佈：2018-12-05

前景描述: 最近在做專案時發現後臺程式的異常拋到前端頁面上報出一大段sql異常,因此考慮需要對異常進行全域性統一處理，並將日誌進行分類入庫以及記錄介面請求的日誌資訊等，記錄日誌資訊在之前的文章已經有記錄了這裡不再重複有需要的請移步到Spring Boot 使用AOP切面實現後臺日誌管理模組。

因為專案是基於Springboot做的前後端分離的專案，需要結合專案本身的一些特殊需求做些許改造。

在網路上講述的大致這兩種方案：

1、基於@ControllerAdvice註解的Controller層的全域性異常統一處理(最常用,使用較多)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import com.isoftstone.common.utils.web.JsonResult;
import com.isoftstone.common.utils.web.StatusUtil;

/**
 * 全域性異常處理類
 * @ClassName:：ControllerExceptionHandler 
 * @author leon
 * @createDate    2018年9月20日 下午3:39:19 
 * @version    v1.0
 * @classRemarks TODO
 */
@ControllerAdvice
public class ControllerExceptionHandler {
    
    private static Logger logger = LoggerFactory.getLogger(ControllerExceptionHandler.class);
    
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public JsonResult handleException(Exception e){

        //異常日誌入庫


        logger.info("=================exception===============");
        e.printStackTrace();
        return new JsonResult(StatusUtil.ERROR,"系統正忙,請稍後在試......");
    }    
    
    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public JsonResult handleException(RuntimeException e){

        //異常日誌入庫


        logger.info("=================runtime exception===============");
        e.printStackTrace();
        return new JsonResult(StatusUtil.ERROR,"小服正在努力嘗試重連,請稍後在試......");
    }
    
    @ExceptionHandler(SaveRuntimeException.class)
    @ResponseBody
    public JsonResult handleException(SaveRuntimeException e){

         //異常日誌入庫


        logger.info("=================Save exception===============");
        e.printStackTrace();
        return new JsonResult(StatusUtil.ERROR,"新增資料失敗,請稍後在試......");
    }
    
    @ExceptionHandler(UpdateRuntimeException.class)
    @ResponseBody
    public JsonResult handleException(UpdateRuntimeException e){

        //異常日誌入庫


        logger.info("=================Update exception===============");
        e.printStackTrace();
        return new JsonResult(StatusUtil.ERROR,"更新資料失敗,請稍後在試......");
    }
}

需注意的是 SaveRuntimeException 和 UpdateRuntimeException是我自定義的異常處理類,基於RuntimeException處理的,

這個程式碼示例寫的非常淺顯易懂，但是需要注意的是：基於@ControllerAdvice註解的全域性異常統一處理只能針對於Controller層的異常，意思是隻能捕獲到Controller層的異常，在service層或者其他層面的異常不能捕獲,當然也可以通過自定義來實現,那我們就來說說第二種方式.

2、基於Springboot自身的全域性異常統一處理，主要是實現ErrorController介面或者繼承AbstractErrorController抽象類或者繼承BasicErrorController類, 以下是網上一位博主給出的示例程式碼

@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: leon
 * @Description: Springboot全域性異常統一處理
 * @Date: 2018/9/20
 * @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也可以實現異常的全域性處理，自己相應的做了測試發現也滿足要求，相應的程式碼如下：


@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異常資訊統一處理

前景描述: 最近在做專案時發現後臺程式的異常拋到前端頁面上報出一大段sql異常,因此考慮需要對異常進行全域性統一處理，並將日誌進行分類入庫以及記錄介面請求的日誌資訊等，記錄日誌資訊在之前的文章已經有記錄了這裡不再重複有需要的請移步到Spring Boot 使用AOP切面實現後臺日誌管理模組。

Javaweb異常提示資訊統一處理

Java異常封裝（自己定義錯誤碼和描述，附原始碼） 2016年01月29日 22:30:54 小寶鴿 閱讀數：23262 標籤： java異常 更多 個人分類： Java基礎

javaweb異常提示資訊統一處理（使用springmvc，附原始碼）

一、前言 後臺出現異常如何友好而又高效地回顯到前端呢？直接將一堆的錯誤資訊拋給使用者介面，顯然不合適。 先不考慮程式碼實現，我們希望是這樣的： （1）如果是頁面跳轉的請求，出現異常了，我們希望跳轉到一個異常顯示頁面，如下： 當然，這裡的介面不夠美觀，

SpringBoot項目統一處理異常

param 統一 信息 hash int aop slf4 message class package com.chitic.module.core.aop; import com.chitic.module.core.constant.ChiticCoreCon

Web層框架對網站中所有異常的統一處理

配置文件 數據安全 攔截器 網站 如何 一個網站的異常信息作為專業的人士，是不會輕易暴露給用戶的，因為那樣狠不安全，顯得你漏是一回事，只要還是考慮到網站的數據安全問題，下面給大家分享一下一些常見的web層框架是如何處理統一的異常。　　　之前都是在Struts2的配置文件中配置攔截器

Springboot中AOP統一處理請求日誌

alt image pri sys -1 boot 技術分享 ring com 完善上面的代碼： 現在把輸出信息由先前的system.out.println()方式改為由日誌輸出（日誌輸出的信息更全面） Springboot中AOP統一處理請求日誌

@ControllerAdvice 攔截異常並統一處理

內容 ref boot art spring ont csdn oot control Spring Boot 系列（八）@ControllerAdvice 攔截異常並統一處理https://www.cnblogs.com/magicalSam/p/7198420.html

SpringBoot使用AOP統一處理Web請求日誌新增MDC

AOP是Spring框架中的一個重要內容，它通過對既有程式定義一個切入點，然後在其前後切入不同的執行內容，基於AOP不會破壞原來程式邏輯，因此它可以很好的對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。之前看到公

android系統異常資訊捕獲處理

1.在Android中有的未知的Bug可能在測試中沒有及時發現，導致使用者在使用時出現程式奔潰，出現使用者體驗不好，而我們又不清楚的情況。android提供了Thread.UncaughtExceptionHandler介面，可以通過實現這個介面，在全域性中捕獲異常並處理，

spring mvc 異常（runtime異常、ajax異常）統一處理與範例

SpringMVC 提供的異常處理主要有兩種方式，一種是直接實現自己的HandlerExceptionResolver，另一種是使用註解的方式實現一個專門用於處理異常的Controller——ExceptionHandler。前者當發生異常時，頁面會跳到指定的錯誤頁面

Spring Boot 系列（八）@ControllerAdvice 攔截異常並統一處理

在spring 3.2中，新增了@ControllerAdvice 註解，可以用於定義@ExceptionHandler、@InitBinder、@ModelAttribute，並應用到所有@RequestMapping中。參考：@ControllerAdvic

Spring 對Controller異常的統一處理

runtime object 處理 java ota body ava server per 對於Controller的異常處理，分為兩種，一種是對已知的異常處理，一種是未知的異常處理 1、定義自定義異常類 /** * @author hzc *

springboot(3)——整合freemarker模板、AOP統一處理、全域性異常處理

《三》、整合freemarker模板、AOP統一處理、全域性異常處理 一、整合freemarker模板引擎 1、引入freemarker依賴 <dependency> <groupId>org.springframe

springboot錯誤資訊返回與自定義異常處理

在很多系統中，我們可能在執行時出現各種異常，有系統異常，程式碼異常，自定義的異常。這時候我們就要把這些錯誤異常資訊返回去給客戶端檢視才知道是哪裡出問題。這裡我們就說說spring boot的異常處理。   springboot錯誤資訊返回: 實際上，如果我們訪問一個url,不同

【SpringBoot】Http請求統一異常(返回資料)處理與單元測試

對返回資料格式的統一 首先規定一下錯誤的輸出格式: { "code": 1, "msg": "提示", "data": null } data是一個物件 首先定義一個http請求返回的類 package cn.

SpringBoot異常統一處理機制

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

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

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

學習springBoot 進階統一異常處理（六）

在實際開發當中我們經常會遇到BUG，所以都會封裝一個異常返回類來使用，提示我們到底是那一步出了問題，方便於我們追蹤問題並且解決問題， 以下舉個新增女孩物件為例子，當新增的女孩物件年齡小於10歲時我們提示該女孩在上小學，大於10歲且小於16歲提示可能在上初中，通過例子說明我們如何對異常統一處理並返

springboot統一處理異常方法

@ControllerAdvice註解將作用在所有註解了@RequestMapping的控制器的方法上 @ExceptionHandler：用於全域性處理控制器裡的異常 所以在寫專案的時候service層和mapper層都使用拋異常的方式，把異常都拋到controller層，然後來統一處理，這個類其

【SpringBoot專題】統一異常處理和統一資料返回

前言 在實際開發中，我們希望對介面結果的返回，進行一次統一的封裝，即便介面發生異常。比如，我們可以這樣設計介面的返回： 統一資料返回 我們希望有一種統一的方式來處理異常，並且有一種統一的方式來對介面結果進行返回，並且儘可能少編寫程式碼，儘可能和業務邏輯