SpringBoot之错误处理机制

---

1、SpringBoot默认的错误处理机制

SpringBoot对错误默认的效果，主要分为两种：一种是浏览器，另一种是其他客户端。

（1）浏览器返回一个默认的错误页面

浏览器发送请求的请求头中携带了关键的信息text/html

（2）如果是其他客户端，默认响应一个json数据，以postman为例，具体如下：

postman发送请求的请求头中accept信息如下：

2、错误处理原理

一旦系统出现4xx或者5xx之类的错误，ErrorPageCustomizer就会生效（定制错误的响应规则）；就会来到/error请求，就会被BasicErrorController处理

响应页面：去哪个页面是由DefaultErrorViewResolver解析得到的；

protected ModelAndView resolveErrorView(HttpServletRequest request,
			HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
    //ErrorViewResolver：异常视图解析器
		for (ErrorViewResolver resolver : this.errorViewResolvers) {
			ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
			if (modelAndView != null) {
				return modelAndView;
			}
		}
		return null;
	}

主要参照错误自动配置类ErrorMvcAutoConfiguration，该错误自动配置类给容器添加了如下组件：DefaultErrorAttributes、BasicErrorController、ErrorPageCustomizer、DefaultErrorViewResolver，每个组件的具体用途如下：

（1）DefaultErrorAttributes

//构造在页面上显示的共享信息
@Override
	public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
			boolean includeStackTrace) {
		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;
	}

（2）BasicErrorController：处理默认的/error请求

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {
	private final ErrorProperties errorProperties;
    
    //产生的html类型的数据;统一处理浏览器发送的请求
    @RequestMapping(produces = "text/html")
	public ModelAndView errorHtml(HttpServletRequest request,
			HttpServletResponse response) {
		HttpStatus status = getStatus(request);
		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);
	}

	@RequestMapping
	@ResponseBody
    //产生json数据；统一出来来自其他客户端的请求
	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);
	}

###（3）ErrorPageCustomer：

@Override
		public void registerErrorPages(ErrorPageRegistry errorPageRegistry) {
            //注册错误响应规则；当系统发生错误后，去哪个路径，通过getPath()进行配置
			ErrorPage errorPage = new ErrorPage(this.properties.getServletPrefix()
					+ this.properties.getError().getPath());
			errorPageRegistry.addErrorPages(errorPage);
		}

public class ErrorProperties {

	/**
	 * 系统出现错误以后来到error请求进行处理（web.xml注册的错误页	   *面规划）
	 */
	@Value("${error.path:/error}")
	private String path = "/error";

（4）DefaultErrorViewResolver：

@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())) {
			modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
		}
		return modelAndView;
	}

	private ModelAndView resolve(String viewName, Map<String, Object> model) {
        //默认SpringBoot可以去找到一个页面：error/404
		String errorViewName = "error/" + viewName;
		//模板引擎可以解析这个页面地址就用模板引擎解析
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
				.getProvider(errorViewName, this.applicationContext);
		if (provider != null) {
            //模板引擎可用的情况下返回到errorViewName指定的视图地址
			return new ModelAndView(errorViewName, model);
		}
        //模板引擎不可用，就在静态资源文件夹下找到errorViewName对应的页面 error/404.html
		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);
				resource = resource.createRelative(viewName + ".html");
				if (resource.exists()) {
					return new ModelAndView(new HtmlResourceView(resource), model);
				}
			}
			catch (Exception ex) {
			}
		}
		return null;
	}

注意：当模板引擎不可用的时候，就会在静态资源文件夹下找对应的错误页面

3、如何定制错误响应

3.1 如何定制错误的页面

（1）有模板引擎的情况下，error/状态码

将错误页面命名为错误状态码.html放在模板引擎文件夹里面的error文件夹下，发生此状态码的错误就会来到对应的页面；

可以使用4xx和5xx作为错误页面的文件名来匹配这种类型的所有错误，精确优先（优先寻找精确的状态码.html）

页面能获取的信息如下：

• timestamp：时间戳
• status：状态码
• error：错误提示
• exception：异常对象
• message：异常信息
• errors：JSR303数据校验的错误都在这里

（2）没有模板引擎（模板引擎找不到这个错误页面），去静态资源文件夹下找

静态资源文件夹的路径有以下四种

（3）以上都没有错误页面，就是默认来到SpringBoot默认的错误提示页面

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());

3.2 如何定制错误的json数据

（1）默认的json数据内容

（2）自定义异常处理&返回定制json数据

@ControllerAdvice
public class MyExceptionHandler {
    //浏览器和客户端返回的都是json数据
    @ResponseBody
    @ExceptionHandler(UserNoExistException.class)
    public Map<String, Object> handleException(Exception e){
        Map<String, Object> map = new HashMap<>();
        map.put("code","user.notexist");
        map.put("message",e.getMessage());
        return map;
    }
}

以上自定义处理方式的缺点是：没有自适应效果，所谓的自适应效果就是：当用浏览器发送请求的时候，返回的应该是html页面；通过其他客户端发送请求的时候，返回的应该是json数据。

（3）转发到/error进行自适应响应效果处理

@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(UserNoExistException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        //传入我们自己的错误状态码4xx、5xx，默认的是200,，否则就不会进入到定制错误页面的解析流程中
        //参考AbstractErrorController类中的getStatus方法中的代码：Integer statusCode = (Integer) request				.getAttribute("javax.servlet.error.status_code");
       
        request.setAttribute("javax.servlet.error.status_code",500);
        map.put("code","user.notexist");
        map.put("message",e.getMessage());
        //将异常信息带到界面上去
        request.setAttribute("ext",map);
        //转发到/error        
        return "forward:/error";
    }
}

（4）将我们的定制数据携带出来

我们可以自定义异常处理器，在异常处理器中捕获一些重要的反馈信息。当出现错误后，会来到/error请求，会被BasicErrorController处理，响应出去可以获取的数据是由getErrorAttributes得到的（AbstractErrorController（ErrorController）规定的方法）；

protected Map<String, Object> getErrorAttributes(HttpServletRequest request,
			boolean includeStackTrace) {
		RequestAttributes requestAttributes = new ServletRequestAttributes(request);
    //构造返回的数据
		return this.errorAttributes.getErrorAttributes(requestAttributes,
				includeStackTrace);
	}

1）完全来编写一个ErrorController的实现类【或者编写AbstractErrorController的子类】，放在容器中；

2）页面上能用的数据，或者是json返回能用的数据都是通过errorAttributes.getErrorAttributes得到；

3）容器中DefaultErrorAttributes.getErrorAttributes();默认进行数据处理的；

自定义ErrorAttributes类

@Component
public class MyErrorAttributes extends DefaultErrorAttributes {
    //返回值的map就是页面和json能获取的所有字段信息
    @Override
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
        Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
        //对每个提示信息添加公共的属性信息
        map.put("company","htzw");
        //我们自定义的异常处理器携带的数据
        Map<String, Object> ext = (Map<String, Object>) requestAttributes.getAttribute("ext", 0);
        map.put("ext",ext);
        return map;
    }
}

4、最终效果

最终的效果是：响应式自适应的，可以通过定制ErrorAttributes改变需要返回的内容

浏览器返回信息如下：

客户端返回信息如下：