你這代碼寫得真醜，滿屏的try-catch，全局異常處理不會嗎？

時間  2021-03-26
標籤 html 前端 spring 數據庫 json 服務器 網絡 數據結構 mybatis mvc 欄目 HTML 简体版
原文   原文鏈接

背景html

軟件開發過程當中，不可避免的是須要處理各類異常，就我本身來講，至少有一半以上的時間都是在處理各類異常狀況，因此代碼中就會出現大量的try {…} catch {…} finally {…} 代碼塊，不只有大量的冗餘代碼，並且還影響代碼的可讀性。比較下面兩張圖，看看您如今編寫的代碼屬於哪種風格？而後哪一種編碼風格您更喜歡？
在這裏插入圖片描述
醜陋的 try catch 代碼塊
在這裏插入圖片描述
優雅的Controller前端

上面的示例，還只是在Controller層，若是是在Service層，可能會有更多的try catch代碼塊。這將會嚴重影響代碼的可讀性、「美觀性」。spring

因此若是是個人話，我確定偏向於第二種，我能夠把更多的精力放在業務代碼的開發，同時代碼也會變得更加簡潔。數據庫

既然業務代碼不顯式地對異常進行捕獲、處理，而異常確定仍是處理的，否則系統豈不是動不動就崩潰了，因此必須得有其餘地方捕獲並處理這些異常。json

那麼問題來了，如何優雅的處理各類異常？服務器

什麼是統一異常處理網絡

Spring在3.2版本增長了一個註解@ControllerAdvice，能夠與@ExceptionHandler、@InitBinder、@ModelAttribute 等註解註解配套使用，對於這幾個註解的做用，這裏不作過多贅述，如有不瞭解的，能夠參考Spring3.2新註解@ControllerAdvice，先大概有個瞭解。數據結構

不過跟異常處理相關的只有註解@ExceptionHandler，從字面上看，就是 異常處理器 的意思，其實際做用也是：若在某個Controller類定義一個異常處理方法，並在方法上添加該註解，那麼當出現指定的異常時，會執行該處理異常的方法，其可使用springmvc提供的數據綁定，好比注入HttpServletRequest等，還能夠接受一個當前拋出的Throwable對象。mybatis

可是，這樣一來，就必須在每個Controller類都定義一套這樣的異常處理方法，由於異常能夠是各類各樣。這樣一來，就會形成大量的冗餘代碼，並且若須要新增一種異常的處理邏輯，就必須修改全部Controller類了，很不優雅。mvc

固然你可能會說，那就定義個相似BaseController的基類，這樣總行了吧。

這種作法雖然沒錯，但仍不盡善盡美，由於這樣的代碼有必定的侵入性和耦合性。簡簡單單的Controller，我爲啥非得繼承這樣一個類呢，萬一已經繼承其餘基類了呢。你們都知道Java只能繼承一個類。

那有沒有一種方案，既不須要跟Controller耦合，也能夠將定義的 異常處理器 應用到全部控制器呢？因此註解@ControllerAdvice出現了，簡單的說，該註解能夠把異常處理器應用到全部控制器，而不是單個控制器。藉助該註解，咱們能夠實現：在獨立的某個地方，好比單獨一個類，定義一套對各類異常的處理機制，而後在類的簽名加上註解@ControllerAdvice，統一對 不一樣階段的、不一樣異常 進行處理。這就是統一異常處理的原理。

注意到上面對異常按階段進行分類，大致能夠分紅：進入Controller前的異常 和Service 層異常，具體能夠參考下圖：
在這裏插入圖片描述
不一樣階段的異常

目標

消滅95%以上的 try catch 代碼塊，以優雅的 Assert(斷言) 方式來校驗業務的異常狀況，只關注業務邏輯，而不用花費大量精力寫冗餘的 try catch 代碼塊。

統一異常處理實戰

在定義統一異常處理類以前，先來介紹一下如何優雅的斷定異常狀況並拋異常。

