Spring Boot 定义全局异常处理返回统一异常信息

最新推荐文章于 2024-05-04 23:56:02 发布
最新推荐文章于 2024-05-04 23:56:02 发布
阅读量880 收藏 5
点赞数
分类专栏： # Java-异常处理 文章标签： spring boot 监控类 aop bug
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IWinds/article/details/122435030
版权

概述

Spring Boot项目定义全局异常处理器，统一返回异常信息。

环境
JDK1.8

设计

1.自定义一个异常类

import lombok.Data;

/**
 * @Classname 自定义异常
 * @Description:
 * @Date 2021/6/30 16:16
 * @Created by LSH
 */
@Data
public class BizException extends RuntimeException {
    private static final long serialVersionUID = 1L;

    /**
     * 错误码
     */
    protected String errorCode;
    /**
     * 错误信息
     */
    protected String errorMsg;
    /**
     * 返回数据
     */
    protected Object data;

    /**
     * 主要业务参数
     */
    protected String taskParam;
    /**
     * 业务参数
     */
    protected String taskParams;
    /**
     * 业务描述
     */
    protected String taskName;
    /**
     * 业务节点描述
     */
    protected String nodeName;
    /**
     * 执行的方法
     */
    protected String method;

    public BizException() {
        super();
    }

    public BizException(BaseErrorInfoInterface errorInfoInterface) {
        super(errorInfoInterface.getResultCode());
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }
    public BizException(BaseErrorInfoInterface errorInfoInterface,String taskParam, String taskName,String nodeName,String method,String taskParams) {
        super(errorInfoInterface.getResultCode());
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
        this.taskParam=taskParam;
        this.taskName=taskName;
        this.nodeName=nodeName;
        this.taskParams=taskParams;
        this.method=method;
    }

    public BizException(BaseErrorInfoInterface errorInfoInterface,String taskParam, String taskName,String nodeName,String method,String taskParams,Object data) {
        super(errorInfoInterface.getResultCode());
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
        this.taskParam=taskParam;
        this.taskName=taskName;
        this.nodeName=nodeName;
        this.taskParams=taskParams;
        this.method=method;
        this.data=data;
    }

