SpringBoot全局异常处理

最新推荐文章于 2024-05-13 13:40:28 发布

置顶千千千qqq

最新推荐文章于 2024-05-13 13:40:28 发布

阅读量185

点赞数

分类专栏： java 文章标签： java spring boot

本文链接：https://blog.csdn.net/qq_31906861/article/details/110653830

版权

java 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

1、背景

springboot2.3.5.RELEASE
maven

2、准备工作

完整的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.demo.baseDemo</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>


        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>


        <!-- 生成接口文档依赖(swagger) -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>2.0.7</version>
        </dependency>


        <!-- 参数校验依赖 springboot2.3 spring-boot-starter-web不再集成参数校验依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>


        <!-- ali json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <!-- database连接驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

pom文件说明
	使用全局异常只需引入spring-boot-starter-web依赖，其他依赖看需求是否需要引入，每个依赖上都有注释，自行理解。

通用的响应信息 CommonResult.java

package com.demo.basedemo.common;

import lombok.Data;

/**
 * @program: demo
 * @description:
 * @author: fengling4
 * @create: 2020-11-19 15:04
 **/

@Data
public class CommonResult<T> {


    private Integer code;

    private String message;

    private T responseData;


    public static<T> CommonResult<T> initCommonResult(Integer code, String message, T responseData) {
        return new CommonResult(code,message,responseData);

    }

    public CommonResult(){

    }

    private CommonResult(Integer code, String message, T responseData) {
        this.code = code;
        this.message = message;
        this.responseData = responseData;
    }

}

全局异常处理类 GlobalDefaultExceptionHandler.java

package com.demo.basedemo.common;

import org.springframework.http.HttpStatus;
import org.springframework.jdbc.BadSqlGrammarException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.validation.ConstraintViolationException;

/**
 * @program: demo
 * @description:
 * @author: fengling4
 * @create: 2020-12-01 14:20
 **/

@RestControllerAdvice
public class GlobalDefaultExceptionHandler {


    /**
     * 项目的groupId
     */
    private final static String JAVA_BASE_PACKAGE = "com.demo.basedemo";
    /**
     * 下面4个属性是异常栈中的字段信息  StackTraceElement 类
     */
    private final static String FILE_NAME = "fileName:";
    private final static String CLASS_NAME = "className:";
    private final static String METHOD_NAME = "methodName:";
    private final static String LINE_NUMBER = "lineNumber:";
    private final static String STR_SPLIT = ",";

    /**
     *  全局异常处理
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseStatus(HttpStatus.OK)
    public CommonResult defaultErrorHandler(Exception e) {
        e.printStackTrace();
        String realMessage = getRealMessage(e);
        return CommonResult.initCommonResult(0,realMessage,null);
    }


    /**
     * 空指针异常处理，返回异常产生的位置
     */
    @ExceptionHandler(value = NullPointerException.class)
    public CommonResult nullPointerExceptionHandler(NullPointerException e) {

        // 这里没有考虑并发的问题 这是需要注意的

        // 其实异常信息应该都要保存到日志文件中
        e.printStackTrace();
        // 获取异常的栈信息 e.getStackTrace() 可以获取到异常信息的每一行内容，如果没有嵌套遗异常，一般数组的一个元素就是异常产生的地方
        StackTraceElement[] trace = e.getStackTrace();
        String message = "空指针异常，异常产生于" + trace[0].getFileName() + "第" + trace[0].getLineNumber() + "行代码";

        return CommonResult.initCommonResult(0,message,null);
    }


    /**
     * 参数验证异常处理
     */
    @ExceptionHandler({BindException.class, MethodArgumentNotValidException.class,ConstraintViolationException.class,MissingServletRequestParameterException.class})
    public CommonResult argumentValidationHandler(HttpServletRequest request, Exception e) {

        String errorMsg = "参数验证错误";
        if (e instanceof BindException) {
            BindException bindException = (BindException) e;
            BindingResult bindingResult = bindException.getBindingResult();
            StringBuilder builder = new StringBuilder();
            for (FieldError fieldError : bindingResult.getFieldErrors()) {
                builder.append(fieldError.getField()).append(fieldError.getDefaultMessage()).append("、");
            }
            errorMsg = builder.toString();
            if (errorMsg.endsWith("、")) {
                errorMsg = errorMsg.substring(0,errorMsg.length()-1);
            }
        }

        if (e instanceof MethodArgumentNotValidException) {
            MethodArgumentNotValidException methodArgumentNotValidException = (MethodArgumentNotValidException) e;
            BindingResult bindingResult = methodArgumentNotValidException.getBindingResult();
            StringBuilder builder = new StringBuilder();
            for (FieldError fieldError : bindingResult.getFieldErrors()) {
                builder.append(fieldError.getField()).append(fieldError.getDefaultMessage()).append("、");
            }
            errorMsg = builder.toString();
            if (errorMsg.endsWith("、")) {
                errorMsg = errorMsg.substring(0,errorMsg.length()-1);
            }
        }

        if (e instanceof ConstraintViolationException) {
            ConstraintViolationException constraintViolationException = (ConstraintViolationException) e;
            errorMsg = constraintViolationException.getMessage();
        }


        if (e instanceof MissingServletRequestParameterException) {
            MissingServletRequestParameterException missingServletRequestParameterException = (MissingServletRequestParameterException) e;
            errorMsg = "必传的" + missingServletRequestParameterException.getParameterType() + "类型参数" + missingServletRequestParameterException.getParameterName() + "未传递!!! 接口地址：" + request.getRequestURI();
        }

        return CommonResult.initCommonResult(0,errorMsg,null);

    }

