<dependency>
    <groupId>com.luamas.thinkbridge</groupId>
    <artifactId>error-spring-boot-starter</artifactId>
</dependency>

implementation("com.luamas.thinkbridge:error-spring-boot-starter")

package com.luamas.thinkbridge.common.base.exception;

/**
 * 基础错误类型,各个模块需要实现此接口,要求所有的字段名，以`public static final`修饰，如：<br/>
 * public static final BaseResultCode OK = new BaseResultCode(200, "base.OK", "OK");<br/>
 * public static final BaseResultCode UNAUTHORIZED = new BaseResultCode(401, "base.UNAUTHORIZED", "未授权: {0}");<br/>
 *
 * @author luamas
 */
public interface ErrorCode {
    int getValue();

    String getName();

    String getInfo();
}

annotationProcessor("com.luamas.thinkbridge:thinkbridge-common-auto-processor")
compileOnly("com.luamas.thinkbridge:thinkbridge-common-auto-processor")

package com.luamas.thinkbridge.integration.demo;

import com.luamas.thinkbridge.common.auto.processor.AutoErrorCode;
import com.luamas.thinkbridge.common.base.exception.ErrorCode;

/**
 * 错误码范围100000~200000
 *
 * @author luamas
 */
@AutoErrorCode
public class ResultCode implements ErrorCode {
    public static final ResultCode CAPTCHA_ERROR = new ResultCode(100109, "integrationDemo.CAPTCHA_ERROR", "info");
    public static final ResultCode USER_NOT_EXIST = new ResultCode(100105, "【{0}】原生描述", "info");
    public static final ResultCode ERROR_DETAILS = new ResultCode(100106, "多个错误", "info");

    public final int value;
    private final String name;
    private final String info;

    private ResultCode(int value, String name, String info) {
        this.value = value;
        this.name = name;
        this.info = info;
    }

    @Override
    public int getValue() {
        return value;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getInfo() {
        return info;
    }
}

package com.luamas.thinkbridge.integration.demo.errorprocess;

import com.luamas.thinkbridge.common.base.exception.BusinessException;
import com.luamas.thinkbridge.common.base.vo.ErrorDetail;
import com.luamas.thinkbridge.common.base.vo.ResponseVo;
import com.luamas.thinkbridge.integration.demo.ResultCode;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import lombok.Getter;
import lombok.Setter;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@Tag(name = "统一错误处理")
@RequestMapping("errorprocess")
public class ErrorProcessController {

    @GetMapping("test1")
    @ResponseBody
    @Parameter(name = "Accept-Language", description = "en或者zh_CN，默认使用浏览器自带的语言", in = ParameterIn.HEADER)
    @Operation(summary = "国际化错误信息")
    public ResponseVo<String> test1(@RequestParam(value = "userId", required = false) String userId) {
        throw BusinessException.of(ResultCode.CAPTCHA_ERROR, userId);
    }

    @GetMapping("test2")
    @ResponseBody
    @Parameter(name = "Accept-Language", description = "en或者zh_CN，默认使用浏览器自带的语言", in = ParameterIn.HEADER)
    @Operation(summary = "非国际化信息，全部统一返回中文信息，不建议")
    public ResponseVo<String> test2(@RequestParam(value = "userId", required = false) String userId) {
        throw BusinessException.of(ResultCode.USER_NOT_EXIST, userId);
    }

    @GetMapping("test3")
    @ResponseBody
    @Operation(summary = "未知异常，这里会触发一个告警")
    public ResponseVo<String> test3() {
        throw new RuntimeException("未捕获异常，会抛出一个默认值");
    }

    @PostMapping("test4")
    @ResponseBody
    @Operation(summary = "对象校验")
    public ResponseVo<String> test4(@Valid User user) {
        return ResponseVo.success();
    }

    @GetMapping("test5")
    @ResponseBody
    @Operation(summary = "自定义多错误异常")
    public ResponseVo<String> test5() {
        List<ErrorDetail> errorDetails = new ArrayList<>();
        errorDetails.add(ErrorDetail.of(1, "发生错误1"));
        errorDetails.add(ErrorDetail.of(2, "发生错误2"));
        errorDetails.add(ErrorDetail.of(3, "发生错误3"));
        throw BusinessException.ofDetails(ResultCode.ERROR_DETAILS, errorDetails);
    }


