SpringBoot源码学习系列之异常处理自动配置 / 憋错料

1、源码学习

先给个SpringBoot中的异常例子，假如访问一个错误链接，让其返回404页面

在浏览器访问：

而在其它的客户端软件，比如postman软件：

很显然，在浏览器里访问才会返回页面，而在Postman直接返回json数据了，所以基于此现象，可以跟一下Springboot异常自动配置的原理，本博客基于学习了尚硅谷课程之后，自己动手实践再做的笔录

SpringBoot的异常自动配置类是ErrorMvcAutoConfiguration.java，可以简单跟一下源码：



package org.springframework.boot.autoconfigure.web.servlet.error;

....

@Configuration(proxyBeanMethods = false)//定义注解类
@ConditionalOnWebApplication(type = Type.SERVLET)//作用于web环境
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class })//系统中有Servlet、DispatcherServlet(Spring重要的分发器类)类才起效
// Load before the main WebMvcAutoConfiguration so that the error View is available(作者也有注释，意思是WebMvcAutoConfiguration加载之后，才加载此自动配置类，目的是保证错误视图可以被加载到)
@AutoConfigureBefore(WebMvcAutoConfiguration.class)
@EnableConfigurationProperties({ ServerProperties.class, ResourceProperties.class, WebMvcProperties.class })//使这些配置类起作用
public class ErrorMvcAutoConfiguration {

    private final ServerProperties serverProperties;

    public ErrorMvcAutoConfiguration(ServerProperties serverProperties) {
        this.serverProperties = serverProperties;
    }

    //系统没有自定义的DefaultErrorAttributes的时候，使这个默认的model属性配置起效
    @Bean
    @ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
    public DefaultErrorAttributes errorAttributes() {
        return new DefaultErrorAttributes(this.serverProperties.getError().isIncludeException());
    }
    //默认的异常控制类
    @Bean
    @ConditionalOnMissingBean(value = ErrorController.class, search = SearchStrategy.CURRENT)
    public BasicErrorController basicErrorController(ErrorAttributes errorAttributes,
            ObjectProvider<ErrorViewResolver> errorViewResolvers) {
        return new BasicErrorController(errorAttributes, this.serverProperties.getError(),
                errorViewResolvers.orderedStream().collect(Collectors.toList()));
    }
    //定义异常错误页面规则
    @Bean
    public ErrorPageCustomizer errorPageCustomizer(DispatcherServletPath dispatcherServletPath) {
        return new ErrorPageCustomizer(this.serverProperties, dispatcherServletPath);
    }

    ....
    //默认的error视图解析器配置类
    @Configuration(proxyBeanMethods = false)
    static class DefaultErrorViewResolverConfiguration {
        //ioc容器
        private final ApplicationContext applicationContext;

        private final ResourceProperties resourceProperties;

        DefaultErrorViewResolverConfiguration(ApplicationContext applicationContext,
                ResourceProperties resourceProperties) {
            this.applicationContext = applicationContext;
            this.resourceProperties = resourceProperties;
        }

        //从容器里加载对应的properties配置
        @Bean
        @ConditionalOnBean(DispatcherServlet.class)
        @ConditionalOnMissingBean(ErrorViewResolver.class)
        DefaultErrorViewResolver conventionErrorViewResolver() {
            return new DefaultErrorViewResolver(this.applicationContext, this.resourceProperties);
        }

    }

    ....

}

ok，基于此类，可以拿出比较重要的类

BasicErrorController
BasicErrorController是页面的默认异常处理控制类

//默认异常控制类
@Bean
    @ConditionalOnMissingBean(value = ErrorController.class, search = SearchStrategy.CURRENT)
    public BasicErrorController basicErrorController(ErrorAttributes errorAttributes,
            ObjectProvider<ErrorViewResolver> errorViewResolvers) {
        return new BasicErrorController(errorAttributes, this.serverProperties.getError(),
                errorViewResolvers.orderedStream().collect(Collectors.toList()));
    }

