springboot自定义异常处理

最新推荐文章于 2024-07-05 15:19:35 发布
最新推荐文章于 2024-07-05 15:19:35 发布
阅读量665 收藏 2
点赞数 1
分类专栏： 代码文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/han949417140/article/details/120903780
版权

异常拦截 spring boot java

项目中我们是一定要碰到的情况就是无论在控制层，业务层还是Dao层都需要校验一些数据，无论是前端传过来的，还是经过业务处理判断的，如果不合法需要友好的提示给用户，否则用户收到一个NullPointerException这玩意，他可能会很懵逼，再说直接将错误的信息直接暴露给用户，这样的体验也不是太好。通过统一异常拦截，可以手动抛出异常，异常拦截格式化异常返回数据。

一、集成统一异常处理

  • 响应结果统一封装类
package com.hld.free.common;



import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.http.HttpStatus;
import org.springframework.util.StringUtils;

import java.io.Serializable;
@Data
@ApiModel("Http结果响应")
public class HttpResult<T> implements Serializable {

    private static String successMessage = "操作成功";

    private static String errorMessage = "操作失败";

    @ApiModelProperty("响应码")
    private int code;

    @ApiModelProperty("响应数据")
    private T data;

    @ApiModelProperty("响应消息")
    private String msg;

    public HttpResult(){ }

    public HttpResult(int code, String msg) {
        this.code=code;
        this.msg=msg;
    }

    public HttpResult(int code, String msg, T data) {
        this.code=code;
        this.msg=msg;
        this.data=data;
    }

    public static HttpResult successResult() {
        return new HttpResult(HttpStatus.OK.value(), successMessage);
    }

    public static HttpResult successResult(String msg) {
        return new HttpResult(DmStatus.OK.getHttpStatus().value(), defaultSuccessMsg(msg));
    }

    public static HttpResult successResult(Object obj) {
        return new HttpResult(DmStatus.OK.getHttpStatus().value(), successMessage, obj);
    }

    public static HttpResult successResult(String msg, Object obj) {
        return new HttpResult(DmStatus.OK.getHttpStatus().value(), defaultSuccessMsg(msg), obj);
    }

    public static HttpResult failureResult() {
        return new HttpResult(DmStatus.INTERNAL_ERROR.getHttpStatus().value(), errorMessage);
    }

    public static HttpResult failureResult(String msg) {
        return new HttpResult(DmStatus.INTERNAL_ERROR.getHttpStatus().value(), defautlErrorMsg(msg));
    }

    public static HttpResult failureResult(Integer code, String msg) {
        return new HttpResult(code, defautlErrorMsg(msg));
    }

    public static HttpResult failureResult(Integer code, String msg,Object obj) {
        return new HttpResult(code, defautlErrorMsg(msg),obj);
    }

    public static HttpResult failureResult(String msg, Object obj) {
        return new HttpResult(DmStatus.INTERNAL_ERROR.getHttpStatus().value(), defaultSuccessMsg(msg), obj);
    }

    private static String defautlErrorMsg(String msg) {
        return StringUtils.isEmpty(msg)?errorMessage:msg;

    }

    private static String defaultSuccessMsg(String msg) {
        return StringUtils.isEmpty(msg)?successMessage:msg;
    }
}
  • 异常状态信息枚举
package com.hld.free.common;

import java.text.MessageFormat;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;