    @Getter
    @Setter
    static class User {
        @NotBlank
        private String username;
    }
}

package com.luamas.thinkbridge.integration.demo.errorprocess;

import com.luamas.thinkbridge.common.error.ErrorResponseHandler;
import com.luamas.thinkbridge.common.error.ErrorResult;
import com.luamas.thinkbridge.common.error.UnknownErrorResponseHandler;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Locale;

@Profile("errorprocess")
//@Component
@RequiredArgsConstructor
public class MyUnknownErrorResponseHandler implements UnknownErrorResponseHandler {
    private final ErrorResponseHandler<?> errorResponseHandler;
    @Override
    public ErrorResult<?> handle(Throwable throwable, HttpStatus status, Locale locale) {
        // 定义一个统一的异常码
        int code = 50000000;
        return errorResponseHandler.error("未知异常,debug可以打印此异常", null, code, status.value(), null, new HashMap<>(), locale);
    }
}

package com.luamas.thinkbridge.common.error;

import org.springframework.http.HttpStatus;

import java.util.Locale;

public interface ErrorExceptionHandler {
    int DEFAULT_ERROR_CODE = 1500;
    /
     * 是否支持
     *
     * @param exception
     * @return
     */
    boolean supports(Throwable exception);

    /
     * 进行处理
     *
     * @param exception
     * @param status
     * @return
     */
    ErrorResult<?> handle(Throwable exception, HttpStatus status, Locale locale);
}

package com.luamas.thinkbridge.common.error;

import com.luamas.thinkbridge.common.base.exception.ThinkBridgeException;
import com.luamas.thinkbridge.common.base.exception.TransmitException;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;

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

@RequiredArgsConstructor
public class BaseErrorExceptionHandler implements ErrorExceptionHandler {
    private final int defaultCode;
    private final ErrorResponseHandler<?> errorResponseHandler;

    @Override
    public boolean supports(Throwable exception) {
        return exception instanceof ThinkBridgeException;
    }

    @Override
    public ErrorResult<?> handle(Throwable exception, HttpStatus status, Locale locale) {
        if (exception instanceof TransmitException transmitException) {
            return new ErrorResult<>(transmitException, HttpStatus.resolve(transmitException.getHttpStatus()));
        }

        if (exception instanceof ThinkBridgeException thinkBridgeException) {
            return handleThinkBridgeException(thinkBridgeException, status, locale);
        }

        return null;
    }

    private ErrorResult<?> handleThinkBridgeException(ThinkBridgeException ex, HttpStatus status, Locale locale) {
        int httpStatus = ex.getHttpStatus();
        int code = ex.getCode() != 0 ? ex.getCode() : defaultCode;
        String message = ex.getMsgCode();
        Object data = ex.getData();
        Map<String, Object> extend = new HashMap<>(ex.getExtend());

        if (!ex.getDetails().isEmpty()) {
            extend.put(ErrorConst.ERROR_DETAILS, ex.getDetails());
        }

        return errorResponseHandler.error(message, ex.getArgs(), code, httpStatus, data, extend, locale);
    }
}

// 1. 自定义异常类
public class MyException extends AbstractException {
    protected MyException(int code, String msgCode, Object... args) {
        super(code, msgCode, args);
    }

    public static MyException of(ErrorCode errorCode, Object... args) {
        return new MyException(errorCode.getValue(), errorCode.getName(), args);
    }
}

// 2. 自定义异常处理器
@Component
public class MyExceptionHandler implements ErrorExceptionHandler {
    @Override
    public boolean supports(Throwable exception) {
        return exception instanceof MyException;
    }

    @Override
    public ErrorResult<?> handle(Throwable exception, HttpStatus status, Locale locale) {
        MyException ex = (MyException) exception;
        // 自定义处理逻辑
        return new ErrorResult<>(ResponseVo.error(ex.getCode(), ex.getMessage()), HttpStatus.resolve(ex.getHttpStatus()));
    }
}

package com.luamas.thinkbridge.common.error;

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

public interface ErrorResponseHandler<T> {
    ErrorResult<T> success(Object data);

    /
     * 返回ResponseVoResponseEntity
     *
     * @param message    消息
     * @param args       消息参数
     * @param errorCode  错误码
     * @param statusCode 状态码
     * @param data       数据，默认可以为空
     * @param locale 本地化
     * @return
     */
    @Deprecated
    default ErrorResult<T> error(String message, Object[] args, Integer errorCode, Integer statusCode, Object data, Locale locale) {
        return error(message, args, errorCode, statusCode, data, new HashMap<>(), locale);
    }