控制类的映射路径，如果application没配server.error.path就使用默认的/error

翻下控制类的源码，在里面找到如下的关键代码：

// 这里获取MediaType为text/html的调用这个接口
@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
    public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
    //获取http的请求状态对象
        HttpStatus status = getStatus(request);
        //model属性map，这个map是不可以编辑的unmodifiableMap
        Map<String, Object> model = Collections
                .unmodifiableMap(getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
        //设置状态码，目的是页面转跳到对应的状态码页面，eg:/error/404.html
        response.setStatus(status.value());
        // 构建modelAndView，通过resolveErrorView方法
        ModelAndView modelAndView = resolveErrorView(request, response, status, model);
        //resolveErrorView是否能获取到?没获取到就跳转到命名为error的视图
        return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
    }

    //error json数据返回的接口
    @RequestMapping
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        //同样获取http状态对象
        HttpStatus status = getStatus(request);
        if (status == HttpStatus.NO_CONTENT) {
            return new ResponseEntity<>(status);
        }
        //通过getErrorAttributes获取默认属性配置封装到model
        Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.ALL));
        return new ResponseEntity<>(body, status);
    }

默认的视图：

/**
     * Simple {@link View} implementation that writes a default HTML error page.
     */
    private static class StaticView implements View {

        private static final MediaType TEXT_HTML_UTF8 = new MediaType("text", "html", StandardCharsets.UTF_8);

        private static final Log logger = LogFactory.getLog(StaticView.class);

        @Override
        public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
                throws Exception {
            if (response.isCommitted()) {
                String message = getMessage(model);
                logger.error(message);
                return;
            }
            response.setContentType(TEXT_HTML_UTF8.toString());
            StringBuilder builder = new StringBuilder();
            Date timestamp = (Date) model.get("timestamp");
            Object message = model.get("message");
            Object trace = model.get("trace");
            if (response.getContentType() == null) {
                response.setContentType(getContentType());
            }
            builder.append("<html><body><h1>Whitelabel Error Page</h1>").append(
                    "<p>This application has no explicit mapping for /error, so you are seeing this as a fallback.</p>")
                    .append("<div id='created'>").append(timestamp).append("</div>")
                    .append("<div>There was an unexpected error (type=").append(htmlEscape(model.get("error")))
                    .append(", status=").append(htmlEscape(model.get("status"))).append(").</div>");
            if (message != null) {
                builder.append("<div>").append(htmlEscape(message)).append("</div>");
            }
            if (trace != null) {
                builder.append("<div style='white-space:pre-wrap;'>").append(htmlEscape(trace)).append("</div>");
            }
            builder.append("</body></html>");
            response.getWriter().append(builder.toString());
        }

        private String htmlEscape(Object input) {
            return (input != null) ? HtmlUtils.htmlEscape(input.toString()) : null;
        }

        private String getMessage(Map<String, ?> model) {
            Object path = model.get("path");
            String message = "Cannot render error page for request [" + path + "]";
            if (model.get("message") != null) {
                message += " and exception [" + model.get("message") + "]";
            }
            message += " as the response has already been committed.";
            message += " As a result, the response may have the wrong status code.";
            return message;
        }

        @Override
        public String getContentType() {
            return "text/html";
        }

    }

其实就是我们经常看到的：

然后status又是从哪里获取的？点下源码，如图，是从javax.servlet.error.status_code属性获取的，这也就是为什么在配置类开头要加上@ConditionalOnClass({ Servlet.class, DispatcherServlet.class })的原因了

ok，跟了这个默认控制类，或许我们就能明白为什么浏览器访问就会访问默认错误页面，Postman访问就返回json数据了

在浏览器的页面按F12调试：这里可以找到请求头里有accept这个关键属性，Springboot就是根据这个属性进行判断的，通过设置@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)，从而让浏览器访问的都跳转页面转跳的接口

而Postman调的默认就调json数据的接口，因为Postman调的接口默认没指定accept属性为text/html：