用 Assert(斷言) 替換 throw exception

想必 Assert(斷言) 你們都很熟悉，好比 Spring 家族的org.springframework.util.Assert，在咱們寫測試用例的時候常常會用到，使用斷言能讓咱們編碼的時候有一種非通常絲滑的感受，好比：

@Test
    public void test1() {
        ...
        User user = userDao.selectById(userId);
        Assert.notNull(user, "用戶不存在.");
        ...
    }

    @Test
    public void test2() {
        // 另外一種寫法
        User user = userDao.selectById(userId);
        if (user == null) {
            throw new IllegalArgumentException("用戶不存在.");
        }
    }

有沒有感受第一種斷定非空的寫法很優雅，第二種寫法則是相對醜陋的 if {…} 代碼塊。那麼神奇的 Assert.notNull() 背後到底作了什麼呢？下面是 Assert 的部分源碼：

public abstract class Assert {
    public Assert() {
    }

    public static void notNull(@Nullable Object object, String message) {
        if (object == null) {
            throw new IllegalArgumentException(message);
        }
    }
}

能夠看到，Assert 其實就是幫咱們把 if {…} 封裝了一下，是否是很神奇。雖然很簡單，但不能否認的是編碼體驗至少提高了一個檔次。那麼咱們能不能模仿org.springframework.util.Assert，也寫一個斷言類，不過斷言失敗後拋出的異常不是IllegalArgumentException 這些內置異常，而是咱們本身定義的異常。下面讓咱們來嘗試一下。

Assert

public interface Assert {
    /**
     * 建立異常
     * @param args
     * @return
     */
    BaseException newException(Object... args);

    /**
     * 建立異常
     * @param t
     * @param args
     * @return
     */
    BaseException newException(Throwable t, Object... args);

    /**
     * <p>斷言對象<code>obj</code>非空。若是對象<code>obj</code>爲空，則拋出異常
     *
     * @param obj 待判斷對象
     */
    default void assertNotNull(Object obj) {
        if (obj == null) {
            throw newException(obj);
        }
    }

    /**
     * <p>斷言對象<code>obj</code>非空。若是對象<code>obj</code>爲空，則拋出異常
     * <p>異常信息<code>message</code>支持傳遞參數方式，避免在判斷以前進行字符串拼接操做
     *
     * @param obj 待判斷對象
     * @param args message佔位符對應的參數列表
     */
    default void assertNotNull(Object obj, Object... args) {
        if (obj == null) {
            throw newException(args);
        }
    }
}

上面的Assert斷言方法是使用接口的默認方法定義的，而後有沒有發現當斷言失敗後，拋出的異常不是具體的某個異常，而是交由2個newException接口方法提供。由於業務邏輯中出現的異常基本都是對應特定的場景，好比根據用戶id獲取用戶信息，查詢結果爲null，此時拋出的異常可能爲UserNotFoundException，而且有特定的異常碼（好比7001）和異常信息「用戶不存在」。因此具體拋出什麼異常，有Assert的實現類決定。

看到這裏，您可能會有這樣的疑問，按照上面的說法，那豈不是有多少異常狀況，就得有定義等量的斷言類和異常類，這顯然是反人類的，這也沒想象中高明嘛。別急，且聽我細細道來。

善解人意的Enum

自定義異常BaseException有2個屬性，即code、message，這樣一對屬性，有沒有想到什麼類通常也會定義這2個屬性？沒錯，就是枚舉類。且看我如何將 Enum 和 Assert 結合起來，相信我必定會讓你眼前一亮。以下：

public interface IResponseEnum {
    int getCode();
    String getMessage();
}
/**
 * <p>業務異常</p>
 * <p>業務處理時，出現異常，能夠拋出該異常</p>
 */
public class BusinessException extends  BaseException {

    private static final long serialVersionUID = 1L;

    public BusinessException(IResponseEnum responseEnum, Object[] args, String message) {
        super(responseEnum, args, message);
    }