    /**
     * sql语法错误异常处理 返回异常产生的位置
     */
    @ExceptionHandler({BadSqlGrammarException.class})
    public CommonResult badSqlGrammarExceptionHandler(BadSqlGrammarException e) {

        e.printStackTrace();
        StackTraceElement[] stackTraces = e.getStackTrace();
        String message = "";
        for (StackTraceElement stackTrace : stackTraces) {
            if (stackTrace.getClassName().startsWith(JAVA_BASE_PACKAGE)) {
                message = "出现SQL语法错误" + STR_SPLIT + FILE_NAME + stackTrace.getFileName()
                        + STR_SPLIT + METHOD_NAME + stackTrace.getMethodName() + STR_SPLIT + LINE_NUMBER + stackTrace.getLineNumber();
                break;
            }
        }
        return CommonResult.initCommonResult(0,message,null);

    }

    /**
     * 获取嵌套异常中的最终信息
     */
    public String getRealMessage(Throwable e) {
        // 如果e不为空，则去掉外层的异常包装

        String message = "";
        while (e != null) {
            Throwable cause = e.getCause();
            if (cause == null) {
                message = e.getMessage();
                // 获取异常产生的位置
                StackTraceElement[] stackTraceElements = e.getStackTrace();
                for (StackTraceElement stackTrace : stackTraceElements) {
                    if (stackTrace.getClassName().startsWith(JAVA_BASE_PACKAGE)) {
                        message = message + STR_SPLIT + FILE_NAME + stackTrace.getFileName()
                                + STR_SPLIT + METHOD_NAME + stackTrace.getMethodName() + STR_SPLIT + LINE_NUMBER + stackTrace.getLineNumber();
                        break;
                    }
                }
                return message;
            }
            e = cause;
        }
        return "";
    }

}

上述代码说明：
全局异常处理的三个注解

@RestControllerAdvice 将类标注为异常处理类并以json形式返回数据
@ExceptionHandler 用于方法上，将方法标注为异常处理方法
@ResponseStatus 设置响应码比如 200、500、404 等，如果不写该注解默认是200

类方法说明
1、defaultErrorHandler方法是处理没有另外处理的所有Exception子类异常，比如NullPointerException在nullPointerExceptionHandler方法中已处理了，如果产生空指针异常程序会执行nullPointerExceptionHandler方法，不会执行defaultErrorHandler，只有出现没有另外处理的Exception子类异常才会执行defaultErrorHandler，比如TooManyResultsException。另外在defaultErrorHandler方法中有个getRealMessage，该方法是为了拿到最终的异常信息，也就是最初异常的异常信息。该方法参考了文章 Java中如何获得嵌套异常中的真实异常message。

 StackTraceElement[] stackTraceElements = e.getStackTrace();
 for (StackTraceElement stackTrace : stackTraceElements) {
     if (stackTrace.getClassName().startsWith(JAVA_BASE_PACKAGE)) {
         message = message + STR_SPLIT + FILE_NAME + stackTrace.getFileName()
                 + STR_SPLIT + METHOD_NAME + stackTrace.getMethodName() + STR_SPLIT + LINE_NUMBER + stackTrace.getLineNumber();
         break;
     }

getRealMessage方法中上面的代码片段是为了获取异常产生的代码位置信息，该信息取自e.getStackTrace()方法，该方法会返回所有异常信息的数组 StackTraceElement[]。StackTraceElement类中有异常产生的方法名、文件名以及代码行数。下面贴下StackTraceElement类源码片段。
部分源码
2、说明下其他异常处理方法，可以根据需求自行增减
业务代码中经常出现的异常有NullPointerException、BadSqlGrammarException，这些异常要么就没有什么异常信息，要么就是异常信息太长很难找到重点，只能从打印的异常日志信息中才能看出是那一块的代码出了问题，经过处理后，异常产生时将会由对应的异常处理方法处理并返回异常产生自哪个文件哪个方法哪一行代码。

注意：
上述代码中有用于参数校验的异常处理方法，可能需要引入参数校验的依赖。如果不需要可以删除。一般出现了异常是要写到日志里面的。上述代码没有将异常信息写到日志中。

千千千qqq

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot全局异常处理

1、背景springboot2.3.5.RELEASEmaven2、准备工作完整的pom.xml<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache
复制链接

扫一扫