Day42——定制错误数据

刺骨的言语ヽ痛彻心扉 2023-02-28 12:45 75阅读 0赞

### 文章目录 ###

*  一. 回顾
 *  二. 定制错误数据
 *   *  2.1 自定义错误异常UserNotExistException
     *  2.2 初步定制错误数据
     *  2.3 改进定制错误数据——自适应
     *  2.4 实现自适应并前往自定制错误页面
     *   *  2.4.1 分析
         *  2.4.2 实现
     *  2.5 将自己定制的数据携带出去
     *   *  2.5.1 分析
         *  2.5.2 将数据携带出去的过程
         *  2.5.3 将数据携带出去的方案
         *  2.5.4 实现
     *  2.6 解决exception显示不出来
     *   *  2.6.1 情况
         *  2.6.2 分析
         *  2.6.3 解决
     *  2.7 总结

# 一. 回顾 #

前面学习了[Day41——错误处理原理&定制错误页面][Day41]，今天学习定制错误数据

# 二. 定制错误数据 #

## 2.1 自定义错误异常UserNotExistException ##

定义异常类并继承RuntimeExcception，如下:

public class UserNotExistException extends RuntimeException{ 
        public UserNotExistException() { 
            super("用户不存在");
        }
    }

定义controller，如下：

@ResponseBody
    @RequestMapping("/hello")
    public String hello(@RequestParam("user")String user){ 
        if(user.equals("aaa")){ 
            throw new UserNotExistException();
        }
        return "hello world!";
    }

并且在错误页面获取某些错误信息，如下：

<h1>status:[[ ${status} ]]</h1>
    <h2>timestamp:[[ ${timestamp} ]]</h2>
    <h2>exception:[[ ${exception} ]]</h2>
    <h2>message:[[ ${message} ]]</h2>

浏览器地址输入localhost:8080/crud/hello?user=aaa，就会来到controller并抛出UserNotExistException异常。效果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]  
**如果错误页面上的exception为空白，只需在application.properties上配置`server.error.include-exception=true`。原理可以参考[SpringBoot获取不到$\{exception\}][SpringBoot_exception]或[Day41——错误处理原理&定制错误页面][Day41 1]。**

## 2.2 初步定制错误数据 ##

前面已经定义好错误异常UserNotExistException，现在定义处理这个UserNotExistException的controller。如下:

MyExceptionHandler.java

@ResponseBody
    @ExceptionHandler(UserNotExistException.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;
    }

这里定制错误数据code以及message。方法返回值的类型是json。因此，这样的定制错误数据，浏览器或客户端返回的都是json类数据。

## 2.3 改进定制错误数据——自适应 ##

根据前面学习过的错误原理机制。我们只需将controller方法的返回值改成返回到/error，相当于发送了error请求，这样BasicErrorController就会根据Request Headers请求头的Accept属性决定发送哪种类型的错误视图，是发json数据，还是发text/html数据。这样就能完成自适应了。

如下：

//2. 方式二：自适应返回数据
        @ExceptionHandler(UserNotExistException.class)
        public String handleException(Exception e, HttpServletRequest request){ 
            Map<String, Object> map = new HashMap<>();
            map.put("code", "user.notexist");
            map.put("message", "用户出错了");
            //实现自适应性，使得能通过发送器/error请求去到错误页面的处理方法
            return "forward:/error";
        }

效果：  
浏览器的错误页面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 1]  
其他客户端的数据  
![在这里插入图片描述][20200721153514176.jpg]

**现在虽然能自适应了，但是状态码却变成了200，而且错误页面也不是我们自己定制的错误页面。**

## 2.4 实现自适应并前往自定制错误页面 ##

### 2.4.1 分析 ###

从前面的效果可以看到状态码变成了200，而不是SpringBoot默认的4xx/5xx。因此我们应该将状态码设置成4xx/5xx再将视图返回出去。

在BasicErrorController中的errorHtml()中有一句是设置状态码，如下：（注意注释）

如上面代码中所述，我们查看getStatus()是什么内容，如下：（注意注释）