    public BusinessException(IResponseEnum responseEnum, Object[] args, String message, Throwable cause) {
        super(responseEnum, args, message, cause);
    }
}
public interface BusinessExceptionAssert extends IResponseEnum, Assert {

    @Override
    default BaseException newException(Object... args) {
        String msg = MessageFormat.format(this.getMessage(), args);

        return new BusinessException(this, args, msg);
    }

    @Override
    default BaseException newException(Throwable t, Object... args) {
        String msg = MessageFormat.format(this.getMessage(), args);

        return new BusinessException(this, args, msg, t);
    }

}
@Getter
@AllArgsConstructor
public enum ResponseEnum implements BusinessExceptionAssert {

    /**
     * Bad licence type
     */
    BAD_LICENCE_TYPE(7001, "Bad licence type."),
    /**
     * Licence not found
     */
    LICENCE_NOT_FOUND(7002, "Licence not found.")
    ;

    /**
     * 返回碼
     */
    private int code;
    /**
     * 返回消息
     */
    private String message;
}

看到這裏，有沒有眼前一亮的感受，代碼示例中定義了兩個枚舉實例：

BAD_LICENCE_TYPE、LICENCE_NOT_FOUND，分別對應了BadLicenceTypeException、LicenceNotFoundException兩種異常。之後每增長一種異常狀況，只需增長一個枚舉實例便可，不再用每一種異常都定義一個異常類了。而後再來看下如何使用，假設LicenceService有校驗Licence是否存在的方法，以下：

/**
     * 校驗{@link Licence}存在
     * @param licence
     */
    private void checkNotNull(Licence licence) {
        ResponseEnum.LICENCE_NOT_FOUND.assertNotNull(licence);
    }

若不使用斷言，代碼可能以下：

   private void checkNotNull(Licence licence) {
        if (licence == null) {
            throw new LicenceNotFoundException();
            // 或者這樣
            throw new BusinessException(7001, "Bad licence type.");
        }
    }

使用枚舉類結合(繼承)Assert，只需根據特定的異常狀況定義不一樣的枚舉實例，如上面的BAD_LICENCE_TYPE、LICENCE_NOT_FOUND，就可以針對不一樣狀況拋出特定的異常（這裏指攜帶特定的異常碼和異常消息），這樣既不用定義大量的異常類，同時還具有了斷言的良好可讀性，固然這種方案的好處遠不止這些，請繼續閱讀後文，慢慢體會。

注：上面舉的例子是針對特定的業務，而有部分異常狀況是通用的，好比：服務器繁忙、網絡異常、服務器異常、參數校驗異常、404等，因此有CommonResponseEnum、ArgumentResponseEnum、ServletResponseEnum，其中ServletResponseEnum 會在後文詳細說明。

定義統一異常處理器類

@Slf4j
@Component
@ControllerAdvice
@ConditionalOnWebApplication
@ConditionalOnMissingBean(UnifiedExceptionHandler.class)
public class UnifiedExceptionHandler {
    /**
     * 生產環境
     */
    private final static String ENV_PROD = "prod"; 

    @Autowired
    private UnifiedMessageSource unifiedMessageSource;

    /**
     * 當前環境
     */
    @Value("${spring.profiles.active}")
    private String profile;
    
    /**
     * 獲取國際化消息
     *
     * @param e 異常
     * @return
     */
    public String getMessage(BaseException e) {
        String code = "response." + e.getResponseEnum().toString();
        String message = unifiedMessageSource.getMessage(code, e.getArgs());

        if (message == null || message.isEmpty()) {
            return e.getMessage();
        }

        return message;
    }

    /**
     * 業務異常
     *
     * @param e 異常
     * @return 異常結果
     */
    @ExceptionHandler(value = BusinessException.class)
    @ResponseBody
    public ErrorResponse handleBusinessException(BaseException e) {
        log.error(e.getMessage(), e);

        return new ErrorResponse(e.getResponseEnum().getCode(), getMessage(e));
    }