    /
     * 返回ResponseVoResponseEntity
     *
     * @param message    消息
     * @param args       消息参数
     * @param errorCode  错误码
     * @param statusCode 状态码
     * @param data       数据，默认可以为空
     * @param locale 本地化
     * @return
     */
    ErrorResult<T> error(String message, Object[] args, Integer errorCode, Integer statusCode, Object data, Map<String, Object> extend, Locale locale);
}

package com.luamas.thinkbridge.common.error;

import com.luamas.thinkbridge.common.base.vo.ErrorDetail;
import com.luamas.thinkbridge.common.base.vo.ResponseVo;
import com.luamas.thinkbridge.common.spring.utils.ErrorMessageSourceUtils;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;

import java.util.List;
import java.util.Locale;
import java.util.Map;

@Slf4j
@RequiredArgsConstructor
public class ThinkBridgeErrorResponseHandler implements ErrorResponseHandler<ResponseVo<?>> {
    /
     * 是否兼容处理
     */
    private final boolean compatibility;

    @Override
    public ErrorResult<ResponseVo<?>> success(Object data) {
        ResponseVo<?> responseVo = ResponseVo.success(data);
        return new ErrorResult<>(responseVo, HttpStatus.OK);
    }

    /
     * 返回ResponseVoResponseEntity
     *
     * @param message    消息
     * @param args       消息参数
     * @param errorCode  错误码
     * @param statusCode 状态码
     * @param data       数据，默认可以为空
     * @return
     */
    public ErrorResult<ResponseVo<?>> error(String message, Object[] args, Integer errorCode, Integer statusCode, Object data, Map<String, Object> extend, Locale locale) {
        HttpStatus status;
        ResponseVo<?> responseVo;
        try {
            message = ErrorMessageSourceUtils.getMessage(message, locale, args);
        } catch (Exception ex) {
            if (compatibility) {
                if (message.contains("%s")) {
                    try {
                        message = String.format(message, args);
                    } catch (Exception e) {
                        log.warn("Failed to format error message with String.format: {}", message, e);
                    }
                }
            }
        }
        if (compatibility) {
            if (message.contains("%s")) {
                try {
                    message = String.format(message, args);
                } catch (Exception e) {
                    log.warn("Failed to format error message with String.format: {}", message, e);
                }
            }
        }
        List<ErrorDetail> details = null;
        if (extend.containsKey(ErrorConst.ERROR_DETAILS)) {
            details = (List<ErrorDetail>) extend.get(ErrorConst.ERROR_DETAILS);
        }
        responseVo = ResponseVo.error(errorCode, message, data, details);
        if (500 == statusCode) {
            statusCode = 200;
        }
        status = HttpStatus.valueOf(statusCode);

        return new ErrorResult<>(responseVo, status);
    }
}

@Component
public class MyErrorResponseHandler implements ErrorResponseHandler<MyResponseVo> {

    @Override
    public ErrorResult<MyResponseVo> success(Object data) {
        return new ErrorResult<>(MyResponseVo.success(data), HttpStatus.OK);
    }

    @Override
    public ErrorResult<MyResponseVo> error(String message, Object[] args, Integer errorCode, Integer statusCode, Object data, Map<String, Object> extend, Locale locale) {
        MyResponseVo responseVo = MyResponseVo.error(errorCode, message);
        return new ErrorResult<>(responseVo, HttpStatus.valueOf(statusCode));
    }
}

# 覆盖默认配置
think:
  error:
    default-config-exceptions:
      org.springframework.security.core.AuthenticationException:
          status: 401
          code: 1200

# 追加自定义配置（不影响默认配置）
think:
  error:
    custom-config-exceptions:
      java.sql.SQLException:
          status: 500
          code: 1500
          message: "数据库错误"

package com.luamas.thinkbridge.bootstarter.error.configuration;

import com.luamas.thinkbridge.common.error.ConfigExceptionClassData;
import com.luamas.thinkbridge.common.error.DefaultExceptionConfigUtils;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;

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

/
 * @author : luamas
 * @date : 2023/1/6 14:51
 */
@ConfigurationProperties(prefix = "think.error")
@Getter
@Setter
public class ThinkBridgeErrorProperties {
    /
     * 未知异常启用美化消息，生产建议启用,默认打印堆栈异常信息
     */
    private boolean unknownEnableBeautifyMessage = false;
    /
     * 未知异常的错误码，默认为500
     */
    private int unknownCode = 500;
    /
     * 未知异常的美化消息，支持国际化配置
     */
    private String unknownBeautifyMessage = "error.BEAUTIFY_MESSAGE";
    /
     * 默认错误码，默认为1500
     */
    private int defaultCode = 1500;
    /
     * 页面未找到的错误码，默认为1504
     */
    private int notfound = 1504;
    /
     * 异常相关错误码等配置
     */
    private Map<String, ConfigExceptionClassData> defaultConfigExceptions = DefaultExceptionConfigUtils.getConfigExceptions();
    /
     * 异常相关错误码等配置
     */
    private Map<String, ConfigExceptionClassData> customConfigExceptions = new HashMap<>();