ok，弄清楚这个原理之后，继续跟一下默认Error控制类的源码

resolveErrorView方法是什么作用？点下源码，这个方法代码如图所示，里面是进行error视图解析器的遍历，既然有视图解析器，那么是否有默认的视图解析器？IDEA软件Ctrl+alt+B打开接口的实现类是DefaultErrorViewResolver.java

DefaultErrorAttributes
在前面BasicErrorController的源码学习里，可以看到如图代码：

可以看出model的属性配置都是从getErrorAttributes方法获取的

ctrl+alt+B打开其实现：可以看出默认是通过DefaultErrorAttributes实现的

通过Postman测试，看看属性返回参数

当然也可以翻其源码，通过Postman简单测试和翻其源码的方式，可以确定，默认的属性配置基本有：
1. timestamp：时间戳
2. status：状态码
3. error：错误提示
4. exception：异常对象
5. message：异常消息
6. errors：JSR303数据校验的错误都在这里
ErrorPageCustomizer
作用：定义错误页面的规则，是一个内部类，源码如图，有进行了/error默认的相对路径设置，注意是相对路径，并非绝对路径，因为error文件夹可以放在模板引擎对应文件夹下面，也可以放在statis文件夹下面，详细请看下文分析
DefaultErrorViewResolver
前面的源码分析可以看出，BasicErrorController会遍历Error视图解析器，通过ctrl+alt+b的方式，我们可以看到只有DefaultErrorViewResolver这个实现类，当然我们虽然从命名上看觉得，这个类应该就是默认的视图解析器类，显然还不是特别确定

ok，翻一下前面的ErrorMvcAutoConfiguration自动配置类，如图代码，可以找到这个内部配置类，这里进行了默认视图的配置，而且将ioc的实例传到DefaultErrorViewResolver构造方法，所以现在可以确定默认的视图解析器类就是DefaultErrorViewResolver.java

点一下DefaultErrorVireResolver源码：故意让页面报错，然后调试一下源码

这里是进行默认状态码获取

ok，分析一下这个关键的方法：

//modelAndView的model数据和Viewname设置
@Override
    public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
        //resolve方法是关键方法，待会分析
        ModelAndView modelAndView = resolve(String.valueOf(status.value()), model);
        //ModelAndView对象获取不到的情况，采用默认的，比如客户端报错返回4xx的Viewname,服务端报错返回5xx的viewname
        if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
        }
        return modelAndView;
    }

关键的resolve方法

private ModelAndView resolve(String viewName, Map<String, Object> model) {
        String errorViewName = "error/" + viewName;//从这里可以看出跳转的页面就是在error文件夹下面的以viewname(状态码命名)的对应html文件
        //模板引擎起效的情况，也就是能加载到对应error/status.html文件的情况
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName,
                this.applicationContext);
        //模板引擎能找得到对应文件的情况
        if (provider != null) {
            return new ModelAndView(errorViewName, model);
        }
        //没找到的情况，继续resolveResource方法
        return resolveResource(errorViewName, model);
    }

找下Thymeleaf模板引擎ThymeleafTemplateAvailabilityProvider类，这里是进行了资源加载，prefix也就是template文件夹，所以将view(error/status)这个参数传进来就能被加载到

ok，经过视图解析器的源码学习，其实可以这样尝试了，在templates的文件夹下面建一个error文件夹，丢几个状态码html文件

故意让页面报错，调试，确实进到这里，viewName也是error/404

放开断点，发现返回的是我们自定义的404页面，并非默认页面了，所以可以得出，我们的猜想是正确的，建个error命名的文件夹丢在templates里，模板引擎是能进行解析的

ok，在源码里还是这个方法，在模板引擎扫描不到对应html页面的时候，会进入这个方法，分析一下源码