protected HttpStatus getStatus(HttpServletRequest request) { 
        //1.原来它是通过request.getAttribute("javax.servlet.error.status_code")获取状态码
    	Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
    	if (statusCode == null) { 
    		return HttpStatus.INTERNAL_SERVER_ERROR;
    	}
    	try { 
    		return HttpStatus.valueOf(statusCode);
    	}
    	catch (Exception ex) { 
    		return HttpStatus.INTERNAL_SERVER_ERROR;
    	}
    }

如上代码所述，由此 **我们可以在异常处理的controller方法中设置状态码，然后这个状态码会被上面的getStatus()方法拿出来，从而实现前往自己的错误页面。**

### 2.4.2 实现 ###

注意注释

//2. 方式二：自适应返回数据
    @ExceptionHandler(UserNotExistException.class)
    public String handleException(Exception e, HttpServletRequest request){ 
        Map<String, Object> map = new HashMap<>();
        /** * 传入自己的错误状态码4xx,5xx,使得springboot去到自己定制的错误页面。 * 否则不会进入定制错误页面的解析流程 */
        /** * SpringBoot是这样取得状态码的： * Integer statusCode = * (Integer) request.getAttribute("javax.servlet.error.status_code"); */
        //因此我们识用request.setAttribute即可
        request.setAttribute("javax.servlet.error.status_code", 500);
        map.put("code", "user.notexist");
        map.put("message", "用户出错了");
        //实现自适应性，使得能通过发送器/error请求去到错误页面的处理方法
        return "forward:/error";
    }

在错误页面显示出code、message，如下:

<h1>status:[[ ${status} ]]</h1>
    <h2>timestamp:[[ ${timestamp} ]]</h2>
    <h2>exception:[[ ${exception} ]]</h2>
    <h2>message:[[ ${message} ]]</h2>
    <h2>company:[[ ${company} ]]</h2>
    <h2>code:[[ ${ext.code} ]]</h2>
    <h2>message:[[ ${ext.message} ]]</h2>

效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 2]  
客户端也没有自己定制的错误数据，如下：  
![在这里插入图片描述][20200721155301866.jpg]  
**总结：能来到自己定制的错误页面，但是与自己定制的错误数据不同**

## 2.5 将自己定制的数据携带出去 ##

### 2.5.1 分析 ###

将数据封装到视图中是发生在BasicErrorController中的errorHtml()以及error()中的，如下：（注意注释）

@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
    	public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) { 
    		HttpStatus status = getStatus(request);
    		//2. model是通过getErrorAtributes()获取到的
    		Map<String, Object> model = Collections
    				.unmodifiableMap(getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
    		response.setStatus(status.value());
    		//1. model被封装ModelAndView对象中
    		ModelAndView modelAndView = resolveErrorView(request, response, status, model);
    		return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
    	}
    
    @RequestMapping
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) { 
    	HttpStatus status = getStatus(request);
    	if (status == HttpStatus.NO_CONTENT) { 
    		return new ResponseEntity<>(status);
    	}
    	//1.也是通过调用getErrorAttributes()获取到数据
    	Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.ALL));
    	return new ResponseEntity<>(body, status);
    }

getErrorAtributes()是AbstractErrorController的方法，而且AbstractErrorController实现了ErrorController接口（这里很关键），如下：

public abstract class AbstractErrorController implements ErrorController { 
    ...
    
    protected Map<String, Object> getErrorAttributes(HttpServletRequest request, 
                                         boolean includeStackTrace) { 
    	WebRequest webRequest = new ServletWebRequest(request);
        //1.当前方法又调用了errorAttributes.getErrorAttributes()获取数据
    	return this.errorAttributes.getErrorAttributes(webRequest, includeStackTrace);
    }

**总结：不管是errorHtml()方法还是error()方法，封装的错误数据是从AbstractErrorController的getErrorAttributes获取到的（而且AbstractErrorController实现了ErrorController接口）。getErrorAttributes()里面又调用了errorAttributes.getErrorAttributes()。**

从上面代码看到，最终是errorAttributes调用getErrorAttributes()获取数据。

看看这个getErrorAttributes()内容，如下：

public interface ErrorAttributes { 
       Map<String, Object> getErrorAttributes(WebRequest webRequest,
                                 boolean includeStackTrace);
    