public enum DmStatus {
    OK(HttpStatus.OK, "DM-200-00000", "数据返回正常"),
    BAD_REQUEST(HttpStatus.BAD_REQUEST, "DM-400-A0001", "{0}"),
    INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "DM-500-B0001", "后台服务异常，请联系管理员!"),
    NO_REGISTER_ERROR(HttpStatus.UNAUTHORIZED, "DM-500-B0001", "账号未注册"),
    NO_BINDING_ERROR(HttpStatus.FORBIDDEN, "DM-500-B0001", "账号未注册"),
    SYS_RUNTIME_ERROR(HttpStatus.REQUEST_TIMEOUT, "DM-400-B0002", "系统运行时异常,请联系管理员!"),
    DATA_OPT_ERROR(HttpStatus.BAD_REQUEST, "DM-400-B0003", "数据操作异常！{0}"),
    TARGET_OBJ_EXCEPTION(HttpStatus.BAD_REQUEST, "DM-400-B0004", "目标对象异常！"),
    GATEWAY_TIMEOUT(HttpStatus.GATEWAY_TIMEOUT, "DM-504-B0100", "网关超时【{0}】"),
    REQUEST_TIMEOUT(HttpStatus.REQUEST_TIMEOUT, "DM-408-B0101", "系统请求超时【{0}】"),
    PARAM_IS_INVALID(HttpStatus.BAD_REQUEST, "DM-400-B0200", "请求参数异常错误！【{0}】"),
    CONSTRAINT_VIOLATION_ERROR(HttpStatus.BAD_REQUEST, "DM-400-B0201", "未绑定对象！【{0}】"),
    SERVLET_REQUEST_BINDING_ERROR(HttpStatus.BAD_REQUEST, "DM-400-B0202", "缺失必要参数！【{0}】"),
    HTTP_METHOD_NOT_ALLOW_ERROR(HttpStatus.METHOD_NOT_ALLOWED, "DM-405-B0203", "HTTP请求方法不被允许【{0}】"),
    HTTP_MEDIA_TYPE_NOT_SUPPORTED_ERROR(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "DM-415-B0203", "不支持的媒体类型"),
    MAX_UPLOAD_SIZE_EXCEEDED(HttpStatus.BAD_REQUEST, "DM-400-B0300", "文件大小超出【{0}】限制, 请压缩或降低文件质量!！"),
    MAX_UPLOAD_TYPE_ERROR(HttpStatus.BAD_REQUEST, "DM-400-B0301", "文件上传类型错误！【{0}】"),
    THIRD_SERVER_ERROR(HttpStatus.BAD_REQUEST, "DM-400-C0001", "调用第三方服务出错"),
    MIDDLE_CALL_ERROR(HttpStatus.BAD_REQUEST, "DM-400-C0100", "中间服务调用出错"),
    MESSAGE_SEND_ERROR(HttpStatus.BAD_REQUEST, "DM-400-C0120", "消息发送失败");

    private static final Logger LOG = LoggerFactory.getLogger(DmStatus.class);
    private final String errorMessage;
    private final String errorCode;
    private final HttpStatus httpStatus;

    private DmStatus(HttpStatus httpStatus, String errorCode, String errorMessage) {
        this.errorMessage = errorMessage;
        this.errorCode = errorCode;
        this.httpStatus = httpStatus;
    }

    public String getFormattedErrorMessage(String... params) {
        if (LOG.isDebugEnabled()) {
            LOG.debug(String.format("<== DmErrorCode.getMessage(%s)", Arrays.toString(params)));
        }

        MessageFormat mf = new MessageFormat(this.errorMessage);
        String result = mf.format(params);
        if (LOG.isDebugEnabled()) {
            LOG.debug(String.format("==> DmErrorCode.getMessage(%s): %s", Arrays.toString(params), result));
        }

        return result;
    }

    public String getErrorMessage() {
        return this.errorMessage;
    }

    public String getErrorCode() {
        return this.errorCode;
    }

    public HttpStatus getHttpStatus() {
        return this.httpStatus;
    }
}
  • 自定义异常处理类
    例如：自定义未注册异常
package com.hld.free.config;


import com.hld.free.common.CommonEnum;
import lombok.Data;

/**
 * @description: 未注册异常
 * @author: hld
 * @create: 2020/10/24 13:09
 * @update: 2020/10/24 13:09
 */
@Data
public class NoRegisterException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * 描述：错误码
     */
    private int errorCode;

    /**
     * 描述：错误信息
     */
    private String errorMsg;

    public NoRegisterException() {
    }

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

    public NoRegisterException(int errorCode, String errorMsg) {
        super(String.valueOf(errorCode));
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

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

}
  • 统一异常拦截
    统一异常拦截主要由@ControllerAdvice 注解实现
package com.hld.free.config;

import com.hld.free.common.DmStatus;
import com.hld.free.common.HttpResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.ServletRequestBindingException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.multipart.MaxUploadSizeExceededException;

import javax.validation.ConstraintViolationException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.List;

/**
 * @description: 统一异常处理
 * @author: fangzhao
 * @create: 2020/3/24 13:09
 * @update: 2020/3/24 13:09
 */
@Slf4j
@RestControllerAdvice
public class GlobalExceptionAdvice {