    /**
     * 自定義異常
     *
     * @param e 異常
     * @return 異常結果
     */
    @ExceptionHandler(value = BaseException.class)
    @ResponseBody
    public ErrorResponse handleBaseException(BaseException e) {
        log.error(e.getMessage(), e);

        return new ErrorResponse(e.getResponseEnum().getCode(), getMessage(e));
    }

    /**
     * Controller上一層相關異常
     *
     * @param e 異常
     * @return 異常結果
     */
    @ExceptionHandler({
            NoHandlerFoundException.class,
            HttpRequestMethodNotSupportedException.class,
            HttpMediaTypeNotSupportedException.class,
            MissingPathVariableException.class,
            MissingServletRequestParameterException.class,
            TypeMismatchException.class,
            HttpMessageNotReadableException.class, 
            HttpMessageNotWritableException.class,
            // BindException.class,
            // MethodArgumentNotValidException.class
            HttpMediaTypeNotAcceptableException.class,
            ServletRequestBindingException.class,
            ConversionNotSupportedException.class,
            MissingServletRequestPartException.class,
            AsyncRequestTimeoutException.class
    })
    @ResponseBody
    public ErrorResponse handleServletException(Exception e) {
        log.error(e.getMessage(), e);
        int code = CommonResponseEnum.SERVER_ERROR.getCode();
        try {
            ServletResponseEnum servletExceptionEnum = ServletResponseEnum.valueOf(e.getClass().getSimpleName());
            code = servletExceptionEnum.getCode();
        } catch (IllegalArgumentException e1) {
            log.error("class [{}] not defined in enum {}", e.getClass().getName(), ServletResponseEnum.class.getName());
        }

        if (ENV_PROD.equals(profile)) {
            // 當爲生產環境, 不適合把具體的異常信息展現給用戶, 好比404.
            code = CommonResponseEnum.SERVER_ERROR.getCode();
            BaseException baseException = new BaseException(CommonResponseEnum.SERVER_ERROR);
            String message = getMessage(baseException);
            return new ErrorResponse(code, message);
        }

        return new ErrorResponse(code, e.getMessage());
    }


    /**
     * 參數綁定異常
     *
     * @param e 異常
     * @return 異常結果
     */
    @ExceptionHandler(value = BindException.class)
    @ResponseBody
    public ErrorResponse handleBindException(BindException e) {
        log.error("參數綁定校驗異常", e);

        return wrapperBindingResult(e.getBindingResult());
    }

    /**
     * 參數校驗異常，將校驗失敗的全部異常組合成一條錯誤信息
     *
     * @param e 異常
     * @return 異常結果
     */
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    @ResponseBody
    public ErrorResponse handleValidException(MethodArgumentNotValidException e) {
        log.error("參數綁定校驗異常", e);

        return wrapperBindingResult(e.getBindingResult());
    }

    /**
     * 包裝綁定異常結果
     *
     * @param bindingResult 綁定結果
     * @return 異常結果
     */
    private ErrorResponse wrapperBindingResult(BindingResult bindingResult) {
        StringBuilder msg = new StringBuilder();

        for (ObjectError error : bindingResult.getAllErrors()) {
            msg.append(", ");
            if (error instanceof FieldError) {
                msg.append(((FieldError) error).getField()).append(": ");
            }
            msg.append(error.getDefaultMessage() == null ? "" : error.getDefaultMessage());

        }

        return new ErrorResponse(ArgumentResponseEnum.VALID_ERROR.getCode(), msg.substring(2));
    }

