全局异常处理使用

已于 2022-03-24 16:34:27 修改
阅读量462 收藏
点赞数 1
文章标签： exception java
于 2021-12-23 13:16:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44696435/article/details/122104809
版权

通用异常处理总结

一：创建通用处理异常

package com.example.demo01.utils;

/**
 * @description:
 * @projectName: zklt
 * @see: com.example.demo01.utils
 * @author: WIG
 * @createTime: 2021/12/20 10:48
 */
public class CommonException extends RuntimeException {

    private final String errorCode;
    private final String errorMessage;

    public CommonException(String errorCode, String errorMessage) {
        super(errorMessage);
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }

    public CommonException(String errorCode, String errorMessage, Throwable throwable) {
        super(throwable);
        this.errorCode = errorCode;
        this.errorMessage = errorMessage;
    }

    @Override
    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof CommonException)) {
            return false;
        } else {
            CommonException other = (CommonException) o;
            if (!other.canEqual(this)) {
                return false;
            } else if (!super.equals(o)) {
                return false;
            } else {
                if (this.getErrorCode() == null) {
                    if (other.getErrorCode() != null) {
                        return false;
                    }
                } else if (!this.getErrorCode().equals(other.getErrorCode())) {
                    return false;
                }

                if (this.getErrorMessage() == null) {
                    if (other.getErrorMessage() != null) {
                        return false;
                    }
                } else if (!this.getErrorMessage().equals(other.getErrorMessage())) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(final Object other) {
        return other instanceof CommonException;
    }

    @Override
    public int hashCode() {
        boolean prime = true;
        int result = super.hashCode();
        result = result * 59 + (this.getErrorCode() == null ? 43 : this.getErrorCode().hashCode());
        result = result * 59 + (this.getErrorMessage() == null ? 43 : this.getErrorMessage().hashCode());
        return result;
    }

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

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

    @Override
    public String toString() {
        return "CommonException(errorCode=" + this.getErrorCode() + ", errorMessage=" + this.getErrorMessage() + ")";
    }
}

二：通用请求异常处理

package com.example.demo01.utils;

import org.springframework.http.HttpStatus;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.yaml.snakeyaml.constructor.DuplicateKeyException;

import javax.validation.ConstraintViolationException;
import java.util.Iterator;
import java.util.Objects;

/**
 * @description:
 * @projectName: zklt
 * @see: com.example.demo01.utils
 * @author: WIG
 * @createTime: 2021/12/20 10:46
 */
public class GlobalExceptionAdvice {
    public GlobalExceptionAdvice() {
    }

    @ExceptionHandler({CommonException.class})
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public Result ftbExceptionHandler(CommonException exception) {
        return ResultUtils.fail(exception.getErrorCode(), exception.getErrorMessage());
    }

    @ExceptionHandler({RuntimeException.class})
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ResponseBody
    public Result runtimeExceptionHandler(RuntimeException exception) {
        exception.printStackTrace();
        return ResultUtils.fail(exception.getMessage());
    }

    @ExceptionHandler({HttpMessageNotReadableException.class})
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ResponseBody
    public Result httpMessageNotReadableExceptionHandler(HttpMessageNotReadableException exception) {
        exception.printStackTrace();
        return ResultUtils.fail(exception.getMessage());
    }

    @ExceptionHandler({ConstraintViolationException.class})
    @ResponseBody
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public Result constraintViolationExceptionHandler(ConstraintViolationException exception) {
        exception.printStackTrace();
        return ResultUtils.fail(exception.getMessage());
    }

    @ExceptionHandler({MethodArgumentTypeMismatchException.class})
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ResponseBody
    public Result methodArgumentTypeMismatchExceptionHandler(MethodArgumentTypeMismatchException exception) {
        exception.printStackTrace();
        return ResultUtils.fail(exception.getMessage());
    }

    @ExceptionHandler({DuplicateKeyException.class})
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ResponseBody
    public Result duplicateKeyExceptionHandler(DuplicateKeyException exception) {
        exception.printStackTrace();
        return ResultUtils.fail(exception.getMessage());
    }

    @ExceptionHandler({MethodArgumentNotValidException.class})
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ResponseBody
    public Result methodArgumentNotValidExceptionHandler(MethodArgumentNotValidException exception) {
        exception.printStackTrace();
        String message = "传入参数异常";
        BindingResult result = exception.getBindingResult();
        if (Objects.nonNull(result) && result.hasErrors()) {
            Iterator var4 = result.getAllErrors().iterator();
            if (var4.hasNext()) {
                ObjectError error = (ObjectError) var4.next();
                message = error.getDefaultMessage();
            }
        }

        return ResultUtils.fail(message);
    }
}

三：通用异常处理

package com.example.demo01.utils;

import com.example.demo01.enums.ErrorExceptionEnums;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.support.DefaultMessageSourceResolvable;
import org.springframework.validation.BindException;
import org.springframework.web.bind.MethodArgumentNotValidException;
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.bind.annotation.RestControllerAdvice;

import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import java.util.stream.Collectors;

/**
 * @description: 通用异常处理
 * @projectName: zklt
 * @see: com.example.demo01.utils
 * @author: WIG
 * @createTime: 2021/12/20 10:43
 */
@Slf4j
@ControllerAdvice
@RestControllerAdvice
public class ExceptionAdvice extends GlobalExceptionAdvice {

    @ExceptionHandler({Exception.class})
    @ResponseBody
    public Result<String> exceptionHandler(Exception exception) {
        log.error("#exceptionHandler", exception);
        return ResultUtils.fail(exception.getMessage());
    }

    @ExceptionHandler({Throwable.class})
    @ResponseBody
    public Result<String> handleExceptionGlobal(Throwable ex) {
        Result<String> result = ResultUtils
                .fail(ErrorExceptionEnums.SERVICE_INTERNAL_ERROR.getErrorCode(), ex.getMessage());
        log.error("#handleExceptionGlobal ====> result:{}", result, ex);
        return result;
    }

    /**
     * 处理Get请求中 使用@Valid 验证路径中请求实体校验失败后抛出的异常，详情继续往下看代码
     */
    @ExceptionHandler(BindException.class)
    @ResponseBody
    public Result<Object> bindExceptionHandler(BindException ex) {
        String message = ex.getBindingResult().getAllErrors().stream()
                .map(DefaultMessageSourceResolvable::getDefaultMessage).collect(
                        Collectors.joining());
        Result<Object> result = ResultUtils
                .fail(ErrorExceptionEnums.SERVICE_INTERNAL_ERROR.getErrorCode(), message);
        log.error("#bindExceptionHandler ====> result:{}", result, ex);
        return result;
    }

    /**
     * 处理请求参数格式错误 @RequestParam上validate失败后抛出的异常是javax.validation.ConstraintViolationException
     */
    @Override
    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseBody
    public Result<Object> constraintViolationExceptionHandler(ConstraintViolationException ex) {
        String message = ex.getConstraintViolations().stream().map(ConstraintViolation::getMessage)
                .collect(Collectors.joining());
        String messageResult = message;
        Result<Object> result = ResultUtils
                .fail(ErrorExceptionEnums.SERVICE_INTERNAL_ERROR.getErrorCode(), messageResult);
        log.error("#constraintViolationExceptionHandler ====> result:{}", result, ex);
        return result;
    }

    /**
     * 处理请求参数格式错误 @RequestBody上validate失败后抛出的异常是MethodArgumentNotValidException异常。
     */
    @Override
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public Result<Object> methodArgumentNotValidExceptionHandler(
            MethodArgumentNotValidException ex) {
        String message = ex.getBindingResult().getAllErrors().stream()
                .map(DefaultMessageSourceResolvable::getDefaultMessage).collect(Collectors.joining());
        Result<Object> result = ResultUtils
                .fail(ErrorExceptionEnums.SERVICE_INTERNAL_ERROR.getErrorCode(), message);
        log.error("#methodArgumentNotValidExceptionHandler ====> result:{}", result, ex);
        return result;
    }

    /**
     * 该方法是防止多层校验出现message重复问题  （现在不加）
     * @param str 错误信息
     * @return str
     */
    private String deleteSameString(String str) {
        StringBuilder stringBuffer = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            if (str.indexOf(str.charAt(i)) == i) {
                stringBuffer.append(str.charAt(i));
            }
        }
        return stringBuffer.toString();
    }

}

