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版本，代码例子下载

巴特西

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

1、源码学习

2、自定义异常

最新文章

热门文章