    /**
     * 未定義異常
     *
     * @param e 異常
     * @return 異常結果
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public ErrorResponse handleException(Exception e) {
        log.error(e.getMessage(), e);

        if (ENV_PROD.equals(profile)) {
            // 當爲生產環境, 不適合把具體的異常信息展現給用戶, 好比數據庫異常信息.
            int code = CommonResponseEnum.SERVER_ERROR.getCode();
            BaseException baseException = new BaseException(CommonResponseEnum.SERVER_ERROR);
            String message = getMessage(baseException);
            return new ErrorResponse(code, message);
        }

        return new ErrorResponse(CommonResponseEnum.SERVER_ERROR.getCode(), e.getMessage());
    }
    
}

能夠看到，上面將異常分紅幾類，實際上只有兩大類，一類是ServletException、ServiceException，還記得上文提到的 按階段分類 嗎，即對應 進入Controller前的異常 和 Service 層異常；而後 ServiceException 再分紅自定義異常、未知異常。對應關係以下：

  • 進入Controller前的異常: handleServletException、handleBindException、handleValidException
  • 自定義異常: handleBusinessException、handleBaseException
  • 未知異常: handleException

接下來分別對這幾種異常處理器作詳細說明。

異常處理器說明

handleServletException

一個http請求，在到達Controller前，會對該請求的請求信息與目標控制器信息作一系列校驗。這裏簡單說一下：

  • NoHandlerFoundException：首先根據請求Url查找有沒有對應的控制器，若沒有則會拋該異常，也就是你們很是熟悉的404異常；
  • HttpRequestMethodNotSupportedException：若匹配到了（匹配結果是一個列表，不一樣的是http方法不一樣，如：Get、Post等），則嘗試將請求的http方法與列表的控制器作匹配，若沒有對應http方法的控制器，則拋該異常；
  • HttpMediaTypeNotSupportedException：而後再對請求頭與控制器支持的作比較，好比content-type請求頭，若控制器的參數簽名包含註解@RequestBody，可是請求的content-type請求頭的值沒有包含application/json，那麼會拋該異常（固然，不止這種狀況會拋這個異常）；
  • MissingPathVariableException：未檢測到路徑參數。好比url爲：/licence/{licenceId}，參數簽名包含@PathVariable(「licenceId」)，當請求的url爲/licence，在沒有明肯定義url爲/licence的狀況下，會被斷定爲：缺乏路徑參數；
  • MissingServletRequestParameterException：缺乏請求參數。好比定義了參數@RequestParam(「licenceId」) String licenceId，但發起請求時，未攜帶該參數，則會拋該異常；
  • TypeMismatchException: 參數類型匹配失敗。好比：接收參數爲Long型，但傳入的值確是一個字符串，那麼將會出現類型轉換失敗的狀況，這時會拋該異常；
  • HttpMessageNotReadableException：與上面的HttpMediaTypeNotSupportedException舉的例子徹底相反，即請求頭攜帶了"content-type: application/json;charset=UTF-8"，但接收參數卻沒有添加註解@RequestBody，或者請求體攜帶的 json 串反序列化成 pojo 的過程當中失敗了，也會拋該異常；
  • HttpMessageNotWritableException：返回的 pojo 在序列化成 json 過程失敗了，那麼拋該異常；
  • HttpMediaTypeNotAcceptableException：未知；
  • ServletRequestBindingException：未知；
  • ConversionNotSupportedException：未知；
  • MissingServletRequestPartException：未知；
  • AsyncRequestTimeoutException：未知；

handleBindException

參數校驗異常，後文詳細說明。

handleValidException

參數校驗異常，後文詳細說明。

handleBusinessException、handleBaseException

處理自定義的業務異常，只是handleBaseException處理的是除了 BusinessException 意外的全部業務異常。就目前來看，這2個是能夠合併成一個的。

handleException

處理全部未知的異常，好比操做數據庫失敗的異常。

注：上面的handleServletException、handleException 這兩個處理器，返回的異常信息，不一樣環境返回的可能不同，覺得這些異常信息都是框架自帶的異常信息，通常都是英文的，不太好直接展現給用戶看，因此統一返回SERVER_ERROR表明的異常信息。

異於常人的404

上文提到，當請求沒有匹配到控制器的狀況下，會拋出NoHandlerFoundException異常，但其實默認狀況下不是這樣，默認狀況下會出現相似以下頁面：
在這裏插入圖片描述
Whitelabel Error Page

這個頁面是如何出現的呢？實際上，當出現404的時候，默認是不拋異常的，而是forward跳轉到/error控制器，spring也提供了默認的error控制器，以下：
在這裏插入圖片描述
BasicErrorController

那麼，如何讓404也拋出異常呢，只需在properties文件中加入以下配置便可：

spring.mvc.throw-exception-if-no-handler-found=true
spring.resources.add-mappings=false

如此，就能夠異常處理器中捕獲它了，而後前端只要捕獲到特定的狀態碼，當即跳轉到404頁面便可

捕獲404對應的異常

統一返回結果

在驗證統一異常處理器以前，順便說一下統一返回結果。說白了，實際上是統一一下返回結果的數據結構。code、message 是全部返回結果中必有的字段，而當須要返回數據時，則須要另外一個字段 data 來表示。

因此首先定義一個 BaseResponse 來做爲全部返回結果的基類；

而後定義一個通用返回結果類CommonResponse，繼承 BaseResponse，並且多了字段data；

爲了區分紅功和失敗返回結果，因而再定義一個 ErrorResponse；

最後還有一種常見的返回結果，即返回的數據帶有分頁信息，由於這種接口比較常見，因此有必要單獨定義一個返回結果類 QueryDataResponse，該類繼承自CommonResponse，只是把 data 字段的類型限制爲 QueryDdata，QueryDdata中定義了分頁信息相應的字段，即totalCount、pageNo、 pageSize、records。

其中比較經常使用的只有 CommonResponse 和 QueryDataResponse，可是名字又賊鬼死長，何不定義2個名字超簡單的類來替代呢？因而 R 和 QR 誕生了，之後返回結果的時候只需這樣寫：new R<>(data)、new QR<>(queryData)。

全部的返回結果類的定義這裏就不貼出來了

驗證統一異常處理

由於這一套統一異常處理能夠說是通用的，全部能夠設計成一個 common包，之後每個新項目/模塊只需引入該包便可。因此爲了驗證，須要新建一個項目，並引入該 common包。項目結構以下：

項目結構
之後只需這樣引入便可

引入common包

主要代碼

下面是用於驗證的主要源碼：

@Service
public class LicenceService extends ServiceImpl<LicenceMapper, Licence> {

    @Autowired
    private OrganizationClient organizationClient;

    /**
     * 查詢{@link Licence} 詳情
     * @param licenceId
     * @return
     */
    public LicenceDTO queryDetail(Long licenceId) {
        Licence licence = this.getById(licenceId);
        checkNotNull(licence);

        OrganizationDTO org = ClientUtil.execute(() -> organizationClient.getOrganization(licence.getOrganizationId()));
        return toLicenceDTO(licence, org);
    }