private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
    //这里是获取所有的静态资源，进行扫描，也就是说将error文件夹放在statis文件夹下面也是会被扫描到的
        for (String location : this.resourceProperties.getStaticLocations()) {
            try {
            //资源读取
                Resource resource = this.applicationContext.getResource(location);
                resource = resource.createRelative(viewName + ".html");
                //扫描都status.html这种html文件，返回一个modelAndView
                if (resource.exists()) {
                    return new ModelAndView(new HtmlResourceView(resource), model);
                }
            }
            catch (Exception ex) {
            }
        }
        return null;//扫描不到html，返回null值，不影响主程序
    }

2、自定义异常

经过前面源码的比较详细的学习，我们现在思路应该比较清晰了，首先SpringBoot的异常处理自动配置就是这样的，首先是有根据客户端的不同显示不同效果，比如浏览器在什么都没配置的情况就返回默认页面，这个页面也就是通过view命名的默认视图StaticView实现的，然后在Postman这些客户端抛异常的时候，是返回json数据的，不返回页面，然后我们通过默认视图解析器源码的学习，就可以知道了，我们是可以自定义异常解析页面的，比如404的时候，我们只要在templates文件夹下面放一个error/404.html文件，就可以实现异常页面的个性定制，而在templates文件夹下面没有对应html文件的时候，就会去statis文件夹下面扫描

ok，所以现在我们想自定义系统的异常实现，具体要怎么实现？本博客就以尚硅谷教程的例子来举例

按照以前SpringMVC的做法，加个自定义异常类：

package com.example.springboot.web.exception;

/**
 * <pre>
 *  自定义异常类
 * </pre>
 *
 * @author nicky
 * <pre>
 * 修改记录
 *    修改后版本:     修改人：  修改日期: 2019年12月01日  修改内容:
 * </pre>
 */
public class NotFoundException extends RuntimeException{

    private Integer code;//自定义异常码

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public NotFoundException(String message, Integer code) {
        super(message);// 父类的构造函数；调用底层的Throwable的构造函数，将参数message赋值到detailMessage (Throwable的属性)
        this.code = code;//赋值code码
    }
}

当然也需要一个ExceptionHandler类：

package com.example.springboot.web.controller;

import com.example.springboot.web.exception.NotFoundException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;
import java.util.Map;

/**
 * <pre>
 *  自定义异常处理类
 * </pre>
 *
 * @author nicky
 * <pre>
 * 修改记录
 *    修改后版本:     修改人：  修改日期: 2019年12月01日  修改内容:
 * </pre>
 */
@RestControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(NotFoundException.class)
    //@ResponseBody
    //@ResponseStatus(value=HttpStatus.INTERNAL_SERVER_ERROR)
    public Map<String,Object> handleException(Exception e){
        Map<String, Object> map = new HashMap<>(16);
        map.put("code", "404");
        map.put("message", e.getMessage());
        return map;
    }

}

测试接口方法：

@RequestMapping(value = {"/testException"})
    @ResponseBody
    public String testException(String tFlag){
        if("1".equals(tFlag)) {
            throw new NotFoundException("404异常",404);
        }
        return "hello!";
    }

很显然，返回的都是json数据

通过前面源码的学习，如果我们想实现SpringBoot那种效果，浏览器返回错误页面，Postman的才返回json数据，具体要怎么实现？

通过前面的学习，BasicErrorController类就是默认的异常处理类，映射链接就是/error，所以这里可以通过BasicErrorController提供的接口来实现

@RestControllerAdvice注解就要换成@ControllerAdvice注解，因为Rest返回的都是json数据，现在要返回一个页面

package com.example.springboot.web.component;

import com.example.springboot.web.exception.NotFoundException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.HashMap;
import java.util.Map;

/**
 * <pre>
 *  自定义异常处理类
 * </pre>
 *
 * @author nicky
 * <pre>
 * 修改记录
 *    修改后版本:     修改人：  修改日期: 2019年12月01日  修改内容:
 * </pre>
 */
