1、Spring Boot默认的错误处理机制

如果是浏览器，则返回一个默认的错误页面：

原理：

​ 可以参照ErrorMvcAutoConfiguration，错误处理的自动配置类。该自动配置类给容器中添加了以下几个组件：

1）、ErrorPageCustomizer：错误页面定制器

@Bean
public ErrorPageCustomizer errorPageCustomizer() {
    return new ErrorPageCustomizer(this.serverProperties);
}

来看看ErrorPageCustomizer类定义：

private static class ErrorPageCustomizer implements ErrorPageRegistrar, Ordered {

    private final ServerProperties properties;

    protected ErrorPageCustomizer(ServerProperties properties) {
        this.properties = properties;
    }

    @Override
    public void registerErrorPages(ErrorPageRegistry errorPageRegistry) {
        ErrorPage errorPage = new ErrorPage(this.properties.getServletPrefix()
                                            + this.properties.getError().getPath());
        errorPageRegistry.addErrorPages(errorPage);
    }
	//other code...
}

@Value("${error.path:/error}")
private String path = "/error";

public String getPath() {
    return this.path;
}

所以当系统出现错误以后，会来到error请求进行处理。

2）、BasicErrorController：错误控制器

创建一个Error控制器：

@Bean
@ConditionalOnMissingBean(value = ErrorController.class, search = SearchStrategy.CURRENT)
public BasicErrorController basicErrorController(ErrorAttributes errorAttributes) {
    return new BasicErrorController(errorAttributes, this.serverProperties.getError(),
                                    this.errorViewResolvers);
}

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {
    
    //浏览器首先返回text/html
    @RequestMapping(produces = "text/html")
	public ModelAndView errorHtml(HttpServletRequest request,
			HttpServletResponse response) {
		HttpStatus status = getStatus(request);
        //getErrorAttributes根据错误信息来封装一些model数据，用于页面显示
		Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
				request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
		response.setStatus(status.value());
        
        //返回错误页面，包含页面地址和页面内容
		ModelAndView modelAndView = resolveErrorView(request, response, status, model);
		return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
	}

    //其他测试工具默认返回json数据
	@RequestMapping
	@ResponseBody
	public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
		Map<String, Object> body = getErrorAttributes(request,
				isIncludeStackTrace(request, MediaType.ALL));
		HttpStatus status = getStatus(request);
		return new ResponseEntity<Map<String, Object>>(body, status);
	}
    
    //other code...
}

从@RequestMapping属性上看得出，如果在配置文件中配置了server.error.path值，则使用指定的值作为错误请求；如果未配置，则查看是否配置了error.path；如果还是没有，则该控制器默认处理/error请求。

​ 该控制器处理错误请求，返回两种类型，分别是text/html和JSON数据，具体可以参看以下两图：

下图是浏览器访问时请求头中的accpet：

下图是测试工具访问时请求头中的accpet：

所以当使用浏览器访问时出现错误的时候，会进入BasicErrorController控制器中的errorHtml方法，而如果是测试工具访问时出现错误的时候，就进入error方法。

在响应页面的errorHtml方法中，会调用了父类的resolveErrorView方法：

protected ModelAndView resolveErrorView(HttpServletRequest request,
			HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
    //获取所有的视图解析器来处理这个错误信息，而这个errorViewResolvers对象其实就是DefaultErrorViewResolver对象的集合
    for (ErrorViewResolver resolver : this.errorViewResolvers) {
        ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
        if (modelAndView != null) {
            return modelAndView;
        }
    }
    return null;
}

所以从上述源码中看得出，在响应页面的时候，会在父类的resolveErrorView方法中获取所有的ErrorViewResolver对象（DefaultErrorViewResolver对象），一起来解析这个错误信息。

3）、DefaultErrorViewResolver：默认错误视图处理器

@Bean
@ConditionalOnBean(DispatcherServlet.class)
@ConditionalOnMissingBean
public DefaultErrorViewResolver conventionErrorViewResolver() {
    return new DefaultErrorViewResolver(this.applicationContext,
                                        this.resourceProperties);
}

public class DefaultErrorViewResolver implements ErrorViewResolver, Ordered {
    private static final Map<Series, String> SERIES_VIEWS;

	static {
		Map<Series, String> views = new HashMap<Series, String>();
		views.put(Series.CLIENT_ERROR, "4xx");
		views.put(Series.SERVER_ERROR, "5xx");
		SERIES_VIEWS = Collections.unmodifiableMap(views);
	}
    