    /**
     * 分頁獲取
     * @param licenceParam 分頁查詢參數
     * @return
     */
    public QueryData<SimpleLicenceDTO> getLicences(LicenceParam licenceParam) {
        String licenceType = licenceParam.getLicenceType();
        LicenceTypeEnum licenceTypeEnum = LicenceTypeEnum.parseOfNullable(licenceType);
        // 斷言, 非空
        ResponseEnum.BAD_LICENCE_TYPE.assertNotNull(licenceTypeEnum);

        LambdaQueryWrapper<Licence> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Licence::getLicenceType, licenceType);
        IPage<Licence> page = this.page(new QueryPage<>(licenceParam), wrapper);
        return new QueryData<>(page, this::toSimpleLicenceDTO);
    }

    /**
     * 新增{@link Licence}
     * @param request 請求體
     * @return
     */
    @Transactional(rollbackFor = Throwable.class)
    public LicenceAddRespData addLicence(LicenceAddRequest request) {
        Licence licence = new Licence();
        licence.setOrganizationId(request.getOrganizationId());
        licence.setLicenceType(request.getLicenceType());
        licence.setProductName(request.getProductName());
        licence.setLicenceMax(request.getLicenceMax());
        licence.setLicenceAllocated(request.getLicenceAllocated());
        licence.setComment(request.getComment());
        this.save(licence);

        return new LicenceAddRespData(licence.getLicenceId());
    }

    /**
     * entity -> simple dto
     * @param licence {@link Licence} entity
     * @return {@link SimpleLicenceDTO}
     */
    private SimpleLicenceDTO toSimpleLicenceDTO(Licence licence) {
        // 省略
    }

    /**
     * entity -> dto
     * @param licence {@link Licence} entity
     * @param org {@link OrganizationDTO}
     * @return {@link LicenceDTO}
     */
    private LicenceDTO toLicenceDTO(Licence licence, OrganizationDTO org) {
        // 省略
    }

    /**
     * 校驗{@link Licence}存在
     * @param licence
     */
    private void checkNotNull(Licence licence) {
        ResponseEnum.LICENCE_NOT_FOUND.assertNotNull(licence);
    }

}

