全局异常处理

package com.*.*.basecloud.security.uas.sts.exception;

import com.*.*.basecloud.security.uas.sts.sdk.common.constant.ResponseEnum;
import com.*.*.basecloud.security.uas.sts.sdk.exception.BaseResp;
import com.*.*.basecloud.security.uas.sts.sdk.exception.EncDecException;
import com.*.*.basecloud.security.uas.sts.sdk.exception.JsonConvertException;
import com.*.*.basecloud.security.uas.sts.sdk.exception.ParamException;
import com.*.*.basecloud.security.uas.sts.sdk.exception.RegistException;
import com.*.*.basecloud.security.uas.sts.sdk.exception.ResponseFactory;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.Set;
import java.util.function.Consumer;

import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.ValidationException;

/**
 * 全局异常处理
 *
 * @author 
 * @since 
 */
@RestControllerAdvice(basePackages = "com.*.*.basecloud.security.uas.sts.controller")
public class GlobalExceptionHandler {
    private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    private static Consumer<BaseResp> consumer;

    private static boolean isHasConsumer = false;

    /**
     * 设置响应结果消费
     *
     * @param consume 响应结果消费方法
     */
    public static void setConsumer(Consumer<BaseResp> consume) {
        if (consume != null) {
            consumer = consume;
            isHasConsumer = true;
        } else {
            isHasConsumer = false;
        }
    }

    /**
     * 参数校验异常处理
     *
     * @param exception 参数校验异常
     * @return 请求响应结果
     */
    @ExceptionHandler(ValidationException.class)
    @ResponseBody
    public BaseResp handle(ValidationException exception) {
        if (exception instanceof ConstraintViolationException) {
            ConstraintViolationException exs = (ConstraintViolationException) exception;
            Set<ConstraintViolation<?>> violations = exs.getConstraintViolations();
            for (ConstraintViolation<?> item : violations) {
                // 打印验证不通过的信息
                log.error(item.getMessage());
            }
        }
        return getResp(ResponseEnum.ERROR_3);
    }

    /**
     * Exception异常处理
     *
     * @param ex 异常
     * @return 请求响应结果
     */
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public BaseResp handleException(Exception ex) {
        log.error("error info: {}, {}", ex.getMessage(), ex);
        return getServerError();
    }

    /**
     * http参数读取异常处理
     *
     * @param ex 异常
     * @return 请求响应结果
     */
    @ExceptionHandler(HttpMessageNotReadableException.class)
    @ResponseBody
    public BaseResp handleHttpMessageNotReadableException(HttpMessageNotReadableException ex) {
        log.error("error info: {}", ex.getMessage());
        return getResp(ResponseEnum.ERROR_3);
    }

    /**
     * 参数校验异常处理
     *
     * @param ex 参数校验异常
     * @return 请求响应结果
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public BaseResp handleMethodArgumentNotValid(MethodArgumentNotValidException ex) {
        BindingResult bindingResult = ex.getBindingResult();
        StringBuilder stringBuilder = new StringBuilder();
        for (FieldError error : bindingResult.getFieldErrors()) {
            stringBuilder.append("field:")
                .append(error.getField())
                .append(" error:")
                .append(error.getDefaultMessage())
                .append(";");
        }
        log.error("parameterError {}", stringBuilder.toString());
        return getResp(ResponseEnum.ERROR_3);
    }

    /**
     * 参数校验异常处理
     *
     * @param ex 参数校验异常
     * @return 请求响应结果
     */
    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseBody
    public BaseResp handleConstraintViolationException(ConstraintViolationException ex) {
        log.error(ex.getMessage());
        return getResp(ResponseEnum.ERROR_3);
    }

    /**
     * 参数手动校验异常处理
     *
     * @param exp 参数校验异常
     * @return 请求响应结果
     */
    @ExceptionHandler(ParamException.class)
    @ResponseBody
    public BaseResp handleParamException(ParamException exp) {
        log.error(exp.getMessage());
        return getResp(ResponseEnum.ERROR_3);
    }

    /**
     * 加解密异常处理
     *
     * @param ex 加解密异常
     * @return 请求响应结果
     */
    @ExceptionHandler(EncDecException.class)
    @ResponseBody
    public BaseResp handleEncDecException(EncDecException ex) {
        log.error("加解密操作异常：{}", ex.getMessage());
        return getServerError();
    }

    /**
     * 业务异常2处理
     *
     * @param exp 业务异常
     * @return 请求响应结果
     */
    @ExceptionHandler(RegistException.class)
    @ResponseBody
    public BaseResp handleConstraintViolationException(RegistException exp) {
        log.error(exp.getResponseEnum().getEnMessage());
        return getResp(exp.getResponseEnum());
    }

    /**
     * Json解析异常处理
     *
     * @param ex Json解析异常
     * @return 请求响应结果
     */
    @ExceptionHandler(JsonConvertException.class)
    @ResponseBody
    public BaseResp handleJsonConvertException(JsonConvertException ex) {
        log.error("Json解析异常：{}", ex.getMessage());
        return getServerError();
    }

    private BaseResp getServerError() {
        return getResp(ResponseEnum.ERROR_5);
    }

    private BaseResp getResp(ResponseEnum codeEnum) {
        BaseResp resp = ResponseFactory.getResponse(codeEnum);
        if (isHasConsumer) {
            consumer.accept(resp);
        }
        return resp;
    }
}

--------------------------------------------------------------------------------------------------------------------------------

package com.*.*.basecloud.security.uas.sts.sdk.exception;

import com.*.*.basecloud.security.uas.sts.sdk.common.constant.ResponseEnum;

/**
 * 响应对象工厂
 *
 * @Author: 
 * @since 2021-10-20
 */
public class ResponseFactory {
    private static final BaseResp SUCCEED_RESP = getResponse(ResponseEnum.ERROR_0);

    private ResponseFactory() {
    }

    public static BaseResp getResponse() {
        return SUCCEED_RESP;
    }

    /**
     * 获取响应对象
     *
     * @param error 响应错误码枚举
     * @return 请求响应对象
     */
    public static BaseResp getResponse(ResponseEnum error) {
        return new BaseResp(error.getCnMessage(), error.getEnMessage(), error.getCode());
    }

    /**
     * 获取响应对象
     *
     * @param error 错误码
     * @param msg 错误信息
     * @return 请求响应对象
     */
    public static BaseResp getResponse(ResponseEnum error, String msg) {
        return new BaseResp(msg, error.getCode());
    }
}
--------------------------------------------------------------------------------------------------------------------------------

package com.*.*.basecloud.security.uas.sts.sdk.exception;

public class BaseResp {

    private String errCnMessage;

    private String errEnMessage;

    private int errCode; // 错误码 0-成功 其他-异常

    public BaseResp(String errCnMessage, String errEnMessage, int errCode) {
        this.errCnMessage = errCnMessage;
        this.errEnMessage = errEnMessage;
        this.errCode = errCode;
    }

    public BaseResp(String errCnMessage, int errCode) {
        this.errCnMessage = errCnMessage;
        this.errCode = errCode;
    }

    public BaseResp() {
    }

    public String getErrCnMessage() {
        return errCnMessage;
    }

    public void setErrCnMessage(String errCnMessage) {
        this.errCnMessage = errCnMessage;
    }

    public String getErrEnMessage() {
        return errEnMessage;
    }

    public void setErrEnMessage(String errEnMessage) {
        this.errEnMessage = errEnMessage;
    }

    public int getErrCode() {
        return errCode;
    }

    public void setErrCode(int errCode) {
        this.errCode = errCode;
    }
}