如果出现无法拦截问题，需要在配置文件中添加如下配置

第一步：修改配置文件 application.yml 添加配置如下

spring:
  resources:
    add-mappings: false

第二步：修改 DispatcherServlet

DispatcherServlet 的 throwExceptionIfNoHandlerFound 默认是 false 修改为true，这里利用的是 spring后置处理器，对 DispatcherServlet进行修改

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.DispatcherServlet;

@Configuration
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof DispatcherServlet){
            System.out.println(bean);
            DispatcherServlet dispatcherServlet = (DispatcherServlet)bean;
            dispatcherServlet.setThrowExceptionIfNoHandlerFound(true);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

第三步：统一异常类配置 GlobalDefaultExceptionHandler

import com.fdas.openplat.common.enums.ResultCode;
import lombok.extern.slf4j.Slf4j;
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.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
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.bind.annotation.RestControllerAdvice;
import org.springframework.web.client.ResourceAccessException;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.servlet.NoHandlerFoundException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.net.ConnectException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @desc: 异常统一拦截处理
 * @auth: zhanghy
 * @data: 2019/9/3 13:30
 */
@RestControllerAdvice
@ResponseBody
@Slf4j
public class GlobalDefaultExceptionHandler {

    /**
     * @auth: zhanghy
     * @desc: 服务不存在
     * @data: 2019/9/3 13:31
     * @return: 异常信息
     */
    @ExceptionHandler(value = NoHandlerFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public Map errorHandler(HttpServletRequest request, NoHandlerFoundException exception, HttpServletResponse response,Exception e) {
        return getExceptionInfo(ResultCode.EXCEPTION_404.getMessage(),ResultCode.EXCEPTION_404.getCode(),e);
    }

    /**
     * @auth: zhanghy
     * @desc: 输入参数类型不合法
     * @data: 2019/9/3 13:31
     * @return: 异常信息
     */
    @ExceptionHandler(value = HttpMessageNotReadableException.class)
    public Map httpMessageNotReadableException(HttpMessageNotReadableException e,HttpServletResponse response) {
        return getExceptionInfo(ResultCode.EXCEPTION_4001.getMessage(),ResultCode.EXCEPTION_4001.getCode(),e);
    }

    /**
     * @auth: zhanghy
     * @desc: 请求方式不支持
     * @data: 2019/9/3 13:31
     * @return: 异常信息
     */
    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
    public Map errorHandler(HttpServletRequest request, HttpMediaTypeNotSupportedException exception, HttpServletResponse response,Exception e) {
        return getExceptionInfo(ResultCode.EXCEPTION_406.getMessage(),ResultCode.EXCEPTION_406.getCode(),e);
    }

    /**
     * @auth: zhanghy
     * @desc: 请求方式不支持
     * @data: 2019/9/3 13:31
     * @return: 异常信息
     */
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public Map httpRequestMethodNotSupportedExceptionHandler(HttpServletRequest request, HttpMediaTypeNotSupportedException exception, HttpServletResponse response,Exception e) {
        return getExceptionInfo(ResultCode.EXCEPTION_405.getMessage(),ResultCode.EXCEPTION_405.getCode(),e);
    }

    /**
     * @auth   zhanghy
     * @date   2021/9/10 11:10
     * @desc   请求资源超时
     * @return 异常信息
     */
    @ExceptionHandler({ResourceAccessException.class, ConnectException.class})
    public Map resourceAccessExceptionHandler(HttpServletRequest request, HttpServletResponse response,Exception e) {
        return getExceptionInfo(ResultCode.EXCEPTION_408.getMessage(),ResultCode.EXCEPTION_408.getCode(),e);
    }

    /**
     * @desc: 请求参数缺失
     * @auth: zhanghy
     * @data: 2019/9/18 14:12
     * @return:
     */
    @ExceptionHandler(MissingServletRequestParameterException.class)
    public Map errorMissingServletRequestParameterExceptionHandler(MissingServletRequestParameterException e) {
        return getExceptionInfo("请求缺少参数 " +  e.getParameterName(),ResultCode.EXCEPTION_400.getCode(),e);
    }

    /**
     * @desc: 请求参数类型错误
     * @auth: zhanghy
     * @data: 2019/9/18 14:12
     * @return:
     */
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public Map errorMethodArgumentTypeMismatchExceptionHandler(MethodArgumentTypeMismatchException e) {
        return getExceptionInfo("参数类型错误 " +  e.getParameter().getParameterName(),1003,e);
    }

    /**
     * 业务处理异常
     */
    @ExceptionHandler(SaasException.class)
    public Map saasException(SaasException e) {
        return getExceptionInfo(e.getMsg(),e.getCode(),e);
    }

    /**
     * 数据验证异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Map methodArgumentNotValidException(MethodArgumentNotValidException e) {
        BindingResult bindingResult = e.getBindingResult();
        List<ObjectError> allErrors = bindingResult.getAllErrors();
        StringBuffer msg = new StringBuffer();
        for(ObjectError obj: allErrors){
            msg.append(obj.getDefaultMessage());
            break;
        }
        return getExceptionInfo(msg.toString(),500,e);
    }

        /**
     * 总的异常处理
     */
    @ExceptionHandler(Exception.class)
    public Map handleException(Exception e) {
        return getExceptionInfo("error",500,e);
    }

    /**
     * 异常处理响应客户端状态
     */
    public Map getExceptionInfo(String msg, Integer resultcode, Exception e){
        Map resultDate = new HashMap();
        resultDate.put("message",msg);
        resultDate.put("code",resultcode);
        log.error(e.getMessage(),e);
        return resultDate;
    }

第四：异常类型，枚举类编写 ResultCode

/**
 * 全局状态码
 */
public enum ResultCode {
    /**
     * 自定义的返回状态码
     */
  
    EXCEPTION_400(400, "缺失参数"),
    EXCEPTION_4001(4001, "参数类型有误"),
    EXCEPTION_401(401, "认证失败"),
    EXCEPTION_403(403, "禁止访问"),
    EXCEPTION_404(404, "资源不存在"),
    EXCEPTION_405(405, "请求方式有误"),           // 请求方式有误
    EXCEPTION_406(406, "请求资源类型不支持"),
    EXCEPTION_408(408, "请求超时"),
    EXCEPTION_500(500, "请求异常");

    private final int code;

    public String message;

    ResultCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
    public int getCode() {
        return code;
    }
    public int code() {
        return code;
    }
}