Spring Boot - 全局异常处理

曾经终败给现在 2023-10-12 15:50 10阅读 0赞

## 状态码封装 ##

package com.lfsun.springbootexceptionhandler.constant;
    
    import lombok.Getter;
    
    /**
     * <p>
     * 状态码封装
     * </p>
     */
    @Getter
    public enum Status {
        
        /**
         * 操作成功
         */
        OK(200, "操作成功"),
    
        /**
         * 未知异常
         */
        UNKNOWN_ERROR(500, "服务器出错啦");
        /**
         * 状态码
         */
        private Integer code;
        /**
         * 内容
         */
        private String message;
    
        Status(Integer code, String message) {
        
            this.code = code;
            this.message = message;
        }
    }

## 异常基类 ##

package com.lfsun.springbootexceptionhandler.exception;
    
    import com.lfsun.springbootexceptionhandler.constant.Status;
    import lombok.Data;
    import lombok.EqualsAndHashCode;
    
    /**
     * <p>
     * 异常基类
     * </p>
     */
    @Data
    @EqualsAndHashCode(callSuper = true)
    // 当一个类继承自另一个类，并且需要在子类中生成equals()和hashCode()方法时，可以使用@EqualsAndHashCode(callSuper = true)注解。
    // 该注解会自动调用父类的equals()和hashCode()方法，以确保父类属性的比较也包含在内。
    public class BaseException extends RuntimeException {
        
        private Integer code;
        private String message;
    
        public BaseException(Status status) {
        
            super(status.getMessage());
            this.code = status.getCode();
            this.message = status.getMessage();
        }
    
        public BaseException(Integer code, String message) {
        
            super(message);
            this.code = code;
            this.message = message;
        }
    }

## json异常 ##

package com.lfsun.springbootexceptionhandler.exception;
    
    import com.lfsun.springbootexceptionhandler.constant.Status;
    import lombok.Getter;
    
    /**
     * <p>
     * JSON异常
     * </p>
     */
    @Getter
    public class JsonException extends BaseException {
        
    
        public JsonException(Status status) {
        
            super(status);
        }
    
        public JsonException(Integer code, String message) {
        
            super(code, message);
        }
    }

## 页面异常 ##

package com.lfsun.springbootexceptionhandler.exception;
    
    import com.lfsun.springbootexceptionhandler.constant.Status;
    import lombok.Getter;
    
    /**
     * <p>
     * 页面异常
     * </p>
     */
    @Getter
    public class PageException extends BaseException {
        
    
        public PageException(Status status) {
        
            super(status);
        }
    
        public PageException(Integer code, String message) {
        
            super(code, message);
        }
    }

## 通用的API接口封装 ##

package com.lfsun.springbootexceptionhandler.model;
    
    import com.lfsun.springbootexceptionhandler.constant.Status;
    import com.lfsun.springbootexceptionhandler.exception.BaseException;
    import lombok.Data;
    
    /**
     * <p>
     * 通用的 API 接口封装
     * </p>
     */
    @Data
    public class ApiResponse {
        
        /**
         * 状态码
         */
        private Integer code;
    
        /**
         * 返回内容
         */
        private String message;
    
        /**
         * 返回数据
         */
        private Object data;
    
        /**
         * 无参构造函数
         */
        private ApiResponse() {
        
    
        }
    
        /**
         * 全参构造函数
         *
         * @param code    状态码
         * @param message 返回内容
         * @param data    返回数据
         */
        private ApiResponse(Integer code, String message, Object data) {
        
            this.code = code;
            this.message = message;
            this.data = data;
        }
    
        /**
         * 构造一个自定义的API返回
         *
         * @param code    状态码
         * @param message 返回内容
         * @param data    返回数据
         * @return ApiResponse
         */
        public static ApiResponse of(Integer code, String message, Object data) {
        
            return new ApiResponse(code, message, data);
        }
    
        /**
         * 构造一个成功且带数据的API返回
         *
         * @param data 返回数据
         * @return ApiResponse
         */
        public static ApiResponse ofSuccess(Object data) {
        
            return ofStatus(Status.OK, data);
        }
    
        /**
         * 构造一个成功且自定义消息的API返回
         *
         * @param message 返回内容
         * @return ApiResponse
         */
        public static ApiResponse ofMessage(String message) {
        
            return of(Status.OK.getCode(), message, null);
        }
    
        /**
         * 构造一个有状态的API返回
         *
         * @param status 状态 {
        @link Status}
         * @return ApiResponse
         */
        public static ApiResponse ofStatus(Status status) {
        
            return ofStatus(status, null);
        }
    
        /**
         * 构造一个有状态且带数据的API返回
         *
         * @param status 状态 {
        @link Status}
         * @param data   返回数据
         * @return ApiResponse
         */
        public static ApiResponse ofStatus(Status status, Object data) {
        
            return of(status.getCode(), status.getMessage(), data);
        }
    
        /**
         * 构造一个异常且带数据的API返回
         *
         * @param t    异常
         * @param data 返回数据
         * @param <T>  {
        @link BaseException} 的子类
         * @return ApiResponse
         */
        public static <T extends BaseException> ApiResponse ofException(T t, Object data) {
        
            return of(t.getCode(), t.getMessage(), data);
        }
    
        /**
         * 构造一个异常且带数据的API返回
         *
         * @param t   异常
         * @param <T> {
        @link BaseException} 的子类
         * @return ApiResponse
         */
        public static <T extends BaseException> ApiResponse ofException(T t) {
        
            return ofException(t, null);
        }
    }