&所需依赖的公共类

result

package com.example.demo01.utils;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

import java.io.Serializable;
import java.util.UUID;

/**
 * @description:
 * @projectName: cloud-wig-user
 * @see: com.example.demo01
 * @author: WIG
 * @createTime: 2021/12/14 16:02
 */
@ApiModel("API统一返回数据封装类")
@JsonIgnoreProperties(
        ignoreUnknown = true
)
public class Result<T> implements Serializable {

    public static final String SUCCEED = " SUCCEED ";
    public static final String FAILED = " FAILED ";
    @ApiModelProperty("返回状态:SUCCEED和FAILED")
    private String returnStatus;
    @ApiModelProperty("时间戳")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Long serverTime;
    @ApiModelProperty("请求ID")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String requestId;
    @ApiModelProperty("错误码")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String errorCode;
    @ApiModelProperty("错误信息")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String errorMessage;
    @ApiModelProperty("错误扩展信息")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Object extMessage;
    @ApiModelProperty("封装数据")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private T data;

    public static <T> Result<T> fail(String errCode, String errMsg) {
        Result<T> result = buildBasic("FAILED");
        result.setErrorCode(errCode);
        result.setErrorMessage(errMsg);
        return result;
    }

    public static <T> Result<T> success(T data) {
        Result<T> result = success();
        result.setData(data);
        return result;
    }