ps: 這裏使用的DAO框架是mybatis-plus。
啓動時，自動插入的數據爲：

-- licence
INSERT INTO licence (licence_id,  organization_id, licence_type, product_name, licence_max, licence_allocated)
VALUES (1, 1, 'user','CustomerPro', 100,5);
INSERT INTO licence (licence_id,  organization_id, licence_type, product_name, licence_max, licence_allocated)
VALUES (2, 1, 'user','suitability-plus', 200,189);
INSERT INTO licence (licence_id,  organization_id, licence_type, product_name, licence_max, licence_allocated)
VALUES (3, 2, 'user','HR-PowerSuite', 100,4);
INSERT INTO licence (licence_id,  organization_id, licence_type, product_name, licence_max, licence_allocated)
VALUES (4, 2, 'core-prod','WildCat Application Gateway', 16,16);

-- organizations
INSERT INTO organization (id, name, contact_name, contact_email, contact_phone)
VALUES (1, 'customer-crm-co', 'Mark Balster', 'mark.balster@custcrmco.com', '823-555-1212');
INSERT INTO organization (id, name, contact_name, contact_email, contact_phone)
VALUES (2, 'HR-PowerSuite', 'Doug Drewry','doug.drewry@hr.com', '920-555-1212');

開始驗證

捕獲自定義異常

獲取不存在的 licence 詳情：http://localhost:10000/licence/5。成功響應的請求：licenceId=1
在這裏插入圖片描述
校驗非空
在這裏插入圖片描述
捕獲 Licence not found 異常
在這裏插入圖片描述
Licence not found

2.根據不存在的 licence type 獲取 licence 列表：http://localhost:10000/licenc...。可選的 licence type 爲：user、core-prod 。
在這裏插入圖片描述
校驗非空
在這裏插入圖片描述
捕獲 Bad licence type 異常
在這裏插入圖片描述
Bad licence type

捕獲進入 Controller 前的異常

訪問不存在的接口：http://localhost:10000/licenc...
在這裏插入圖片描述
捕獲404異常

http 方法不支持：http://localhost:10000/licence
在這裏插入圖片描述
PostMapping
在這裏插入圖片描述
捕獲 Request method not supported 異常
在這裏插入圖片描述
Request method not supported

3 校驗異常1：http://localhost:10000/licenc...
在這裏插入圖片描述
getLicences
在這裏插入圖片描述
LicenceParam
在這裏插入圖片描述
捕獲參數綁定校驗異常
在這裏插入圖片描述
licence type cannot be empty

4.校驗異常2：post 請求，這裏使用postman模擬。
在這裏插入圖片描述
addLicence
在這裏插入圖片描述
LicenceAddRequest
在這裏插入圖片描述
請求url即結果
在這裏插入圖片描述
捕獲參數綁定校驗異常

注：由於參數綁定校驗異常的異常信息的獲取方式與其它異常不同，因此才把這2種狀況的異常從 進入 Controller 前的異常 單獨拆出來，下面是異常信息的收集邏輯：
在這裏插入圖片描述
異常信息的收集