## 统一异常处理 ##

package com.lfsun.springbootexceptionhandler.handler;
    
    
    import com.lfsun.springbootexceptionhandler.exception.JsonException;
    import com.lfsun.springbootexceptionhandler.exception.PageException;
    import com.lfsun.springbootexceptionhandler.model.ApiResponse;
    import lombok.extern.slf4j.Slf4j;
    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.servlet.ModelAndView;
    
    /**
     * <p>
     * 统一异常处理
     * </p>
     */
    @ControllerAdvice
    @Slf4j
    public class DemoExceptionHandler {
        
        private static final String DEFAULT_ERROR_VIEW = "error";
    
        /**
         * 统一 json 异常处理
         *
         * @param exception JsonException
         * @return 统一返回 json 格式
         */
        @ExceptionHandler(value = JsonException.class)
        @ResponseBody
        public ApiResponse jsonErrorHandler(JsonException exception) {
        
            log.error("【JsonException】:{}", exception.getMessage());
            return ApiResponse.ofException(exception);
        }
    
        /**
         * 统一 页面 异常处理
         *
         * @param exception PageException
         * @return 统一跳转到异常页面
         */
        @ExceptionHandler(value = PageException.class)
        public ModelAndView pageErrorHandler(PageException exception) {
        
            log.error("【DemoPageException】:{}", exception.getMessage());
            ModelAndView view = new ModelAndView();
            view.addObject("message", exception.getMessage());
            view.setViewName(DEFAULT_ERROR_VIEW);
            return view;
        }
    }

## controller ##

package com.lfsun.springbootexceptionhandler.controller;
    
    
    import com.lfsun.springbootexceptionhandler.constant.Status;
    import com.lfsun.springbootexceptionhandler.exception.JsonException;
    import com.lfsun.springbootexceptionhandler.exception.PageException;
    import com.lfsun.springbootexceptionhandler.model.ApiResponse;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.ModelAndView;
    
    
    /**
     * <p>
     * 测试Controller
     * </p>
     */
    @Controller
    public class TestController {
        
    
        @GetMapping("/json")
        @ResponseBody
        public ApiResponse jsonException() {
        
            throw new JsonException(Status.UNKNOWN_ERROR);
        }
    
        @GetMapping("/page")
        public ModelAndView pageException() {
        
            throw new PageException(Status.UNKNOWN_ERROR);
        }
    }

## templates/error.html ##

<!DOCTYPE html>
    <html xmlns:th="http://www.thymeleaf.org">
    <head lang="en">
    	<meta charset="UTF-8"/>
    	<title>统一页面异常处理</title>
    </head>
    <body>
    <h1>统一页面异常处理</h1>
    <div th:text="${message}"></div>
    </body>
    </html>

## application.yml ##

server:
      port: 8080
      servlet:
        context-path: /
    spring:
      thymeleaf:
        cache: false
        mode: HTML
        encoding: UTF-8
        servlet:
          content-type: text/html

## 完整代码地址 ##

https://gitee.com/lfsun666/springboot-study-2023/tree/master/spring-boot-exception-handler