    public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
        super(errorInfoInterface.getResultCode(), cause);
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }

    public BizException(String errorMsg) {
        super(errorMsg);
        this.errorMsg = errorMsg;
    }

    public BizException(String errorCode, String errorMsg) {
        super(errorCode);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public BizException(String errorCode, String errorMsg, Throwable cause) {
        super(errorCode, cause);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public String getErrorCode() {
        return errorCode;
    }

    @Override
    public String getMessage() {
        return errorMsg;
    }

    @Override
    public Throwable fillInStackTrace() {
        return this;
    }
}

注意: 该异常类设计时字段设计的多有冗余，可以先按照例子设计，通篇看完后就知道这些字段都用来干嘛了，然后即可按需设计。

2.定义一个异常信息接口模板

/**
 * @Classname BaseErrorInfoInterface
 * @Description:
 * @Date 2021/6/30 16:14
 * @Created by LSH
 */
public interface BaseErrorInfoInterface {
    /** 错误码*/
    String getResultCode();

    /** 错误描述*/
    String getResultMsg();
}

3.定义一个异常枚举，实现步骤2的接口

/**
 * @Classname CommonEnum
 * @Description:
 * @Date 2021/6/30 16:15
 * @Created by LSH
 */
public enum CommonEnum implements BaseErrorInfoInterface {
    // 数据操作错误定义
    SUCCESS("200", "success"),

    BODY_NOT_MATCH("400","数据空指针!"),
    SIGNATURE_NOT_MATCH("401","请求的数字签名不匹配!"),
    NOT_FOUND("404", "未找到该资源!"),

    INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
    PARAM_VERIFY_ERROR("501", "业务参数为空!"),
    PARAM_ILLEGAL_ERROR("502", "非法的业务参数!"),
    SERVER_BUSY("503","服务器正忙，请稍后再试!"),
    DUPLICATE_KEY_ERROR("504","DB主键冲突!"),
    TOO_MANY_RESULT_ERROR("505","Query异常!"),
    QUERY_RESULT_NULL("506","There are some scenarios where DB Query is necessary,But null"),
    HTTP_API_ERROR("507","HTTP API服务异常!"),
    BAD_SQL("508","BAD SQL!"),
    DML_ERROR("510","DML ERROR!"),

    EXPORT_ERROR("600","File Export Error!"),
    FILE_NOT_FOUND("601","File Not Found!"),
    FILE_READ_ERROR("603","File Parsing Error!"),

    HTTP_ERROR("700","Http API Error!");

    /** 错误码 */
    private String resultCode;

    /** 错误描述 */
    private String resultMsg;

    CommonEnum(String resultCode, String resultMsg) {
        this.resultCode = resultCode;
        this.resultMsg = resultMsg;
    }


    @Override
    public String getResultCode() {
        return resultCode;
    }

    @Override
    public String getResultMsg() {
        return resultMsg;
    }
}

注意：该枚举类中的code以及code对应的错误描述按需自行设计即可。

4.定义一个异常实体类，用于发生异常时返回给前端

import com.alibaba.fastjson.JSONObject;
import lombok.Data;

/**
 * @Classname ResultBody
 * @Description:
 * @Date 2021/6/30 16:17
 * @Created by LSH
 */
@Data
public class ResultBody {
    /**
     * 响应代码
     */
    private String code;

    /**
     * 响应消息
     */
    private String message;

    /**
     * 响应结果
     */
    private Object result;

    public ResultBody() {
    }

    public ResultBody(BaseErrorInfoInterface errorInfo) {
        this.code = errorInfo.getResultCode();
        this.message = errorInfo.getResultMsg();
    }

    /**
     * 成功,不带返回数据
     * @return
     */
    public static ResultBody success() {
        return success(null);
    }

    /**
     * 成功，带返回数据
     * @param data
     * @return
     */
    public static ResultBody success(Object data) {
        ResultBody rb = new ResultBody();
        rb.setCode(CommonEnum.SUCCESS.getResultCode());
        rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
        rb.setResult(data);
        return rb;
    }

    /**
     * 失败，不带返回数据
     */
    public static ResultBody error(BaseErrorInfoInterface errorInfo) {
        ResultBody rb = new ResultBody();
        rb.setCode(errorInfo.getResultCode());
        rb.setMessage(errorInfo.getResultMsg());
        rb.setResult(null);
        return rb;
    }

    /**
     * 失败，不带返回数据
     */
    public static ResultBody error(String code, String message) {
        ResultBody rb = new ResultBody();
        rb.setCode(code);
        rb.setMessage(message);
        rb.setResult(null);
        return rb;
    }
    /**
     * 失败，带返回数据
     */
    public static ResultBody error(String code, String message,Object data) {
        ResultBody rb = new ResultBody();
        rb.setCode(code);
        rb.setMessage(message);
        rb.setResult(data);
        return rb;
    }

    /**
     * 失败
     */
    public static ResultBody error( String message) {
        ResultBody rb = new ResultBody();
        rb.setCode("-1");
        rb.setMessage(message);
        rb.setResult(null);
        return rb;
    }

    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
}

5.定义一个全局异常处理器

在 @ExceptionHandler 注解中中预定义好运行时可能会遇到的异常类型，当异常发生时，就能够被该类捕获。

import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.MyBatisSystemException;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.jdbc.BadSqlGrammarException;
import org.springframework.jdbc.UncategorizedSQLException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MissingServletRequestParameterException;
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.method.annotation.MethodArgumentTypeMismatchException;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @Classname GlobalExceptionHandler
 * @Description: 全局异常处理器
 * @Date 2021/6/30 16:19
 * @Created by LSH
 */
@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    //@Autowired
    //private ErrorLogService errorLogService;

    /**
     * 处理自定义业务异常
     * @param e
     * @return
     */
    @ExceptionHandler(value = BizException.class)
    @ResponseBody
    public ResultBody bizExceptionHandler(BizException e){
        log.error(e.getMethod(),e);
        return ResultBody.error(e.getErrorCode(),e.getErrorMsg(),e.getData());
    }

    /**
     * 处理空指针异常
     * @param e
     * @return
     */
    @ExceptionHandler(value =NullPointerException.class)
    @ResponseBody
    public ResultBody exceptionHandler(NullPointerException e){
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"空指针异常!");
        log.error("空指针异常!",e);
        return ResultBody.error(CommonEnum.BODY_NOT_MATCH);
    }

    /**
     * 处理未知异常
     * @param e
     * @return
     */
    @ExceptionHandler(value =Exception.class)
    @ResponseBody
    public ResultBody exceptionHandler(Exception e){
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"未知异常!");
        log.error("未知异常!",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }
    
    /**
     * DB异常
     * @param e
     * @return
     */
    @ExceptionHandler(UncategorizedSQLException.class)
    @ResponseBody
    public ResultBody handleUncategorizedSQLException(UncategorizedSQLException e){
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"DB主键冲突!");
        log.error("DB异常!", e);
        return ResultBody.error(CommonEnum.BAD_SQL);
    }
    
    /**
     * DB主键冲突异常
     * @param e
     * @return
     */
    @ExceptionHandler(DuplicateKeyException.class)
    @ResponseBody
    public ResultBody handleDuplicateKeyException(DuplicateKeyException e){
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"DB异常!");
        log.error("DB主键冲突!", e);
        return ResultBody.error(CommonEnum.DUPLICATE_KEY_ERROR);
    }

    /**
     * 非法sql异常
     * @param e
     * @return
     */
    @ExceptionHandler(BadSqlGrammarException.class)
    @ResponseBody
    public ResultBody badSqlGrammarException(BadSqlGrammarException e){
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"BAD SQL!");
        log.error("BAD SQL!", e);
        return ResultBody.error(CommonEnum.BAD_SQL);
    }

    /**
     * Query异常
     * @param e
     * @return
     */
    @ExceptionHandler(MyBatisSystemException.class)
    @ResponseBody
    public ResultBody queryException(MyBatisSystemException e){
        //errorLogService.insertErrorLog("","","Query Data",exceptionMethod(e),e,"Query异常!");
        log.error("Query异常!", e);
        return ResultBody.error(CommonEnum.TOO_MANY_RESULT_ERROR);
    }

    /**
     * DML 操作异常
     * @param e
     * @return
     */
    @ExceptionHandler(DataIntegrityViolationException.class)
    @ResponseBody
    public ResultBody dataIntegrityViolationException(MyBatisSystemException e){
        //errorLogService.insertErrorLog("","","Query Data",exceptionMethod(e),e,"DML 操作异常!");
        log.error("DML 操作异常!", e);
        return ResultBody.error(CommonEnum.DML_ERROR);
    }

    /**
     * 运算异常
     */
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public ResultBody arithmeticExceptionHandler(ArithmeticException e) {
        //errorLogService.insertErrorLog("","","Data Process",exceptionMethod(e),e,"运算异常!");
        log.error("运算异常!",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }

    /**
     * 类型转换异常
     */
    @ExceptionHandler(ClassCastException.class)
    @ResponseBody
    public ResultBody classCastExceptionHandler(ClassCastException e) {
        //errorLogService.insertErrorLog("","","Data Process",exceptionMethod(e),e,"类型转换异常!");
        log.error("类型转换异常!",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }

    /**
     * 数据下标越界异常
     */
    @ExceptionHandler(IndexOutOfBoundsException.class)
    @ResponseBody
    public ResultBody indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException e) {
        //errorLogService.insertErrorLog("","","Data Process",exceptionMethod(e),e,"数据下标越界异常!");
        log.error("数据下标越界异常!",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }

    /**
     * 文件未找到异常
     */
    @ExceptionHandler(FileNotFoundException.class)
    @ResponseBody
    public ResultBody fileNotFoundExceptionHandler(FileNotFoundException e) {
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"文件未找到异常!");
        log.error("文件未找到异常!",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }

    /**
     * IO异常
     */
    @ExceptionHandler(IOException.class)
    @ResponseBody
    public ResultBody iOExceptionHandler(IOException e) {
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"IO异常!");
        log.error("IO异常!",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }

    /**
     * 参数类型不匹配
     */
    @ExceptionHandler({MethodArgumentTypeMismatchException.class})
    @ResponseBody
    public ResultBody requestTypeMismatch(MethodArgumentTypeMismatchException e) {
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"参数类型不匹配!");
        log.error("参数类型不匹配!",e);
        return ResultBody.error("参数类型不匹配");
    }

    /**
     * 必要的参数为null
     */
    @ExceptionHandler({MissingServletRequestParameterException.class})
    @ResponseBody
    public ResultBody requestMissingServletRequest(MissingServletRequestParameterException e) {
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"必要的参数为null");
        log.error("必要的参数为null!",e);
        return ResultBody.error("必要的参数为null");
    }

    /**
     * 请求method不匹配
     */
    @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
    @ResponseBody
    public ResultBody requestMissingServletRequest(HttpRequestMethodNotSupportedException e) {
        //errorLogService.insertErrorLog("","","",exceptionMethod(e),e,"请求method不匹配");
        log.error("请求method不匹配!",e);
        return ResultBody.error("请求method不匹配");
    }

    /**
     * 获取异常堆栈信息
     * @param e
     * @return
     */
    public Map<String,Object> getExceptionStackTraceInfo(Exception e){
        if(e==null){
            return null;
        }

        Map<String,Object> exceptionStackTraceInfo=new HashMap<>();
        StackTraceElement[] stackTrace = e.getStackTrace();
        String methodName = "";
        String className = "";
        if(stackTrace.length>0){
            methodName = stackTrace[0].getMethodName();
            className = e.getStackTrace()[0].getClassName();
        }
        exceptionStackTraceInfo.put("method",methodName);
        exceptionStackTraceInfo.put("class",className);
        return exceptionStackTraceInfo;
    }

    /**
     * 获取发生异常时的方法
     * @param e
     * @return
     */
    public String exceptionMethod(Exception e){
        Map<String, Object> exceptionStackTraceInfo = this.getExceptionStackTraceInfo(e);
        if(exceptionStackTraceInfo==null){
            return null;
        }
        return (String) exceptionStackTraceInfo.get("method");
    }

    /**
     * 获取发生异常时的类
     * @param e
     * @return
     */
    public String exceptionClass(Exception e){
        Map<String, Object> exceptionStackTraceInfo = this.getExceptionStackTraceInfo(e);
        if(exceptionStackTraceInfo==null){
            return null;
        }
        return (String) exceptionStackTraceInfo.get("class");
    }
}