//@RestControllerAdvice
@ControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(NotFoundException.class)
    public String handleException(Exception e){
        Map<String, Object> map = new HashMap<>(16);
        map.put("code", "404");
        map.put("message", e.getMessage());
        return "forward:/error";//BasicErrorController的接口
    }

}

ok，貌似是实现了，不过发现不是我们要的效果，又调回了默认页面，而且状态码是还是200

具体是为什么？又要跟一下BasicErrorController的源码了，如图，这里有setStatus的操作

前面源码学习，可以知道就是通过这个状态码去找对应页面，所以很显然，我们可以知道为什么不能跳转自定义页面了

因为status获取不到，所以不能找到对应页面

修改方法是，加上属性配置即可：

404.html进行信息修改，将SpringBoot默认的DefaultErrorAttributes信息获取到，当然要放在templates下面，因为这样才能被模板引擎解析到

<h1>this is a 404 page </h1>
    <span>status:[[${status}]]</span><br/>
    <span>timestamp:[[${timestamp}]]</span><br/>
    <span>error:[[${error}]]</span><br/>
    <span>exception:[[${exception}]]</span><br/>
    <span>message:[[${message}]]</span><br/>
    <!--<span>errors:[[${errors}]</span><br/>-->

ok，自定义异常页面，已经实现，然后想自定义异常Attributes怎么实现？看一下Springboot ErrorAttributes的自动配置，注意了，这里指明了要系统没有自定义DefaultErrorAttributes的情况才使用默认的，所以我们只有写个自定义的类实现DefaultErrorAttributes即可

修改一下ExceptionHandler类：

自定义一个ErrorAttributes类：

package com.example.springboot.web.component;

import org.springframework.boot.web.servlet.error.DefaultErrorAttributes;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.WebRequest;

import java.util.Map;

/**
 * <pre>
 *   自定义异常Attributes类
 * </pre>
 *
 * @author nicky
 * <pre>
 * 修改记录
 *    修改后版本:     修改人：  修改日期: 2019年12月01日  修改内容:
 * </pre>
 */
@Component
public class CustomErrorAttributes extends DefaultErrorAttributes {

    //返回值的map就是页面和json能获取的所有字段
    @Override
    public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
        //先将默认的Attributes封装到map
        Map<String, Object> map = super.getErrorAttributes(webRequest, includeStackTrace);
        map.put("company","company.com");
        //获取ExceptionHandler设置的Attributes，0表示从Request中拿
        Map<String,Object> ext = (Map<String, Object>) webRequest.getAttribute("extend",0);
        map.put("extend",ext);
        return map;
    }

}

404页面进行修改

<h1>this is a 404 page </h1>
    <span>status:[[${status}]]</span><br/>
    <span>timestamp:[[${timestamp}]]</span><br/>
    <span>error:[[${error}]]</span><br/>
    <span>exception:[[${exception}]]</span><br/>
    <span>message:[[${message}]]</span><br/>
    <!--<span>errors:[[${errors}]</span><br/>-->
    <span>company:[[${company}]]</span><br/>
    <span>extend:[[${extend}]]</span><br/>

ok，自定义的attribute信息也拿到

Postman软件测试也是可以的：

ok，本博客例子是学习尚硅谷教程后写的，例子都经过验证，基于Springboot2.2.1版本，代码例子下载

原文地址：https://www.cnblogs.com/mzq123/p/11967963.html

时间： 2024-10-10 01:16:18

SpringBoot源码学习系列之异常处理自动配置

1、源码学习

2、自定义异常

SpringBoot源码学习系列之异常处理自动配置的相关文章

SpringBoot源码学习系列之嵌入式Servlet容器

SpringBoot源码学习系列之启动原理简介

JDK源码学习系列08----HashMap

JDK源码学习系列07----Stack

JDK源码学习系列06----Vector

JDK源码学习系列05----LinkedList

【JDK1.8】 Java小白的源码学习系列：HashMap

Java 源码学习系列（三）——Integer

thinkphp5源码剖析系列1-类的自动加载机制