    public static <T> Result<T> success() {
        Result<T> result = buildBasic("SUCCEED");
        return result;
    }

    private static <T> Result<T> buildBasic(String status) {
        Result<T> result = new Result();
        result.setReturnStatus(status);
        result.setServerTime(System.currentTimeMillis());
        result.setRequestId(createRequestId());
        return result;
    }

    protected static String createRequestId() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }

    public String getReturnStatus() {
        return this.returnStatus;
    }

    public Long getServerTime() {
        return this.serverTime;
    }

    public String getRequestId() {
        return this.requestId;
    }

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

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

    public Object getExtMessage() {
        return this.extMessage;
    }

    public T getData() {
        return this.data;
    }

    public void setReturnStatus(final String returnStatus) {
        this.returnStatus = returnStatus;
    }

    public void setServerTime(final Long serverTime) {
        this.serverTime = serverTime;
    }

    public void setRequestId(final String requestId) {
        this.requestId = requestId;
    }

    public void setErrorCode(final String errorCode) {
        this.errorCode = errorCode;
    }

    public void setErrorMessage(final String errorMessage) {
        this.errorMessage = errorMessage;
    }

    public void setExtMessage(final Object extMessage) {
        this.extMessage = extMessage;
    }

    public void setData(final T data) {
        this.data = data;
    }

    @Override
    public boolean equals(final Object object) {
        if (object == this) {
            return true;
        } else if (!(object instanceof Result)) {
            return false;
        } else {
            Result<?> other = (Result) object;
            if (!other.canEqual(this)) {
                return false;
            } else {
                label95: {
                    if (this.getServerTime() == null) {
                        if (other.getServerTime() == null) {
                            break label95;
                        }
                    } else if (this.getServerTime().equals(other.getServerTime())) {
                        break label95;
                    }

                    return false;
                }

                if (this.getReturnStatus() == null) {
                    if (other.getReturnStatus() != null) {
                        return false;
                    }
                } else if (!this.getReturnStatus().equals(other.getReturnStatus())) {
                    return false;
                }

                if (this.getRequestId() == null) {
                    if (other.getRequestId() != null) {
                        return false;
                    }
                } else if (!this.getRequestId().equals(other.getRequestId())) {
                    return false;
                }

                label74: {
                    if (this.getErrorCode() == null) {
                        if (other.getErrorCode() == null) {
                            break label74;
                        }
                    } else if (this.getErrorCode().equals(other.getErrorCode())) {
                        break label74;
                    }

                    return false;
                }

                label67: {
                    if (this.getErrorMessage() == null) {
                        if (other.getErrorMessage() == null) {
                            break label67;
                        }
                    } else if (this.getErrorMessage().equals(other.getErrorMessage())) {
                        break label67;
                    }

                    return false;
                }

                if (this.getExtMessage() == null) {
                    if (other.getExtMessage() != null) {
                        return false;
                    }
                } else if (!this.getExtMessage().equals(other.getExtMessage())) {
                    return false;
                }

                if (this.getData() == null) {
                    if (other.getData() != null) {
                        return false;
                    }
                } else if (!this.getData().equals(other.getData())) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(final Object other) {
        return other instanceof Result;
    }

    @Override
    public int hashCode() {
        int result =  59 + (this.getServerTime() == null ? 43 : this.getServerTime().hashCode());
        result = result * 59 + (this.getReturnStatus() == null ? 43 : this.getReturnStatus().hashCode());
        result = result * 59 + (this.getRequestId() == null ? 43 : this.getRequestId().hashCode());
        result = result * 59 + (this.getErrorCode() == null ? 43 : this.getErrorCode().hashCode());
        result = result * 59 + (this.getErrorMessage() == null ? 43 : this.getErrorMessage().hashCode());
        result = result * 59 + (this.getExtMessage() == null ? 43 : this.getExtMessage().hashCode());
        result = result * 59 + (this.getData() == null ? 43 : this.getData().hashCode());
        return result;
    }

    @Override
    public String toString() {
        return "Result(returnStatus=" + this.getReturnStatus() + ", serverTime=" + this.getServerTime() + ", requestId=" + this.getRequestId() + ", errorCode=" + this.getErrorCode() + ", errorMessage=" + this.getErrorMessage() + ", extMessage=" + this.getExtMessage() + ", data=" + this.getData() + ")";
    }

    public Result() {
    }

}

resultUtils

package com.example.demo01.utils;

import java.util.Objects;

/**
 * @description:
 * @projectName: zklt
 * @see: com.example.demo01.utils
 * @author: WIG
 * @createTime: 2021/12/20 11:10
 */
public final class ResultUtils {
    private ResultUtils() {
    }

    public static <T> Result<T> success() {
        return Result.success();
    }

    public static <T> Result<T> success(T data) {
        return Result.success(data);
    }

    public static <T> PageResult<T> success(T data, Integer totalCount) {
        return PageResult.success(data, totalCount, (Integer) null, (Integer) null);
    }

    public static <T> PageResult<T> success(T data, Integer totalCount, Integer pageNo, Integer pageSize) {
        return PageResult.success(data, totalCount, pageNo, pageSize);
    }

    public static <T> Result<T> fail(IError error) {
        return fail(error.getErrorCode(), error.getErrorMessage());
    }

    public static <T> Result<T> fail(String errorMessage) {
        return fail("", errorMessage);
    }

    public static <T> Result<T> fail(IError error, Object extMessage) {
        Result result = fail(error.getErrorCode(), error.getErrorMessage());
        result.setExtMessage(extMessage);
        return result;
    }

    public static <T> Result<T> fail(String errorCode, String errorMessage) {
        return Result.fail(errorCode, errorMessage);
    }

    public static void checkResult(Result result, IError errorCodeEnum) {
        if (Objects.isNull(result)) {
            throw ExceptionUtils.getException(errorCodeEnum);
        } else if (isFailed(result)) {
            throw ExceptionUtils.getException(errorCodeEnum.getErrorCode(), errorCodeEnum.getErrorMessage() + result.getErrorMessage());
        }
    }

    public static boolean isSuccess(Result result) {
        return "SUCCEED".equals(result.getReturnStatus());
    }

    public static boolean isFailed(Result result) {
        return "FAILED".equals(result.getReturnStatus());
    }
}

pageResult

package com.example.demo01.utils;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * @description:
 * @projectName: zklt
 * @see: com.example.demo01.utils
 * @author: WIG
 * @createTime: 2021/12/20 11:11
 */
@ApiModel("带分页的响应体封装类")
@JsonIgnoreProperties(
        ignoreUnknown = true
)
public class PageResult<T> extends Result<T> {
    @ApiModelProperty("总共条数")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Integer totalCount;
    @ApiModelProperty("页数")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Integer pageNo;
    @ApiModelProperty("本页条数")
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private Integer pageSize;

    public static <T> PageResult<T> success(T data, Integer totalCount, Integer pageNo, Integer pageSize) {
        PageResult<T> result = buildBasic("SUCCEED");
        result.setData(data);
        result.setTotalCount(totalCount);
        result.setPageNo(pageNo);
        result.setPageSize(pageSize);
        return result;
    }

    private static <T> PageResult<T> buildBasic(String status) {
        PageResult<T> result = new PageResult();
        result.setReturnStatus(status);
        result.setServerTime(System.currentTimeMillis());
        result.setRequestId(createRequestId());
        return result;
    }

    public Integer getTotalCount() {
        return this.totalCount;
    }

    public Integer getPageNo() {
        return this.pageNo;
    }

    public Integer getPageSize() {
        return this.pageSize;
    }

    public void setTotalCount(final Integer totalCount) {
        this.totalCount = totalCount;
    }

    public void setPageNo(final Integer pageNo) {
        this.pageNo = pageNo;
    }

    public void setPageSize(final Integer pageSize) {
        this.pageSize = pageSize;
    }

    @Override
    public boolean equals(final Object object) {
        if (object == this) {
            return true;
        } else if (!(object instanceof PageResult)) {
            return false;
        } else {
            PageResult<?> other = (PageResult) object;
            if (!other.canEqual(this)) {
                return false;
            } else {
                label47: {
                    if (this.getTotalCount() == null) {
                        if (other.getTotalCount() == null) {
                            break label47;
                        }
                    } else if (this.getTotalCount().equals(other.getTotalCount())) {
                        break label47;
                    }

                    return false;
                }

                if (this.getPageNo() == null) {
                    if (other.getPageNo() != null) {
                        return false;
                    }
                } else if (!this.getPageNo().equals(other.getPageNo())) {
                    return false;
                }

                if (this.getPageSize() == null) {
                    if (other.getPageSize() != null) {
                        return false;
                    }
                } else if (!this.getPageSize().equals(other.getPageSize())) {
                    return false;
                }

                return true;
            }
        }
    }

    @Override
    protected boolean canEqual(final Object other) {
        return other instanceof PageResult;
    }

    @Override
    public int hashCode() {
        int result = 59 + (this.getTotalCount() == null ? 43 : this.getTotalCount().hashCode());
        result = result * 59 + (this.getPageNo() == null ? 43 : this.getPageNo().hashCode());
        result = result * 59 + (this.getPageSize() == null ? 43 : this.getPageSize().hashCode());
        return result;
    }

    @Override
    public String toString() {
        return "PageResult(totalCount=" + this.getTotalCount() + ", pageNo=" + this.getPageNo() + ", pageSize=" + this.getPageSize() + ")";
    }

    public PageResult() {
    }
}

errorExceptionEnums

package com.example.demo01.enums;

import com.example.demo01.utils.IError;
import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * @description:
 * @projectName: zklt
 * @see: com.example.demo01.enums
 * @author: WIG
 * @createTime: 2021/12/15 10:37
 */


@Getter
@AllArgsConstructor
public enum ErrorExceptionEnums implements IError {

    SERVICE_INTERNAL_ERROR("000001", "服务内部错误");
    private final String errorCode;
    private final String errorMessage;


}

ierror

  •  * package com.example.demo01.utils;

   /**

    * @description:

  * @projectName: zklt

  * @see: com.example.demo01.utils

  * @author: WIG

  * @createTime: 2021/12/15 11:03
    */
    public interface IError {
    String getErrorCode();

    String getErrorMessage();
    }
止初
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot全局异常处理_全局异常处理教程
weixin_39980002的博客
12-05 780
全局异常处理教程一.SpringBoot全局异常处理方式正常的Web应用开发时,需要考虑到应用运行发生异常时或出现错误时如何来被处理,例如捕获必要的异常信息,记录日志方便日后排错,友好的用户响应输出等等.而应用程序发生错误,有可能是应用自身的问题,也有可能是客户端操作的问题.在我们的项目中全局异常处理非常重要.大概有三种异常情况：1️⃣.在进入Controller之前,譬如请求一个不存在的地址40...
springboot全局异常处理代码实例
08-25
主要介绍了springboot全局异常处理代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
@SpringBoot异常处理-@ControllerAdvice+@ExceptionHandler 注解处理异常
Huyongli199588的博客
10-18 552
@SpringBoot异常处理-@ControllerAdvice+@ExceptionHandler 注解处理异常 版权声明：本文为CSDN博主「爱吃西瓜的小松鼠」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_40979622/article/details/83188701 @Controller...
全局异常捕获的使用方法
最新发布
qq_45664048的博客
03-03 608
全局异常捕获器
SpringBoot学习笔记之实现全局异常处理
编程火箭车（Coding Rocket）专注编程领域
04-19 1772
在项目开发中会处理各种类型的异常，那么实现全局统一异常处理是十分必要的。/error，当抛出异常之后，会转到该请求处理。在实际应用中，并不是很符合项目要求。网上 SpringBoot 实现全局异常处理的资料有很多，但也不能拿来就用，需要结合自身项目做些改动。这里就记录一下结合网上众多资料实现自己项目的全局异常处理实践过程。一个问题的解决方案有千万种，选择适合自己的。解决问题的资料不能单纯的拿来就用，改改为己所用。办法总比困难多，加油，菜鸟。
项目终于遇到的问题(二)系统中的异常该如何处理
qq_44620773的博客
04-02 1166
现在有两种解决思路。 及时解决 使用Result.fail() 返回异常 异常全部抛出，使用统一拦截类拦截拿到异常，读取错误码及其其他信息，返回。 这里来探讨一下第二种方式。 我们可以将异常信息放在数据库中，我们取到数据放到全局（statis）map中，当有新增错误码时，可以通过mq获取到变化的错误码，并更新mq 声明一个异常类（进程RuntimeException），类里有错误码，错误信息，错误描述 遇到异常或错误信息，将错误码（一般放在枚举中）放在异常类中抛出 全局拦截类拦截到后，通过错误码.
微服务下全局异常处理方案
12-21
2、自定义全局异常类BaseException package com.jhjcn.common.base.exception; /** * @Deacription TODO * @Author jianhua.hong * @Date 2020/2/25 9:56 **/ public class BaseException extends ...
springboot 常用配置，模板引擎，全局异常处理使用代码
09-27
springBoot 全局的异常处理；springboot常用的属性配置；Spring Boot 使用thymeleaf；Spring Boot 使用freemarker
springboot 全局异常处理
11-29
springboot 全局异常处理.捕捉全局异常,转换格式,以友好方式提示客户正确的操作步骤. 避免系统错误出现在用户勉强,造成不良使用体验.
Spring Cloud Gateway的全局异常处理
11-26
Spring Cloud Gateway的全局异常处理 Spring Cloud Gateway中的全局异常处理不能直接用@ControllerAdvice来处理，通过跟踪异常信息的抛出，找到对应的源码，自定义一些处理逻辑来符合业务的需求。 网关都是给接口做...
SpringBoot全局处理系列--全局异常处理
IT利刃出鞘的博客
06-11 3176
本文用实例介绍SpringBoot如何进行全局异常处理。
全局异常处理
weixin_43732943的博客
12-05 185
软件开发过程中不可避免的需要处理各种异常，代码中会出现大量的 代码块，不仅有大量的冗余代码，而且还影响代码的可读性。Spring从3.2版本开始增加了一个注解，可以与、、 等注解配套使用，可以统一进行异常处理。1，创建maven工程exceptionHandler_demo并配置pom.xml文件 2，编写UserController 3，创建application.yml 4，创建启动类 5，启动项目，访问地址：http://localhost:9000/user/get 可以看到异常信息直接显示到了页面
Springboot全局异常处理
程序三两行
11-26 3545
springboot默认发生4xx错误时候，pc端响应的页面如下如果是移动端（手机端）将会响应json格式的数据，如下。
Springboot 全局异常处理
陈皮的JavaLib
02-06 4489
关注微信公众号【Java之言】，更多干货文章和学习资料，助你放弃编程之路！ 文章目录一、为何要处理全局异常?二、开发环境三、添加依赖四、自定义异常错误类4.1 自定义异常基础接口类4.2 通用异常信息枚举类4.3 业务异常信息枚举类4.4 自定义业务异常类五、接口返回统一格式六、全局异常处理七、测试7.1 辅助类7.2 测试结果 一、为何要处理全局异常? 在平常项目开发过程中，程序难免会出现运行时异常，或者业务异常。难道要针对每一处可能出现的异常进行编写代码进行处理？或者直接不处理异常，将一大屏堆.
全局异常处理解决方案
远处
07-21 3545
背景： 在项目开发中，习惯去设计一些自定义的异常类来处理各层的异常。比如： DAO层会有对应的DAOException.java Service层有对应的ServiceException.java Controller层有对应的ControllerException.java 当程序遇到不可忽视的错误时，会直接throw出这些异常，这就意味着需要一种全局异常处理机制来对这些异常进行统一管理（比如：返回给用户一个错误页面） 一、过滤器实现全局异常处理 这里采用的是注解@WebFilter方式添加的过滤
@ControllerAdvice 和 @ExceptionHandler注解处理全局异常
热门推荐
何哥的博客
11-26 1万+
前言：@ControllerAdvice ，很多初学者可能都没有听说过这个注解，实际上，这是一个非常有用的解，顾名思义，这是一个增强的 Controller。一般配合@ExceptionHandler使用来处理全局异常。 一、@ControllerAdvice @ControllerAdvice 是Spring 3.2提供的新注解,他是一个controller增强器，可以对controller中使用到@RequestMapping注解的方法做逻辑处理。 使用这个注解 ，可以实现三个方面的功能：
实现全局异常处理
imVainiycos的博客
10-24 2645
通常，我们除了描述jdk默认的异常之外，还会自定义契合业务主体本身的业务异常。} }/*** 自定义异常return AjaxResult . error("自定义异常被捕获");}实际场景中，我们为了方便管理异常情况，通常会定义一个异常结果枚举类，然后自定义异常只需要传入对应枚举类参数即可。接下来提供一套完整的实战环境下的异常处理以供参考，首先定义一套参考的枚举类（参考自GitHub仓库-miaosha：https://github.com/qiurunze123/miaosha）
全局异常处理教程
qfchenjunbo的博客
09-02 801
全局异常处理教程 一.SpringBoot全局异常处理方式 正常的Web应用开发时,需要考虑到应用运行发生异常时或出现错误时如何来被处理,例如捕获必要的异常信息,记录日志方便日后排错,友好的用户响应输出等等.而应用程序发生错误,有可能是应用自身的问题,也有可能是客户端操作的问题.在我们的项目中全局异常处理非常重要. 大概有三种异常情况： 1️⃣.在进入Controller之前,譬如请求一个不存在的地址404错误; 2️⃣.在执行@RequestMapping时,进入逻辑处理阶段前,譬如传的参数类型错
SpringBoot 全局异常处理用法及原理
Java的一只小实习生的博客
02-11 958
全局异常处理用法及原理

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值