6.实际效果样例

1.在API内部预设一个空指针异常
预设一个异常
2.使用API管理工具ApiPost调用该API
调用API
3.异常返回
异常返回信息
该异常在全局异常处理类中已经预定义，所以当空指针异常发生时就能够被捕获到
空指针异常

通过统一的响应码和响应信息，在遇到Bug时即可大致判断出了什么错误，快速定位线上Bug。

昭武归尘
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Spring Boot2 Webflux的全局异常处理
08-26
主要介绍了详解Spring Boot2 Webflux的全局异常处理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Springboot 自定义异常类及自定义返回编码
阿巴阿巴……
07-28 4195
springboot中定义异常类，从而统一返回值类型，让业务更加完美
SpringBoot 项目优雅处理全局异常
不负年华
10-25 357
阐述： 框架的异常处理往往不太合适，因此我们需要对这些异常进行分类统一的捕获处理。SpringBoot 中可以用@ControllerAdvice 进行系统全局异常的捕获。 代码如下： @ControllerAdvice @Slf4j public class GlobalExceptionHandler { /** * 处理自定义的业务异常 * @param req * @param e * @return */ @ExceptionHandler(value = MY.
全局异常的定义和使用
最新发布
m0_61495361的博客
05-04 183
全局异常的定义和使用
SpringBoot 全局异常处理
weixin_44936599的博客
04-16 208
代码简单示例 SpringBoo t的项目已经对有一定的异常处理了，但是对于我们开发者而言可能就不太合适了，因此我们需要对这些异常进行统一的捕获并处理。SpringBoot 中有一个ControllerAdvice 的注解，使用该注解表示开启了全局异常的捕获，我们只需在自定义一个方法使用ExceptionHandler 注解然后定义捕获异常的类型即可对这些捕获的异常进行统一的处理。 我们根据下面的...
springboot优雅的做全局异常处理（完整代码+已运行使用）
Hitmi_的博客
01-25 1754
首先我们需要知道的是，java异常的基础知识和springboot对异常处理是如何支持的。Java异常的基础知识大家可以参考菜鸟教程的java教程。 springboot对异常处理的支持 在springboot中，我们只需要定义一个全局异常处理类（用@ControllerAdvice），不需要在每个controller类重复定义。在全局异常处理类中，我们使用@ExceptionHandler指定...
Springboot自定义全局异常
weixin_44314459的博客
03-19 1524
自定义全局异常 bizException基础包下封装异常类 BizException：运行时业务中出现的异常 /** * @Description : 运行时业务中出现的异常 * @Param : * @Return : * @Author : l-jiahui * @Date : 2020-10-11 */ public class BizException extends RuntimeException { private static final long serialVers
Java异常介绍及Spring Boot统一异常处理
01-05
Spring Boot 提供了统一的异常处理机制，通过使用 @ControllerAdvice 和 @ExceptionHandler 注解，可以实现对控制器层、Service 层、Dao 层以及 Spring 系统内定义的部分异常的统一处理。 在 Spring Boot 中，可以...
Spring Boot 捕捉全局异常 统一返回值的问题
08-19
Spring Boot 捕捉全局异常统一返回值 在 Spring Boot 框架中，捕捉全局异常并统一返回值是一个非常重要的概念。本文将通过实例代码详细介绍如何在 Spring Boot 中捕捉全局异常，并统一返回值，从而使开发者能够更好...
spring boot 默认异常处理的实现
08-26
在 Spring Boot 中，默认的异常处理机制是通过 `@ExceptionHandler` 注解来定义全局异常处理器的。当应用程序中出现异常时，Spring Boot 会自动将异常抛出，并将其转发到全局异常处理器中。 示例代码 下面是一个...
SpringBoot初始教程之统一异常处理详解
08-30
@ControllerAdvice是一个Spring注解，用于定义一个全局异常处理器。通过使用@ControllerAdvice，我们可以捕获所有的异常，并对其进行处理。 在上面的代码中，我们定义了一个GlobalExceptionHandler类，该类使用@...
全局异常处理-@ExceptionHandler、ExceptionHandlerMethodResolver
jianlee1991的博客
04-14 951
浅尝 自定义全局异常处理 @ControllerAdvice publicclassGlobalExceptionHandler{ privatestaticfinalLoggerlogger=LoggerFactory.getLogger(GlobalExceptionHandler.class); /** *处理自定义的业务异常 *@paramreq *@parame *@return */ @ExceptionHandler(...
springboot自定义全局异常处理+前台返回异常统一处理
goxingman的博客
05-19 2099
一、思想 第一步、定义一个返回类型枚举rescode，返回类res（rescode） 第二步、自定义运行时异常类bussEx ，定义全局异常处理类GolbEx 第三步、判断返回前端是否出现异常 3.1出现异常：手动抛出bussEx（rescode），并传入错误类型，会触发GolbEx类中关联bussEx的方法handler（ex），在 handler（）中取出code和info，封装到res返回类，返回给前端 ...
springboot 全局异常统一返回
拒绝躺平，适当内卷
03-24 1025
统一返回结果全局异常处理
SpringBoot统一接口返回和全局异常
拾一二的博客
11-01 6966
写在最前：后端接口大致分为四个部分组成：接口地址（url）、接口请求方式（get、post等）、请求数据（request）、响应数据（response）。如何构建，这是我们应该深入思考的问题，公司不同，规范不同，要求不同。不管公司有没有要求，我们对自己必须要有要求。 今天的这篇文章我们主要介绍，怎么统一处理下接口的返回格式问题。 在写后端接口，思考下药做些什么：请求，逻辑处理，返回。 这似乎已经可以满足对用户管理操作的需求，但是对于一个查询用户方法来讲代码量还是可以接受的，但是对于一个简单的更
67、商品服务-API-品牌管理-统一异常处理
pyd1040201698的博客
08-13 320
package com.atguigu.gulimall.product.exception; import com.atguigu.common.utils.R; import lombok.extern.slf4j.Slf4j; import org.springframework.validation.BindingResult; import org.springframework.validation.FieldError; import org.springframework.web...
Springboot项目中的异常处理与返回结果的统一
m0_71777195的博客
08-10 1374
/ 方便前端判断当前请求处理结果是否正常// 业务处理结果// 产生错误的情况下，提示用户信息// 产生错误情况下的异常堆栈，提示开发人员// 发生错误的时候，返回的附加信息}复制代码1.为了把模糊的消息定性，我们给所有的返回结果都带上一个code字段，前端可以根据这个字段来判断我们的处理结果到底是成功的还是失败的；比如code=200的时候，我们的处理结果一定是成功的，其他的code值全都是失败的，并且我们会有多种code值，以便前端页面可以根据不同的code值做出不同的交互动作。...
Spring/SpringBoot定义统一异常错误码返回
KimZing的博客
08-05 7418
配置大致说下流程， 首先我们自定义一个自己的异常类CustomException，继承RuntimeException。再写一个异常管理类ExceptionManager，用来抛出自定义的异常。 然后使用Spring提供的注解@RestControllerAdvice或者@ControllerAdvice写一个统一异常处理的类，在这个类中写一个带有@ExceptionHandler(Exceptio
springboot错误信息返回与自定义异常处理
Ajekseg的博客
04-26 2945
在很多系统中，我们可能在运行时出现各种异常，有系统异常，代码异常，自定义的异常。这时候我们就要把这些错误异常信息返回去给客户端查看才知道是哪里出问题。这里我们就说说spring boot的异常处理。 springboot错误信息返回: 实际上，如果我们访问一个url,不同的客户端可能返回的信息不一样，比如浏览器返回错误页面，手机客户端返回json数据。 下面这段代码是springboot框架中抛出一个异常，那么springboot面对电脑浏览器和客户端会做出什么不同的返回信息呢？ @RequestMappi
Spring boot全局异常处理
08-14
4. 在方法中定义处理异常的逻辑，例如返回自定义的错误消息、错误码等。 5. 可以选择将错误消息封装成一个自定义的响应实体类，以便在控制器中统一返回该实体类。 以下是一个简单的示例： ```java @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值