       Throwable getError(WebRequest webRequest);
    }

如上所示，它是一个接口，将光标放在ErrorAttributes，按ctrl+alt+b查看它的实现类，如下：  
![在这里插入图片描述][20200721161349833.jpg]  
原来DefaultErrorAttributes是它的实现类。

DefaultErrorAttributes里面的getErrorAttributes()方法如下:

public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) { 
        Map<String, Object> errorAttributes = new LinkedHashMap();
        errorAttributes.put("timestamp", new Date());
        this.addStatus(errorAttributes, webRequest);
        this.addErrorDetails(errorAttributes, webRequest, includeStackTrace);
        this.addPath(errorAttributes, webRequest);
        return errorAttributes;
    }

如上所示，最终找到了封装的错误数据是从DefaultErrorAttributes.getErrorAttributes获得的。

**总结：最终最终，封装的错误数据是从DefaultErrorAttributes.getErrorAttributes获得的。**

### 2.5.2 将数据携带出去的过程 ###

SringBoot自动配置是这样做的：  
出现错误，发送/error请求，来到BasicErrorController，根据自适应，去errorHtml()或者error()方法及逆行处理。处理的过程中，响应的数据由 getErrorAttributes()（它是AbstractErrorController（实现了ErrorController接口）的方法） 得到，最终会调用errorAttributes.getErrorAttributes()得到数据。最终最终会调用DefaultErrorAttributes的getErrorAttributes()得到数据。

**总结一**：因此，我们可以**编写AbstractController的子类**，放在容器中，从而将自己定制的错误数据携带出去。但是有更简单的解决方案，后面讲

--------------------

自动配置是以上的做法，我们查看ErrorMvcAutoConfiguration，如下：（注意注释）

@Bean
    //1.当没有ErrorController，才会注册BasicErrorControlelr。才会有以上的阐述的做法。
    @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()));
    }

**总结二**：也就是我们完全可以**编写一个ErrorController的实现类**，放在容器中，从而将自己定制的错误数据携带出去。但是有更简单的解决方案，后面讲

--------------------

因为最终会调用DefaultErrorAttributes的getErrorAttributes()得到数据。所以来看看自动配置类ErrorMvcAutoConfiguration中是怎么注册DefaultErrorAttributes的，如下：

@Bean
    //1.当没有ErrorAttributes时，才会注册DefaultErrorAttributes
    @ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
    public DefaultErrorAttributes errorAttributes() { 
    	return new DefaultErrorAttributes(this.serverProperties.getError().isIncludeException());
    }

综上所述，可以编写一个DefaultErrorAttributes的子类来携带自己定制的错误数据。

**总结三**：**编写一个DefaultErrorAttributes的子类**来携带自己定制的错误数据。

### 2.5.3 将数据携带出去的方案 ###

**方案一**：**编写AbstractController的子类或者编写ErrorController的实现类，放到容器中**。但是编写controlelr过于沉重繁琐，**不推荐**此方案。

**方案二**：**编写DefaultErrorAttributes的子类或者ErrorAttributes的实现类，放到容器中**。**推荐**此方案

### 2.5.4 实现 ###

首先在处理异常的方法（发送/error之前）中将扩展的数据放在ext中，如下:

/** * 定制错误数据 */
    @ControllerAdvice
    public class MyExceptionHandler { 
        //2. 方式二：自适应返回数据
        @ExceptionHandler(UserNotExistException.class)
        public String handleException(Exception e, HttpServletRequest request){ 
            Map<String, Object> map = new HashMap<>();
            /** * 传入自己的错误状态码4xx,5xx,使得springboot去到自己定制的错误页面。 * 否则不会进入定制错误页面的解析流程 */
            /** * SpringBoot是这样取得状态码的： * Integer statusCode = * (Integer) request.getAttribute("javax.servlet.error.status_code"); */
            //因此我们使用request.setAttribute即可
            request.setAttribute("javax.servlet.error.status_code", 500);
            map.put("code", "user.notexist");
            map.put("message", "用户出错了");
            request.setAttribute("ext", map);//将扩展的数据放在ext中
            //实现自适应性，使得能通过发送器/error请求去到错误页面的处理方法
            return "forward:/error";
        }

编写DefaultErrorAttributes子类，获取SpringBoot的默认错误数据以及在异常处理的方法中自己定制的数据，如下:

package com.atguigu.springboot.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;
    
    /** * 给容器中加入我们自己定义的ErrorAttributes */
    @Component
    public class MyErrorAttributes extends DefaultErrorAttributes { 
    
    
        /** * 返回值的map就是页面和json能获得的所有字段,不仅能自适应返回html数据还是json数据， * 还能返回xxxExceptionhandler定制的数据 */
        @Override
        public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) { 
            Map<String, Object> map = super.getErrorAttributes(webRequest, includeStackTrace);
            map.put("company", "atguigu");//这里也可以自定义数据
            //webRequest是将requestAttributes包装起来的对象，而requestAttributes是对request包装起来的对象
            // webRequest.getAttribute()获取在MyExceptionHandler中封装好的数据
            //入参0表示从request域中获取，1表示从session域中获取
            //ext是我们异常处理器MyExceptionHandler携带的数据
            Map<String, Object> ext = (Map<String, Object>) webRequest.getAttribute("ext", 0);
            map.put("ext", ext);
            return map;
        }
    }

效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 3]

## 2.6 解决exception显示不出来 ##

### 2.6.1 情况 ###

在添加了自己编写的MyErrorAttributes的时候，exception对象的信息又显示不出来了。

### 2.6.2 分析 ###

原因肯定是因为调用super.getErrorAttributes(webRequest, includeStackTrace)时，super调用了入参includeException为false的DefaultErrorAttributes构造器。

因此我们需要**传入值为true的includeException到DefaultErrorAttributes构造器中**。

### 2.6.3 解决 ###

在自定义的ErrorAttribute中，通过构造器，将`includeException=true`传给DefaultErrorAttributes

**解决方案如下：**

//MyErrorAttributes是我定义的DefaultErrorAttributes的子类
    public MyErrorAttributes() { 
       //将includeException=true传给DefaultErrorAttributes，使得能获取出exception对象
        super(true);
    }

**完整代码如下：**

package com.atguigu.springboot.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;
    
    /** * 给容器中加入我们自己定义的ErrorAttributes */
    @Component
    public class MyErrorAttributes extends DefaultErrorAttributes { 
    
    
        public MyErrorAttributes() { 
            //将includeException=true传给DefaultErrorAttributes，使得能获取出exception对象
            super(true);
        }
    
        /** * 返回值的map就是页面和json能获得的所有字段,不仅能自适应返回html数据还是json数据， * 还能返回xxxExceptionhandler定制的数据 */
        @Override
        public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) { 
            Map<String, Object> map = super.getErrorAttributes(webRequest, includeStackTrace);
            map.put("company", "atguigu");//这里也可以自定义数据
            //webRequest是将requestAttributes包装起来的对象，而requestAttributes是对request包装起来的对象
            // webRequest.getAttribute()获取在MyExceptionHandler中封装好的数据
            //入参0表示从request域中获取，1表示从session域中获取
            //ext是我们异常处理器MyExceptionHandler携带的数据
            Map<String, Object> ext = (Map<String, Object>) webRequest.getAttribute("ext", 0);
            map.put("ext", ext);
            return map;
        }
    }

## 2.7 总结 ##

定制错误数据总结，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 4]

[Day41]: https://blog.csdn.net/qq_40634846/articleaadetails/107463007
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70]: /images/20230209/39fe3bf3ba5c4b1f80ae2cb2b0f2e07e.png
[SpringBoot_exception]: https://blog.csdn.net/qq_40634846/article/details/107480759
[Day41 1]: https://blog.csdn.net/qq_40634846/article/details/107463007
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 1]: /images/20230209/24979d04d2f2499e9d7a3c1e38823506.png
[20200721153514176.jpg]: /images/20230209/67f81c44104a4c8cb4c171c47d6d2423.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 2]: /images/20230209/2ce3a37592f249bba0da850970e1cee7.png
[20200721155301866.jpg]: https://img-blog.csdnimg.cn/20200721155301866.jpg
[20200721161349833.jpg]: https://img-blog.csdnimg.cn/20200721161349833.jpg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200721172159671.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200721180127201.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNjM0ODQ2,size_16,color_FFFFFF,t_70