捕獲未知異常

假設咱們如今隨便對 Licence 新增一個字段 test，但不修改數據庫表結構，而後訪問：http://localhost:10000/licence/1。
在這裏插入圖片描述
增長test字段
在這裏插入圖片描述
捕獲數據庫異常
在這裏插入圖片描述
Error querying database

小結

能夠看到，測試的異常都可以被捕獲，而後以 code、message 的形式返回。每個項目/模塊，在定義業務異常的時候，只需定義一個枚舉類，而後實現接口BusinessExceptionAssert，最後爲每一種業務異常定義對應的枚舉實例便可，而不用定義許多異常類。使用的時候也很方便，用法相似斷言。

擴展

在生產環境，若捕獲到 未知異常 或者 ServletException，由於都是一長串的異常信息，若直接展現給用戶看，顯得不夠專業，因而，咱們能夠這樣作：當檢測到當前環境是生產環境，那麼直接返回 「網絡異常」。
在這裏插入圖片描述
生產環境返回「網絡異常」

能夠經過如下方式修改當前環境：
在這裏插入圖片描述
修改當前環境爲生產環境

總結

使用 斷言 和 枚舉類 相結合的方式，再配合統一異常處理，基本大部分的異常都可以被捕獲。爲何說大部分異常，由於當引入 spring cloud security 後，還會有認證/受權異常，網關的服務降級異常、跨模塊調用異常、遠程調用第三方服務異常等，這些異常的捕獲方式與本文介紹的不太同樣，不過限於篇幅，這裏不作詳細說明，之後會有單獨的文章介紹。

另外，當須要考慮國際化的時候，捕獲異常後的異常信息通常不能直接返回，須要轉換成對應的語言，不過本文已考慮到了這個，獲取消息的時候已經作了國際化映射，邏輯以下：
在這裏插入圖片描述
獲取國際化消息

最後總結，全局異常屬於老生長談的話題，但願此次經過手機的項目對你們有點指導性的學習。你們根據實際狀況自行修改。

也能夠採用如下的jsonResult對象的方式進行處理，也貼出來代碼.

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 沒有登陸
     * @param request
     * @param response
     * @param e
     * @return
     */
    @ExceptionHandler(NoLoginException.class)
    public Object noLoginExceptionHandler(HttpServletRequest request,HttpServletResponse response,Exception e)
{
        log.error("[GlobalExceptionHandler][noLoginExceptionHandler] exception",e);
        JsonResult jsonResult = new JsonResult();
        jsonResult.setCode(JsonResultCode.NO_LOGIN);
        jsonResult.setMessage("用戶登陸失效或者登陸超時,請先登陸");
        return jsonResult;
    }

    /**
     *  業務異常
     * @param request
     * @param response
     * @param e
     * @return
     */
    @ExceptionHandler(ServiceException.class)
    public Object businessExceptionHandler(HttpServletRequest request,HttpServletResponse response,Exception e)
{
        log.error("[GlobalExceptionHandler][businessExceptionHandler] exception",e);
        JsonResult jsonResult = new JsonResult();
        jsonResult.setCode(JsonResultCode.FAILURE);
        jsonResult.setMessage("業務異常,請聯繫管理員");
        return jsonResult;
    }

    /**
     * 全局異常處理
     * @param request
     * @param response
     * @param e
     * @return
     */
    @ExceptionHandler(Exception.class)
    public Object exceptionHandler(HttpServletRequest request,HttpServletResponse response,Exception e)
{
        log.error("[GlobalExceptionHandler][exceptionHandler] exception",e);
        JsonResult jsonResult = new JsonResult();
        jsonResult.setCode(JsonResultCode.FAILURE);
        jsonResult.setMessage("系統錯誤,請聯繫管理員");
        return jsonResult;
    }
}

來源：https://www.cnblogs.com/juren...

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程