    public Map<String, ConfigExceptionClassData> getConfigExceptions() {
        Map<String, ConfigExceptionClassData> map = new HashMap<>();
        map.putAll(defaultConfigExceptions);
        map.putAll(customConfigExceptions);
        return map;
    }
}

# 下面演示了对所有SQL错误的拦截
think:
  error:
    unknown-enable-beautify-message: false # 未知异常启用美化消息，生产建议启用,默认打印堆栈异常信息
    unknown-code: 500 # 未知异常的错误码，默认为500
    unknown-beautify-message: "error.BEAUTIFY_MESSAGE" # 未知异常的美化消息，支持国际化配置，默认："error.BEAUTIFY_MESSAGE"
    default-code: 1500 # 默认错误码，默认为1500
    notfound: 1504 # 页面未找到的错误码，默认为1504

think:
  error:
    # 启用未知异常美化消息
    unknown-enable-beautify-message: true
    # 未知异常错误码
    unknown-code: 500
    # 默认错误码
    default-code: 1500
    # 页面未找到错误码
    notfound: 1504

throw UnauthorizedException.of(ResultCode.XXX, args);

package com.luamas.thinkbridge.common.base.exception;

/
 * 没有授权，此异常会抛出401
 *
 * @author luamas
 */
public class UnauthorizedException extends AbstractException {

    protected UnauthorizedException(int code, String msgCode, Object... args) {
        super(code, msgCode, args);
        this.httpStatus = 401;
    }

    protected UnauthorizedException(Throwable cause, int code, String msgCode, Object... args) {
        super(cause, code, msgCode, args);
        this.httpStatus = 401;
    }
    public static UnauthorizedException of(ErrorCode errorCode, Object... args) {
        return new UnauthorizedException(errorCode.getValue(), errorCode.getName(), args);
    }

    public static UnauthorizedException of(Throwable cause, ErrorCode errorCode, Object... args) {
        return new UnauthorizedException(cause, errorCode.getValue(), errorCode.getName(), args);
    }

    public static UnauthorizedException of(int code, String msgCode, Object... args) {
        return new UnauthorizedException(code, msgCode, args);
    }

    /
     * @deprecated 使用 {@link #of(ErrorCode, Object...)} 替代
     */
    @Deprecated
    public static UnauthorizedException newInstance(ErrorCode errorCode, Object... args) {
        return of(errorCode, args);
    }

    /
     * @deprecated 使用 {@link #of(Throwable, ErrorCode, Object...)} 替代
     */
    @Deprecated
    public static UnauthorizedException newInstance(Throwable cause, ErrorCode errorCode, Object... args) {
        return of(cause, errorCode, args);
    }

    /
     * @deprecated 使用 {@link #of(int, String, Object...)} 替代
     */
    @Deprecated
    public static UnauthorizedException newInstance(int code, String msgCode, Object... args) {
        return of(code, msgCode, args);
    }
}

throw ForbiddenException.of(ResultCode.XXX, args);

package com.luamas.thinkbridge.common.base.exception;

/
 * 没有授权，此异常会抛出403
 *
 * @author luamas
 /
public class ForbiddenException extends AbstractException {
    protected ForbiddenException(int code, String msgCode, Object... args) {
        super(code, msgCode, args);
        this.httpStatus = 403;
    }

    protected ForbiddenException(Throwable cause, int code, String msgCode, Object... args) {
        super(cause, code, msgCode, args);
        this.httpStatus = 403;
    }

    public static ForbiddenException of(ErrorCode errorCode, Object... args) {
        return new ForbiddenException(errorCode.getValue(), errorCode.getName(), args);
    }

    public static ForbiddenException of(Throwable cause, ErrorCode errorCode, Object... args) {
        return new ForbiddenException(cause, errorCode.getValue(), errorCode.getName(), args);
    }

    /
     * @deprecated 使用 {@link #of(ErrorCode, Object...)} 替代
     */
    @Deprecated
    public static ForbiddenException newInstance(ErrorCode errorCode, Object... args) {
        return of(errorCode, args);
    }

    /*
     * @deprecated 使用 {@link #of(Throwable, ErrorCode, Object...)} 替代
     */
    @Deprecated
    public static ForbiddenException newInstance(Throwable cause, ErrorCode errorCode, Object... args) {
        return of(cause, errorCode, args);
    }
}