配置springboot在访问404时自定义返回结果以及统一异常处理

在搭建项目框架的时候用的是springboot，想统一处理异常，但是发现404的错误总是捕捉不到，总是返回的是springBoot自带的错误结果信息。

如下是springBoot自带的错误结果信息：

 {
   "timestamp": 1492063521109,
   "status": 404,
   "error": "Not Found",
   "message": "No message available",
   "path": "/rest11/auth"
 }

百度一波，发现需要配置文件中加上如下配置：

properties格式：

#出现错误时, 直接抛出异常
spring.mvc.throw-exception-if-no-handler-found=true
#不要为我们工程中的资源文件建立映射
spring.resources.add-mappings=false

yml格式：

spring:
#出现错误时, 直接抛出异常(便于异常统一处理，否则捕获不到404)
  mvc:
    throw-exception-if-no-handler-found: true

#不要为我们工程中的资源文件建立映射
  resources:
    add-mappings: false

　　

下面是我SpringMVC-config配置代码，里面包含统一异常处理代码，都贴上：

　　

 package com.qunyi.jifenzhi_zx.core.config;

 import com.alibaba.druid.pool.DruidDataSource;
 import com.alibaba.druid.support.http.StatViewServlet;
 import com.alibaba.druid.support.http.WebStatFilter;
 import com.alibaba.druid.support.spring.stat.BeanTypeAutoProxyCreator;
 import com.alibaba.druid.support.spring.stat.DruidStatInterceptor;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.serializer.SerializerFeature;
 import com.alibaba.fastjson.support.config.FastJsonConfig;
 import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
 import com.qunyi.jifenzhi_zx.core.Const;
 import com.qunyi.jifenzhi_zx.core.base.exception.ServiceException;
 import com.qunyi.jifenzhi_zx.core.base.result.ResponseMsg;
 import com.qunyi.jifenzhi_zx.core.base.result.Result;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.web.servlet.FilterRegistrationBean;
 import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
 import org.springframework.boot.web.servlet.ServletRegistrationBean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.web.context.request.RequestContextListener;
 import org.springframework.web.method.HandlerMethod;
 import org.springframework.web.servlet.HandlerExceptionResolver;
 import org.springframework.web.servlet.ModelAndView;
 import org.springframework.web.servlet.NoHandlerFoundException;
 import org.springframework.web.servlet.config.annotation.CorsRegistry;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.util.List;

 /**
  * Spring MVC 配置
  *
  * @author xujingyang
  * @date 2018/05/25
  */
 @Configuration
 public class WebMvcConfigurer extends WebMvcConfigurerAdapter {

     private final Logger logger = LoggerFactory.getLogger(WebMvcConfigurer.class);
     @Value("${spring.profiles.active}")
     private String env;//当前激活的配置文件

     //使用阿里 FastJson 作为JSON MessageConverter
     @Override
     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
         FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
         FastJsonConfig config = new FastJsonConfig();
         config.setSerializerFeatures(SerializerFeature.WriteMapNullValue,//保留空的字段
                 SerializerFeature.WriteNullStringAsEmpty,//String null -> ""
                 SerializerFeature.WriteNullNumberAsZero);//Number null -> 0
         converter.setFastJsonConfig(config);
         converter.setDefaultCharset(Charset.forName("UTF-8"));
         converters.add(converter);
     }

     //统一异常处理
     @Override
     public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
         exceptionResolvers.add(new HandlerExceptionResolver() {
             public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception e) {
                 ResponseMsg result;
                 if (e instanceof ServiceException) {//业务失败的异常，如“账号或密码错误”
                     result = new ResponseMsg("501", "业务层出错：" + e.getMessage());
                     logger.info(e.getMessage());
                 } else if (e instanceof NoHandlerFoundException) {
                     result = new ResponseMsg("404", "接口 [" + request.getRequestURI() + "] 不存在");
                 } else {
                     result = new ResponseMsg("500", "接口 [" + request.getRequestURI() + "] 错误，请联系管理员！");
                     String message;
                     if (handler instanceof HandlerMethod) {
                         HandlerMethod handlerMethod = (HandlerMethod) handler;
                         message = String.format("接口 [%s] 出现异常，方法：%s.%s，异常摘要：%s",
                                 request.getRequestURI(),
                                 handlerMethod.getBean().getClass().getName(),
                                 handlerMethod.getMethod().getName(),
                                 e.getMessage());
                     } else {
                         message = e.getMessage();
                     }
                     logger.error(message, e);
                 }
                 responseResult(response, result);
                 return new ModelAndView();
             }

         });
     }

     //解决跨域问题
     @Override
     public void addCorsMappings(CorsRegistry registry) {
         registry.addMapping("/**") // **代表所有路径
                 .allowedOrigins("*") // allowOrigin指可以通过的ip，*代表所有，可以使用指定的ip，多个的话可以用逗号分隔，默认为*
                 .allowedMethods("GET", "POST", "HEAD", "PUT", "DELETE") // 指请求方式 默认为*
                 .allowCredentials(false) // 支持证书，默认为true
                 .maxAge(3600) // 最大过期时间，默认为-1
                 .allowedHeaders("*");
     }

     //添加拦截器
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         //接口登录验证拦截器
         if (!"dev".equals(env)) { //开发环境忽略登录验证
             registry.addInterceptor(new HandlerInterceptorAdapter() {
                 @Override
                 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                     //验证登录
                     Object obj = request.getSession().getAttribute(Const.LOGIN_SESSION_KEY);
                     if (obj != null) {
                         return true;
                     } else {
                         logger.warn("请先登录！==> 请求接口：{}，请求IP：{}，请求参数：{}",
                                 request.getRequestURI(), getIpAddress(request), JSON.toJSONString(request.getParameterMap()));

                         responseResult(response, new ResponseMsg(Result.SIGNERROR));
                         return false;
                     }
                 }
             });
         }
     }

     private void responseResult(HttpServletResponse response, ResponseMsg result) {
         response.setCharacterEncoding("UTF-8");
         response.setHeader("Content-type", "application/json;charset=UTF-8");
         response.setStatus(200);
         try {
             response.getWriter().write(JSON.toJSONString(result));
         } catch (IOException ex) {
             logger.error(ex.getMessage());
         }
     }

     private String getIpAddress(HttpServletRequest request) {
         String ip = request.getHeader("x-forwarded-for");
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getHeader("Proxy-Client-IP");
         }
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getHeader("WL-Proxy-Client-IP");
         }
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getHeader("HTTP_CLIENT_IP");
         }
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getHeader("HTTP_X_FORWARDED_FOR");
         }
         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
             ip = request.getRemoteAddr();
         }
         // 如果是多级代理，那么取第一个ip为客户端ip
         if (ip != null && ip.indexOf(",") != -1) {
             ip = ip.substring(0, ip.indexOf(",")).trim();
         }

         return ip;
     }

     /**
      * druidServlet注册
      */
     @Bean
     public ServletRegistrationBean druidServletRegistration() {
         ServletRegistrationBean registration = new ServletRegistrationBean(new StatViewServlet());
         registration.addUrlMappings("/druid/*");
         return registration;
     }

     /**
      * druid监控 配置URI拦截策略
      *
      * @return
      */
     @Bean
     public FilterRegistrationBean druidStatFilter() {
         FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
         // 添加过滤规则.
         filterRegistrationBean.addUrlPatterns("/*");
         // 添加不需要忽略的格式信息.
         filterRegistrationBean.addInitParameter("exclusions", "/web_frontend/*,*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid,/druid/*,/error,/login*");
         // 用于session监控页面的用户名显示 需要登录后主动将username注入到session里
         filterRegistrationBean.addInitParameter("principalSessionName", "username");
         return filterRegistrationBean;
     }

     /**
      * druid数据库连接池监控
      */
     @Bean
     public DruidStatInterceptor druidStatInterceptor() {
         return new DruidStatInterceptor();
     }

     /**
      * druid数据库连接池监控
      */
     @Bean
     public BeanTypeAutoProxyCreator beanTypeAutoProxyCreator() {
         BeanTypeAutoProxyCreator beanTypeAutoProxyCreator = new BeanTypeAutoProxyCreator();
         beanTypeAutoProxyCreator.setTargetBeanType(DruidDataSource.class);
         beanTypeAutoProxyCreator.setInterceptorNames("druidStatInterceptor");
         return beanTypeAutoProxyCreator;
     }

     /**
      * RequestContextListener注册
      */
     @Bean
     public ServletListenerRegistrationBean<RequestContextListener> requestContextListenerRegistration() {
         return new ServletListenerRegistrationBean<>(new RequestContextListener());
     }

     /**
      * 将swagger-ui.html 添加 到 resources目录下
      *
      * @param registry
      */
     @Override
     public void addResourceHandlers(ResourceHandlerRegistry registry) {
         registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
         registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
         registry.addResourceHandler("/web_frontend/**").addResourceLocations("classpath:/web_frontend/");

     }

 }

　

　　至此，所有错误异常都能捕捉到，统一处理了~~