实现思路：

1.使用@ControllerAdvice和@ExceptionHandler注解 注解@ControllerAdvice表示这是一个控制器增强类，当控制器发生异常且符合类中定义的拦截异常类，将会被拦截。 注解ExceptionHandler定义拦截的异常类 2.使用ErrorController类来实现。 系统默认的错误处理类为BasicErrorController，将会显示如上的错误页面。

一.SpringBoot异常处理配置

1.创建统一返回结果实体

package com.tms.tblog.dto;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.List;

@Data
/***
 * 统一返回结果
 */
@ApiModel(value = "ResultDto对象", description = "统一返回结果实体")
public class ResultDto<T> {
    @ApiModelProperty("消息编码")
    public String code;
    @ApiModelProperty("消息信息")
    public String message;
    @ApiModelProperty("返回对象")
    private T data;
    @ApiModelProperty("返回集合")
    private List<T> List;
    @ApiModelProperty("返回分页总页数")
    private Long total;

    public ResultDto() {
    }

    public ResultDto(String code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }
}

2.异常处理共通的配置类

package com.tms.tblog.infrastructure.exception;

import com.tms.tblog.dto.ResultDto;
import lombok.extern.log4j.Log4j2;
import org.springframework.dao.DataAccessException;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpRequestMethodNotSupportedException;
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.servlet.NoHandlerFoundException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import java.sql.SQLException;
import java.util.stream.Collectors;

/**
 * 异常处理类
 *
 * @author lcj
 */
@ControllerAdvice
@Log4j2
public class ExceptionHandlerEx {

    /**
     * 处理空指针的异常
     *
     * @param req
     * @param ex
     * @return
     */
    @ExceptionHandler(value = NullPointerException.class)
    @ResponseBody
    public ResultDto nullExceptionHandler(HttpServletRequest req, NullPointerException ex) {
        log.error("发生空指针异常！原因是:", ex);
        ResultDto result = new ResultDto("1", ex.getMessage(), null);
        return result;
    }

    /**
     * 处理RuntimeException的异常
     *
     * @param req
     * @param ex
     * @return
     */
    @ExceptionHandler(value = RuntimeException.class)
    @ResponseBody
    public ResultDto runtimeExceptionHandler(HttpServletRequest req, RuntimeException ex) {
        log.error("发生RuntimeException异常:", ex);
        ResultDto result = new ResultDto("1", ex.getMessage(), null);
        return result;
    }

    /**
     * 框架参数校验错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResultDto methodArgumentNotValidExceptionHandler(MethodArgumentNotValidException ex) {
        String message = ex.getBindingResult().getAllErrors().stream().map(ObjectError::getDefaultMessage).collect(Collectors.joining(", "));
        log.error("框架参数校验错误异常:", ex);
        ResultDto result = new ResultDto("1", message, null);
        return result;
    }

    /**
     * 服务器异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({ServletException.class})
    public ResultDto servletExceptionHandler(ServletException ex) {
        log.error("服务器异常:", ex);
        ResultDto result = new ResultDto("1", ex.getMessage(), null);
        return result;
    }

    /**
     * 数据库异常
     *
     * @param ex
     * @return
     */
    @ExceptionHandler({SQLException.class, DataAccessException.class})
    public ResultDto SQLExceptionHandler(SQLException ex) {
        log.error("数据库异常:", ex);
        ResultDto result = new ResultDto("1", ex.getMessage(), null);
        return result;
    }


    /**
     * 接口不存在异常
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(NoHandlerFoundException.class)
    public ResultDto noHandlerFoundExceptionHandler(NoHandlerFoundException ex, HttpServletRequest request) {

        log.error("接口不存在异常:", ex);
        ResultDto result = new ResultDto("1", ex.getMessage(), null);
        return result;
    }

    /**
     * 访问资源错误
     *
     * @param ex
     * @return
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public ResultDto httpRequestMethodNotSupportedExceptionHandler(HttpRequestMethodNotSupportedException ex, HttpServletRequest request) {
        log.error("访问资源错误:", ex);
        ResultDto result = new ResultDto("1", ex.getMessage(), null);
        return result;
    }

    /**
     * 全局异常
     *
     * @param ex
     * @param request
     * @return
     */
    @ExceptionHandler(Exception.class)
    public ResultDto ExceptionHandler(HttpServletRequest request, Throwable ex) {
        log.error("异常:", ex);
        ResultDto result = new ResultDto("1", ex.getMessage(), null);
        return result;
    }

}

3.在控制器中抛出异常 在控制器的方法中抛出异常，统一异常处理类会捕获并处理这些异常。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/test")
    public String test() {
        // 模拟抛出自定义异常
        throw new CustomException("This is a custom exception.");
    }
}

这只是简单的写了异常处理，后期遇到了新的异常没有处理的，陆续添加到这个配置类中，同时可以在抛出异常的时候可以添加发邮件的功能和把报错信息放到资源管理里。由于我们是演示，就不做那么麻烦了。