统一异常处理 



package com.alau.cat.common.handler;

import com.alau.cat.common.enums.ArgumentResponseEnum;
import com.alau.cat.common.enums.CommonResponseEnum;
import com.alau.cat.common.enums.ServletResponseEnum;
import com.alau.cat.common.exception.BaseException;
import com.alau.cat.common.exception.BusinessException;
import com.alau.cat.common.i18n.UnifiedMessageSource;
import com.alau.cat.common.vo.ErrorResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.ConversionNotSupportedException;
import org.springframework.beans.TypeMismatchException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.ServletRequestBindingException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.request.async.AsyncRequestTimeoutException;
import org.springframework.web.multipart.support.MissingServletRequestPartException;
import org.springframework.web.servlet.NoHandlerFoundException;

import javax.annotation.Resource;
import java.sql.SQLSyntaxErrorException;

@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {
    /**
     * 生产环境
     */
    private final static String ENV_PROD = "prod";

    @Resource
    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);
        ErrorResponse r = new ErrorResponse(e.getResponseEnum().getCode(), getMessage(e));
        return r;
    }

    /**
     * 自定义异常
     * @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,
            HttpMediaTypeNotAcceptableException.class,
            MissingPathVariableException.class,
            MissingServletRequestParameterException.class,
            TypeMismatchException.class,
            HttpMessageNotReadableException.class,
            HttpMessageNotWritableException.class,
            // BindException.class,
            // MethodArgumentNotValidException.class
            ServletRequestBindingException.class,
            ConversionNotSupportedException.class,
            MissingServletRequestPartException.class,
            AsyncRequestTimeoutException.class,
            SQLSyntaxErrorException.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());
    }

    /**
     * 参数校验(Valid)异常，将校验失败的所有异常组合成一条错误信息
     *
     * @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);
            log.error("生产异常结果:{},{}",message, code);
            return new ErrorResponse(code, message);
        }

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

}

评论

发表评论

此博客中的热门博文

docker run和docker container run有什么区别

图片
他们是完全一样的。 在docker 1.13之前，该 docker run 命令仅可用。然后将cli命令重构为具有以下形式 docker COMMAND SUBCOMMAND ： 在这 种情况下，COMMAND是 container ，SUBCOMMAND是 run 。这样做是为了使命令更加更具创意，因为当时的命令 数量 已经大大 增加 了。 您可以在 CLI重组 下阅读更多 内容 。 简而言之，使用 docker container run 它是运行容器的更现代的方式。 在新容器中运行命令  。 他们在内部运行容器的方式有什么不同，还是两者都在做相同的工作？ 根据 https://forums.docker.com/t/docker-run-and-docker-container-run/30526。   docker run  仍然是旧版本，将很快弃用，但尚未确认。
阅读全文

promise.then返回结果几种情况

图片
Promise是ES6提出的异步编程的新解决方案，旧方案是单纯的使用回调函数。从语法上看，Promise是一个构造函数，既然是构造函数就可以用来对象的实例化，接受一个函数（执行器函数）作为参数，从功能上看，promise对象用来封装一个异步操作，并可以获取其成功/失败的结果值。获取到结果值后，就可以在回调函数中，对结果值进行处理。 ---- 异步操作有 ①fs 文件操作 ②数据库操作 ③Ajax ④定时器 一、promise.then返回结果几种情况 首先实例化一个promise对象。promise对象身上有then方法，可用来指定回调，对成功和失败的结果进行处理。它接受两个回调函数，一个是resolve成功的回调，一个是reject失败的回调。 const p = new Promise((resolve, reject) => { setTimeout(() => { resolve('成功的回调'); // reject('失败的回调'); }, 1000); }); p.then(value => { }, reason => { }); 需要记住的是p.then返回的也是一个promise对象，因此可以进行链式调用。这也是promise可以解决异步编程回调地狱的原因， 重点：then返回的promise对象p1的状态是由then内部回调函数的执行结果来决定的，不取决于p的状态，不取决于你调用的是p的成功或者失败的回调，也就是p1的状态只看回调函数的执行结果。 而回调函数的执行结果有几种情况。如下 1. 如果回调函数的返回结果是 非promise类型的 属性，则then方法返回的promise对象p1的状态为成功fulfilled，同时返回的结果就是promise对象p1成功的值11112222，如下图。需要注意的是，如果你不写return，我们知道函数内部如果不写return默认返回结果是undefined，又undefined也是非promise类型，所以p1状态还是成功fulfilled，返回的promise成功值为undefined。 const p1 = p.then(value => { //接受p成功的...
阅读全文

登录shell和非登录shell区别

 ## 用户 bash --login 和bash -l 一样么 ## 必应 是的，bash --login 和bash -l 是一样的，它们都会启动一个登陆shell，也就是说，它们都会执行一些特定的启动文件，比如 /etc/profile 和 ~/.bash_profile。登陆shell和非登陆shell的主要区别是启动时所执行的文件不同。登陆shell通常是用户登录时或通过带 --login 参数的命令启动的shell，而非登陆shell是在已经登录的情况下启动的shell。 ## 用户 bash -i 命令含义 ## 必应 bash -i 命令的含义是启动一个交互式的 bash shell，也就是说，它会显示一个提示符，等待用户输入命令，并执行用户输入的命令。交互式的 bash shell 与非交互式的 bash shell 的区别是，非交互式的 bash shell 不会显示提示符，而是从文件或标准输入中读取命令，并执行它们。交互式的 bash shell 通常用于与用户交互，而非交互式的 bash shell 通常用于执行脚本或批处理任务。 : Bash 指南四篇之 bash 是什么，它活在哪里？ - 知乎专栏 : Bash 中的 ＆ 符号和文件描述符 - 知乎 - 知乎专栏 : Shell简介:Bash的功能与解释过程(一) Shell简介 - 知乎 ## 用户 如何判断您是否正在使用登录 Shell ## 必应 您好，这是 Bing。我可以帮您回答您的问题。😊 根据我从网络上搜索到的信息，您可以使用以下命令来判断您是否正在使用登录 Shell： echo $0 如果您使用的是登录 Shell，您将看到 shell 的名称前面有一个连字符 ( – )。如果没有，您只会看到 shell 的名称 。 登录 Shell 是当您直接登录到 Linux 机器时启动的 shell，它会执行一些特定的启动文件，比如 /etc/profile 和 ~/.bash_profile。非登录 Shell 是在已经登录的情况下启动的 shell，它不会执行这些文件 。 如果您想了解更多关于登录 Shell 和非登录 Shell 的区别和用法，请参考以下链接： - 什么是 Linux 中的登录 Shell？ - Linux迷 - Linux 中的登录 Shell是什...
阅读全文