    @Override
	public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
			Map<String, Object> model) {
        //先以错误状态码作为错误页面名
		ModelAndView modelAndView = resolve(String.valueOf(status), model);
		if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            //如果无法处理，则使用4xx或者5xx作为错误页面名
			modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
		}
		return modelAndView;
	}

	private ModelAndView resolve(String viewName, Map<String, Object> model) {
        //错误页面：error/400，或者error/404，或者error/500...
		String errorViewName = "error/" + viewName;
        //模版引擎可以解析到这个页面地址就用模版引擎来解析
		TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
				.getProvider(errorViewName, this.applicationContext);
		if (provider != null) {
            //模版引擎能够解析到页面的情况下返回到errorViewName指定的视图
			return new ModelAndView(errorViewName, model);
		}
        //模版引擎不能够解析到页面的情况下，就在静态资源文件夹下查找errorViewName对应的页面
		return resolveResource(errorViewName, model);
	}

	private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
		for (String location : this.resourceProperties.getStaticLocations()) {
			try {
				Resource resource = this.applicationContext.getResource(location);
                //从静态资源文件中查找errorViewName对应的页面
				resource = resource.createRelative(viewName + ".html");
				if (resource.exists()) {
                    //如果存在，则直接返回
					return new ModelAndView(new HtmlResourceView(resource), model);
				}
			}
			catch (Exception ex) {
			}
		}
		return null;
	}
}

@Bean
@ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
public DefaultErrorAttributes errorAttributes() {
    return new DefaultErrorAttributes();
}

@Order(Ordered.HIGHEST_PRECEDENCE)
public class DefaultErrorAttributes
		implements ErrorAttributes, HandlerExceptionResolver, Ordered {
    
    @Override
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
                                                  boolean includeStackTrace) {
        //用来生成页面model数据
        Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
        errorAttributes.put("timestamp", new Date());
        addStatus(errorAttributes, requestAttributes);
        addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
        addPath(errorAttributes, requestAttributes);
        return errorAttributes;
    }
    
    //other code...
}

private final SpelView defaultErrorView = new SpelView(
				"<html><body><h1>Whitelabel Error Page</h1>"
						+ "<p>This application has no explicit mapping for /error, so you are seeing this as a fallback.</p>"
						+ "<div id='created'>${timestamp}</div>"
						+ "<div>There was an unexpected error (type=${error}, status=${status}).</div>"
						+ "<div>${message}</div></body></html>");

@Bean(name = "error")
@ConditionalOnMissingBean(name = "error")
public View defaultErrorView() {
    return this.defaultErrorView;
}

@ControllerAdvice
public class MyExceptionHandler {

	@ResponseBody
	@ExceptionHandler(value= NotExistException.class)
	public Map<String, Object> handler(Exception e){
		Map<String, Object> map = new HashMap<>();
		map.put("message", e.getMessage());

		return map;
	}
}

@ControllerAdvice
public class MyExceptionHandler {

	@ExceptionHandler(NotExistException.class)
	public String handler(Exception e, HttpServletRequest request){
		Map<String, Object> map = new HashMap<>();
//		Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
		//需要传入自己的错误状态码 4xx或者5xx（重要，否则是状态码为200，会找不到对应的错误页面）
		request.setAttribute("javax.servlet.error.status_code", 400);

		map.put("email", "412425870@qq.com");
		map.put("error", "发生错误啦！");
		request.setAttribute("map", map);

		//转发到/error请求
		return "forward:/error";
	}
}

3）、将自定义的数据传递给页面或者json数据（重点）

    自定义ErrorAttributes类，来覆盖ErrorMvcAutoConfiguration自动配置类中创建的默认DefaultErrorAttributes的Bean。

@Component
public class MyErrorAttributes extends DefaultErrorAttributes {

	@Override
	public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
		Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);

		//在原来的错误信息上添加自定义的错误信息
		map.put("author", "caychen");

        //获取异常处理类中设置的错误信息
		Map<String, Object> other = (Map<String, Object>) requestAttributes.getAttribute("map", RequestAttributes.SCOPE_REQUEST);
		map.put("other", other);
		return map;
	}
}

这样就可以在模版页面上获取对应的错误信息了。

<h1>status: [[${status}]]</h1>
<h2>timestamp: [[${timestamp}]]</h2>
<h2>error: [[${error}]]</h2>
<h2>exception: [[${exception}]]</h2>
<h2>author: [[${author}]]</h2>
<h2 th:if="${other.error}" th:text="${other.error}"></h2>
<h2 th:if="${other.email}" th:text="${other.email}"></h2>

====================打个广告，欢迎关注====================

QQ:	412425870
微信公众号：Cay课堂
csdn博客：	http://blog.csdn.net/caychen
码云：	https://gitee.com/caychen/
github：	https://github.com/caychen
点击群号或者扫描二维码即可加入QQ群: 328243383(1群)
点击群号或者扫描二维码即可加入QQ群: 180479701(2群)