fw-sample/fw-sample-service/src/main/java/com/mokasz/sample/common/aspect/ExceptionControllerAdvice.java

package com.mokasz.sample.common.aspect;

import cn.hutool.core.exceptions.ExceptionUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.mokasz.sample.common.context.ApiContext;
import com.mokasz.sample.common.decorator.Slf4jDecorator;
import com.mokasz.sample.common.exception.ApiArgumentBizException;
import com.mokasz.sample.common.exception.ApiBizException;
import com.mokasz.sample.common.exception.AuditBizException;
import com.mokasz.sample.common.exception.CommonBizException;
import com.mokasz.sample.common.model.ApiResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.ConstraintViolationException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestControllerAdvice(basePackages = {"com.mokasz.sample.api.controller", "com.mokasz.sample.admin.controller"})
@Slf4j
public class ExceptionControllerAdvice {

    @ExceptionHandler
    public ApiResponse<?> handleException(Exception ex) {
        log.error("[ExceptionControllerAdvice]请求处理Exception异常,ex:{},traceId:{}", ExceptionUtil.stacktraceToString(ex), ApiContext.getTraceId());
        return ApiResponse.fail("系统异常");
    }

    @ExceptionHandler({AuditBizException.class})
    public ApiResponse<?> handleAuditBizException(AuditBizException ex) {
        log.error("[ExceptionControllerAdvice]请求处理AuditBizException异常,msg:{},code:{},ex:{}", ex.getMsg(), ex.getCode(), ExceptionUtil.stacktraceToString(ex));
        return ApiResponse.fail(ex.getMsg());
    }

    @ExceptionHandler({CommonBizException.class})
    public ApiResponse<?> handleCommonBizException(CommonBizException ex) {
        log.error("[ExceptionControllerAdvice]请求处理CommonBizException异常,msg:{},code:{},ex:{}", ex.getMsg(), ex.getCode(), ExceptionUtil.stacktraceToString(ex));
        return ApiResponse.fail(ex.getMsg());
    }

    @ExceptionHandler({ApiBizException.class})
    public ApiResponse<?> handleApiBizException(ApiBizException ex) {
        Slf4jDecorator logger = Slf4jDecorator.instance(log);
        logger.log(ex.getLevel(), "[ExceptionControllerAdvice]请求处理ApiBizException异常,msg:{},code:{},ex:{}", ex.getMsg(), ex.getCode(), ExceptionUtil.stacktraceToString(ex));
        return ApiResponse.fail(ex.getMsg());
    }

    @ExceptionHandler({ApiArgumentBizException.class})
    public ApiResponse<?> handleApiArgumentBizExistException(ApiArgumentBizException ex) {
        log.error("[ExceptionControllerAdvice]请求处理ApiArgumentBizException异常,msg:{},code:{},ex:{}", ex.getMsg(), ex.getCode(), ExceptionUtil.stacktraceToString(ex));
        return ApiResponse.fail(String.format("ApiArgumentBizException：%s", ex.getMsg()));
    }

    @ExceptionHandler({MethodArgumentNotValidException.class})
    public ApiResponse<?> handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
        BindingResult bindResult = ex.getBindingResult();
        List<ObjectError> errors = bindResult.getAllErrors();
        Map<String, Object> msgMap = new HashMap<>();

        errors.forEach(error -> {
            if (error instanceof FieldError) {
                FieldError fieldError = (FieldError) error;
                msgMap.put(StrUtil.toUnderlineCase(fieldError.getField()), fieldError.getDefaultMessage());
            } else {
                msgMap.put(StrUtil.toUnderlineCase(error.getObjectName()), error.getDefaultMessage());
            }
        });

        log.error("[ExceptionControllerAdvice]请求处理MethodArgumentNotValidException异常,msg:{},ex:{}", JSON.toJSONString(msgMap), ExceptionUtil.stacktraceToString(ex));
        return ApiResponse.fail(String.format("MethodArgumentNotValidException：%s", JSON.toJSONString(msgMap)));
    }

    @ExceptionHandler(ConstraintViolationException.class)
    public ApiResponse<?> handleConstraintViolationException(ConstraintViolationException ex, HttpServletRequest request, HttpServletResponse response) {
        Map<String, Object> msgMap = new HashMap<>();
        ex.getConstraintViolations().forEach(error -> {
            String message = error.getMessage();
            String path = error.getPropertyPath().toString();
            msgMap.put(StrUtil.toUnderlineCase(path), message);
        });
        log.error("[ExceptionControllerAdvice]请求处理ConstraintViolationException异常,msg:{},ex:{}", JSON.toJSONString(msgMap), ExceptionUtil.stacktraceToString(ex));
        return ApiResponse.fail(String.format("ConstraintViolationException：%s", JSON.toJSONString(msgMap)));
    }

}