	 /**
     * 需指定自定义异常处理类
     * @param exception
     * @return
     */
    @ExceptionHandler(NoRegisterException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public HttpResult<Object> sendErrorResponse(NoRegisterException exception){
        log.error("未注册账号异常: {}", getStackTrace(exception));

        return HttpResult.failureResult(exception.getErrorCode(),exception.getErrorMsg());
    }


    /**
     * 系统运行时异常
     * @param exception RuntimeException
     * @return 返回消息
     */
    @ExceptionHandler(RuntimeException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public HttpResult<Object> sendErrorResponse(RuntimeException exception){
        log.error("系统运行时异常: {}", getStackTrace(exception));
        return HttpResult.failureResult(DmStatus.SYS_RUNTIME_ERROR.getHttpStatus().value(),exception.getLocalizedMessage());
    }

    /**
     * 单个参数校验（没有绑定对象）
     * @param e ConstraintViolationException
     * @return 返回的信息
     */
    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public HttpResult<Object> otherValidException(ConstraintViolationException e) {
        log.error("参数校验异常: {}", getStackTrace(e));
        return HttpResult.failureResult(DmStatus.CONSTRAINT_VIOLATION_ERROR.getHttpStatus().value(),e.getLocalizedMessage());
    }

    /**
     * 必填参数缺失
     * @param e ServletRequestBindingException
     * @return 返回的信息
     */
    @ExceptionHandler(ServletRequestBindingException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public HttpResult<Object> servletRequestBinding(ServletRequestBindingException e) {
        log.error("必填参数缺失异常: {}", getStackTrace(e));
        return HttpResult.failureResult(DmStatus.SERVLET_REQUEST_BINDING_ERROR.getHttpStatus().value(),e.getLocalizedMessage());
    }

    /**
     * 参数错误异常
     * @param e 异常参数
     * @return 返回的信息
     */
    @ExceptionHandler({MethodArgumentNotValidException.class, BindException.class})
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public HttpResult<Object> handleException(Exception e) {
        StringBuilder errorMsg = new StringBuilder();
        if (e instanceof MethodArgumentNotValidException) {
            MethodArgumentNotValidException validException = (MethodArgumentNotValidException) e;
            BindingResult result = validException.getBindingResult();
            if (result.hasErrors()) {
                List<ObjectError> errors = result.getAllErrors();
                errors.forEach(p ->{
                    FieldError fieldError = (FieldError) p;
                    errorMsg.append(fieldError.getDefaultMessage()).append(",");
                });
            }
        } else if (e instanceof BindException) {
            BindException bindException = (BindException)e;
            if (bindException.hasErrors()) {
                log.error("请求参数错误: {}", bindException.getAllErrors());
                errorMsg.append(bindException.getAllErrors());
            }
        }
        log.error("参数校验异常: {}", getStackTrace(e));
        return HttpResult.failureResult(DmStatus.PARAM_IS_INVALID.getHttpStatus().value(),errorMsg.toString());
    }

    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    @ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
    public HttpResult<Object> sendErrorResponse(HttpRequestMethodNotSupportedException exception){
        log.error("http方法不允许: {}", getStackTrace(exception));
        return HttpResult.failureResult(DmStatus.HTTP_METHOD_NOT_ALLOW_ERROR.getHttpStatus().value(), Arrays.toString(exception.getSupportedMethods()));
    }
    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
    @ResponseStatus(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
    public HttpResult<Object> sendErrorResponse(HttpMediaTypeNotSupportedException exception){
        return HttpResult.failureResult(DmStatus.HTTP_MEDIA_TYPE_NOT_SUPPORTED_ERROR.getHttpStatus().value(),exception.getLocalizedMessage());
    }

    @ExceptionHandler(MaxUploadSizeExceededException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public HttpResult<Object> sendErrorResponse(MaxUploadSizeExceededException exception){
        return HttpResult.failureResult(DmStatus.MAX_UPLOAD_SIZE_EXCEEDED.getHttpStatus().value(),exception.getLocalizedMessage());
    }

    public static String getStackTrace(Throwable throwable) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw, true);
        throwable.printStackTrace(pw);
        return sw.getBuffer().toString();
    }
}

二、测试统一异常

  • 手动抛出异常
		/**
		  *这里只写出部分使用的代码片段
		  */
		//如果有@IgnoreAuth注解，则不验证token
        if (annotation != null) {
            return true;
        }
        //从header中获取token
        String token = request.getHeader(ShopCommon.TOKEN);
        //token为空
        if (StringUtils.isBlank(token)) {
            throw new NoRegisterException(401,"请先登录");
        }
  • 接口返回示例
    在这里插入图片描述
易佰菜鸟
关注
专栏目录
Springboot自定义异常处理
jonathan的专栏
05-31 2万+
背景Springboot 默认把异常的处理集中到一个ModelAndView中了，但项目的实际过程中，这样做，并不能满足我们的要求。具体的自定义异常的处理，参看以下前提 Springboot 默认的application properties Spring Boot异常处理详解 具体实现如果仔细看完Spring boot的异常处理详解，并且研究过源码后，我觉得具体的实现可以不用看了。。。 重写定义
SpringBoot 自定义异常处理
m0_59485371的博客
01-14 1092
被 @ControllerAdvice 注解的类可以用来实现全局异常处理，这是 Spring MVC 中提供的功能，在 Spring Boot 中可以直接使用。
Springboot 自定义异常处理
weixin_49238911的博客
08-20 1021
Springboot 统一异常处理和自定义异常处理
Spring自定义异常
最新发布
weixin_39459811的博客
07-05 299
errorHtml方法中，跳转到404或500页面具体跳转到哪个文件夹下：分析源码所得：1.先去（前缀/resources）：/META-INF/resources/error/、/resources/error/、/static/error/、/public/error/，按照顺序找404.html。
Spring Boot 自定义异常内容
扛麻袋的少年的博客
04-01 4997
Spring Boot学习笔记(二十一)：在上篇文章：Spring Boot 错误处理机制源码分析，我们已经对 Spring Boot 错误处理机制的源码部分内容进行了详细的讲解，接下来我们来介绍如何自定义我们自己的异常内容提示。 自定义异常，分两种情况来介绍： 1.使用模板引擎：       &...
Spring Boot 自定义异常处理
IceStreamLab
05-25 9431
文章目录自定义异常类，继承RuntimeException全局异常处理响应结果枚举类测试自定义异常处理 自定义异常类，继承RuntimeException /** * 自定制异常类 * * @author MoCha * @date 2019/5/25 */ @Getter public class CustomException extends RuntimeException { ...
详解Springboot自定义异常处理
08-30
Spring Boot提供了一种简单的方法来处理全局异常，但有时我们需要根据项目的具体需求进行自定义异常处理。本文将深入探讨如何在Spring Boot中实现自定义异常处理。 首先，Spring Boot默认的异常处理机制会将所有未...
springboot自定义异常视图过程解析
08-25
Spring Boot自定义异常视图过程解析 Spring Boot框架提供了一个强大的异常处理机制，对于系统中的异常进行捕捉和处理。但是，在实际开发中，我们可能需要自定义自己的异常视图，以便更好地处理和展示异常信息。这...
Springboot之自定义全局异常处理的实现
08-25
Springboot之自定义全局异常处理的实现是指在Springboot框架中，通过自定义异常处理器来捕获和处理全局异常的方法。这种方法可以帮助开发者更好地处理程序中的异常，提高程序的稳定性和可靠性。 为什么需要自定义...
【SpringBoot】实现自定义异常处理
qq_52641681的博客
05-06 965
【SpringBoot】实现自定义异常处理 1. 背景 当用户输入的url不合法时，页面会给出以下提示； Whitelabel Error Page This application has no explicit mapping for /error, so you are seeing this as a fallback. Tue Nov 29 10:48:26 CST 2016 There was an unexpected error (type=Bad Request, status=400
Spring boot自定义异常处理（全局异常处理）
weixin_68481727的博客
09-28 1520
Spring boot自定义异常处理（全局异常处理）
Spring Boot （二十一）——自定义异常处理
云中、漫步的博客
01-10 358
在 Spring Boot 项目中 ，异常统一处理，可以使用 Spring 中 @ControllerAdvice 来统一处理，也可以自己来定义异常处理方案。Spring Boot 中，对异常的处理有一些默认的策略，我们分别来看。 默认情况下，Spring Boot 中的异常页面 是这样的： 我们从这个异常提示中，也能看出来，之所以用户看到这个页面，是因为开发者没有明确提供一个 /error 路...
springboot笔记--自定义异常处理
weixin_47245896的博客
02-16 532
自定义异常的使用 1.首先自定义自己的异常 /** * 自定义异常 * 目的：统一处理异常信息 * 便于解耦，拦截器、service与controller 异常错误的解耦， * 不会被service返回的类型而限制 */ public class MyCustomException extends RuntimeException { private ResponseStatusEnum responseStatusEnum; public MyCustom
springboot 自定义全局异常处理
yssa1125001的博客
05-09 329
首先是统一结果返回： import io.swagger.annotations.ApiModelProperty; import lombok.Data; import java.util.HashMap; import java.util.Map; /** * 统一的返回数据类型 */ @Data public class R { @ApiModelProperty(value = "是否成功") private Boolean success; @ApiModel
SpringBoot实现自定义异常类。
weixin_60414376的博客
02-06 7870
SpringBoot异常类创建与简化返回给前端的异常消息
SpringBoot自定义异常
实习生的博客
10-07 369
阿斯蒂芬
SpringBoot自定义异常处理：静态与动态页面方案解析
"本文将深入探讨SpringBoot中自定义异常处理的方法，包括如何创建静态和动态异常页面，以及SpringBoot的默认异常处理策略。" 在SpringBoot应用中，为了提供更友好的用户体验和增强系统的可维护性，通常需要对异常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值