SpringBoot全局异常处理

2019-10-29

字数统计: 7.6k字 | 阅读时长: 35分

× 文章目录

转载自

https://www.jianshu.com/p/accec85b4039

https://www.cnblogs.com/xuwujing/p/10933082.html

https://www.jianshu.com/p/d458694e739f

前言

在日常web开发中发生了异常，往往是需要通过一个统一的异常处理来保证客户端能够收到友好的提示。

1. Spring Boot默认的异常处理机制

默认情况下，Spring Boot为两种情况提供了不同的响应方式。

一种是浏览器客户端请求一个不存在的页面或服务端处理发生异常时，一般情况下浏览器默认发送的请求头中Accept: text/html，所以Spring Boot默认会响应一个html文档内容，称作“Whitelabel Error Page”。

另一种是使用Postman等调试工具发送请求一个不存在的url或服务端处理发生异常时，Spring Boot会返回类似如下的Json格式字符串信息

{
    "timestamp": "2018-05-12T06:11:45.209+0000",
    "status": 404,
    "error": "Not Found",
    "message": "No message available",
    "path": "/index.html"
}

原理也很简单，Spring Boot 默认提供了程序出错的结果映射路径/error。这个/error请求会在BasicErrorController中处理，其内部是通过判断请求头中的Accept的内容是否为text/html来区分请求是来自客户端浏览器（浏览器通常默认自动发送请求头内容Accept:text/html）还是客户端接口的调用，以此来决定返回页面视图还是 JSON 消息内容。

相关BasicErrorController中代码如下：

2. 如何自定义错误页面

好了，了解完Spring Boot默认的错误机制后，我们来点有意思的，浏览器端访问的话，任何错误Spring Boot返回的都是一个Whitelabel Error Page的错误页面，这个很不友好，所以我们可以自定义下错误页面。

1、先从最简单的开始，直接在/resources/templates下面创建error.html就可以覆盖默认的Whitelabel Error Page的错误页面，我项目用的是thymeleaf模板，对应的error.html代码如下：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
动态error错误页面
<p th:text="${error}"></p>
<p th:text="${status}"></p>
<p th:text="${message}"></p>
</body>
</html>

这样运行的时候，请求一个不存在的页面或服务端处理发生异常时，展示的自定义错误界面如下：

2、此外，如果你想更精细一点，根据不同的状态码返回不同的视图页面，也就是对应的404，500等页面，这里分两种，错误页面可以是静态HTML（即，添加到任何静态资源文件夹下），也可以使用模板构建，文件的名称应该是确切的状态码。

如果只是静态HTML页面，不带错误信息的，在resources/public/下面创建error目录，在error目录下面创建对应的状态码html即可，例如，要将404映射到静态HTML文件，您的文件夹结构如下所示：

静态404.html简单页面如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    静态404错误页面
</body>
</html>

这样访问一个错误路径的时候，就会显示静态404错误页面错误页面

注：这时候如果存在上面第一种介绍的error.html页面，则状态码错误页面将覆盖error.html，具体状态码错误页面优先级比较高.

如果是动态模板页面，可以带上错误信息，在resources/templates/下面创建error目录，在error目录下面命名即可:

这里我们模拟下500错误，控制层代码,模拟一个除0的错误：

@Controller 
public class BaseErrorController extends  AbstractController{ 
private Logger logger = LoggerFactory.getLogger(this.getClass()); 

    @RequestMapping(value="/ex") 
    @ResponseBody 
    public String error(){ 
        int i=5/0; 
        return "ex"; 
    } 
}

500.html代码:

<!DOCTYPE html> 
<html xmlns:th="http://www.thymeleaf.org"> 
<head> 
<meta charset="UTF-8"> 
<title>Title</title> 
</head> 
<body> 
    动态500错误页面 
    <p th:text="${error}"></p> 
    <p th:text="${status}"></p> 
    <p th:text="${message}"></p> 
</body> 
</html>

注:如果同时存在静态页面500.html和动态模板的500.html，则后者覆盖前者。即templates/error/这个的优先级比resources/public/error高。

整体概括上面几种情况，如下：

error.html会覆盖默认的 whitelabel Error Page 错误提示
静态错误页面优先级别比error.html高
动态模板错误页面优先级比静态错误页面高

3、上面介绍的只是最简单的覆盖错误页面的方式来自定义，如果对于某些错误你可能想特殊对待，则可以这样

@Configuration 
public class ContainerConfig { 
    @Bean 
    public EmbeddedServletContainerCustomizer containerCustomizer(){ 
        return new EmbeddedServletContainerCustomizer(){ 
           @Override 
           public void customize(ConfigurableEmbeddedServletContainer container) { 
               container.addErrorPages(new ErrorPage(HttpStatus.INTERNAL_SERVER_ERROR, "/error/500")); 
           } 
        }; 
   } 
}

上面这段代码中HttpStatus.INTERNAL_SERVER_ERROR就是对应500错误码，也就是说程序如果发生500错误，就会将请求转发到/error/500这个映射来，那我们只要实现一个方法是对应这个/error/500映射即可捕获这个异常做出处理.

@RequestMapping("/error/500") 
@ResponseBody 
public String showServerError() { 
    return "server error"; 
}

这里我们就只对500做了特殊处理，并且返还的是字符串，如果想要返回视图，去掉 @ResponseBody注解，并返回对应的视图页面。如果想要对其他状态码自定义映射，在customize方法中添加即可。

上面这种方法虽然我们重写了/500映射，但是有一个问题就是无法获取错误信息，想获取错误信息的话，我们可以继承BasicErrorController或者干脆自己实现ErrorController接口，除了用来响应/error这个错误页面请求，可以提供更多类型的错误格式等（BasicErrorController在上面介绍SpringBoot默认异常机制的时候有提到）

这里博主选择直接继承BasicErrorController，然后把上面 /error/500映射方法添加进来即可.

@Controller
public class MyBasicErrorController extends BasicErrorController {

    public MyBasicErrorController() {
        super(new DefaultErrorAttributes(), new ErrorProperties());
    }

    /**
    * 定义500的ModelAndView
    * @param request
    * @param response
    * @return
    */

    @RequestMapping(produces = "text/html",value = "/500")
    public ModelAndView errorHtml500(HttpServletRequest request,HttpServletResponse response) {
        response.setStatus(getStatus(request).value());
        Map<String, Object> model = getErrorAttributes(request,isIncludeStackTrace(request, MediaType.TEXT_HTML));
        model.put("msg","自定义错误信息");
        return new ModelAndView("error/500", model);
    }

    /**
    * 定义500的错误JSON信息
    * @param request
    * @return
    */

    @RequestMapping(value = "/500")
    @ResponseBody

    public ResponseEntity<Map<String, Object>> error500(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,isIncludeStackTrace(request, MediaType.TEXT_HTML));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String, Object>>(body, status);
    }
}

代码也很简单，只是实现了自定义的500错误的映射解析，分别对浏览器请求以及json请求做了回应。

BasicErrorController默认对应的@RequestMapping是/error，固我们方法里面对应的@RequestMapping(produces = "text/html",value = "/500")实际上完整的映射请求是/error/500，这就跟上面 customize 方法自定义的映射路径对上了。

errorHtml500 方法中，我返回的是模板页面，对应/templates/error/500.html，这里顺便自定义了一个msg信息，在500.html也输出这个信息<p th:text="${msg}"></p>，如果输出结果有这个信息，则表示我们配置正确了。

3. 通过@ControllerAdvice注解来处理异常

Spring Boot提供的ErrorController是一种全局性的容错机制。此外，你还可以用@ControllerAdvice注解和@ExceptionHandler注解实现对指定异常的特殊处理。

这里介绍两种情况：

局部异常处理 @Controller + @ExceptionHandler
全局异常处理 @ControllerAdvice + @ExceptionHandler

1. 局部异常处理 @Controller + @ExceptionHandler

局部异常主要用到的是@ExceptionHandler注解，此注解注解到类的方法上，当此注解里定义的异常抛出时，此方法会被执行。如果@ExceptionHandler所在的类是@Controller，则此方法只作用在此类。如果@ExceptionHandler所在的类带有@ControllerAdvice注解，则此方法会作用在全局。

该注解用于标注处理方法处理那些特定的异常。被该注解标注的方法可以有以下任意顺序的参数类型：

Throwable、Exception 等异常对象；
ServletRequest、HttpServletRequest、ServletResponse、HttpServletResponse；
HttpSession 等会话对象；
org.springframework.web.context.request.WebRequest；
java.util.Locale；
java.io.InputStream、java.io.Reader；
java.io.OutputStream、java.io.Writer；
org.springframework.ui.Model；

并且被该注解标注的方法可以有以下的返回值类型可选：

ModelAndView；
org.springframework.ui.Model；
java.util.Map；
org.springframework.web.servlet.View；
@ResponseBody 注解标注的任意对象；
HttpEntity or ResponseEntity；
void；

以上罗列的不完全，更加详细的信息可参考：Spring ExceptionHandler.

举个简单例子，这里我们对除0异常用@ExceptionHandler来捕捉。

@Controller
public class BaseErrorController extends  AbstractController{ 
    private Logger logger = LoggerFactory.getLogger(this.getClass()); 

    @RequestMapping(value="/ex") 
    @ResponseBody 
    public String error(){ 
        int i=5/0; 
        return "ex"; 
  } 

    //局部异常处理 
    @ExceptionHandler(Exception.class) 
    @ResponseBody 
    public String exHandler(Exception e){ 
      // 判断发生异常的类型是除0异常则做出响应 
      if(e instanceof ArithmeticException){ 
          return "发生了除0异常"; 
      } 
      // 未知的异常做出响应 
      return "发生了未知异常"; 
    }
}

2. 全局异常处理 @ControllerAdvice + @ExceptionHandler

在spring 3.2中，新增了@ControllerAdvice 注解，可以用于定义@ExceptionHandler、@InitBinder、@ModelAttribute，并应用到所有@RequestMapping中。

简单的说，进入Controller层的错误才会由@ControllerAdvice处理，拦截器抛出的错误以及访问错误地址的情况@ControllerAdvice处理不了，由SpringBoot默认的异常处理机制处理。

我们实际开发中，如果是要实现RESTful API，那么默认的JSON错误信息就不是我们想要的，这时候就需要统一一下JSON格式，所以需要封装一下。

/**
* 返回数据
*/
public class AjaxObject extends HashMap<String, Object> {
    private static final long serialVersionUID = 1L;

    public AjaxObject() {
        put("code", 0);
    }

    public static AjaxObject error() {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
    }

    public static AjaxObject error(String msg) {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
    }

    public static AjaxObject error(int code, String msg) {
        AjaxObject r = new AjaxObject();
        r.put("code", code);
        r.put("msg", msg);
        return r;
    }

    public static AjaxObject ok(String msg) {
        AjaxObject r = new AjaxObject();
        r.put("msg", msg);
        return r;
    }

    public static AjaxObject ok(Map<String, Object> map) {
        AjaxObject r = new AjaxObject();
        r.putAll(map);
        return r;
    }

    public static AjaxObject ok() {
        return new AjaxObject();
    }

    public AjaxObject put(String key, Object value) {
        super.put(key, value);
        return this;
    }

    public AjaxObject data(Object value) {
        super.put("data", value);
        return this;
    }

    public static AjaxObject apiError(String msg) {
        return error(1, msg);
    }
}

上面这个AjaxObject就是我平时用的，如果是正确情况返回的就是：

{
    code：0，
    msg：“获取列表成功”，
    data：{ 
        queryList :[]
    }
}

正确默认code返回0，data里面可以是集合，也可以是对象，如果是异常情况，返回的json则是：

{
    code：500，
    msg：“未知异常，请联系管理员”
}

然后创建一个自定义的异常类：

public class BusinessException extends RuntimeException implements Serializable {

    private static final long serialVersionUID = 1L;
    private String msg;
    private int code = 500;

    public BusinessException(String msg) {
        super(msg);
        this.msg = msg;
    }

    public BusinessException(String msg, Throwable e) {
        super(msg, e);
        this.msg = msg;
    }

    public BusinessException(int code,String msg) {
        super(msg);
        this.msg = msg;
        this.code = code;
    }

    public BusinessException(String msg, int code, Throwable e) {
        super(msg, e);
        this.msg = msg;
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

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

spring 对于 RuntimeException 异常才会进行事务回滚

Controler中添加一个json映射，用来处理这个异常

@Controller
public class BaseErrorController{
    @RequestMapping("/json")
    public void json(ModelMap modelMap) {
        System.out.println(modelMap.get("author"));
        int i=5/0;
    }
}

最后创建这个全局异常处理类：

/**
 * 异常处理器
 */
@RestControllerAdvice
public class BusinessExceptionHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 应用到所有@RequestMapping注解方法，在其执行之前初始化数据绑定器
     * @param binder
     */
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        System.out.println("请求有参数才进来");
    }

    /**
     * 把值绑定到Model中，使全局@RequestMapping可以获取到该值
     * @param model
     */
    @ModelAttribute
    public void addAttributes(Model model) {
        model.addAttribute("author", "嘟嘟MD");
    }

    @ExceptionHandler(Exception.class)
    public Object handleException(Exception e,HttpServletRequest req){
        AjaxObject r = new AjaxObject();
        //业务异常
        if(e instanceof BusinessException){
            r.put("code", ((BusinessException) e).getCode());
            r.put("msg", ((BusinessException) e).getMsg());
        }else{//系统异常
            r.put("code","500");
            r.put("msg","未知异常，请联系管理员");
        }

        //使用HttpServletRequest中的header检测请求是否为ajax, 如果是ajax则返回json, 如果为非ajax则返回view(即ModelAndView)
        String contentTypeHeader = req.getHeader("Content-Type");
        String acceptHeader = req.getHeader("Accept");
        String xRequestedWith = req.getHeader("X-Requested-With");
        if ((contentTypeHeader != null && contentTypeHeader.contains("application/json"))
                || (acceptHeader != null && acceptHeader.contains("application/json"))
                || "XMLHttpRequest".equalsIgnoreCase(xRequestedWith)) {
            return r;
        } else {
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("msg", e.getMessage());
            modelAndView.addObject("url", req.getRequestURL());
            modelAndView.addObject("stackTrace", e.getStackTrace());
            modelAndView.setViewName("error");
            return modelAndView;
        }
    }
}

@ExceptionHandler 拦截了异常，我们可以通过该注解实现自定义异常处理。其中，@ExceptionHandler 配置的 value 指定需要拦截的异常类型，上面我配置了拦截Exception，
再根据不同异常类型返回不同的相应，最后添加判断，如果是Ajax请求，则返回json,如果是非ajax则返回view，这里是返回到error.html页面。

为了展示错误的时候更友好，我封装了下error.html,不仅展示了错误，还添加了跳转百度谷歌以及StackOverFlow的按钮，如下：

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org" layout:decorator="layout">
<head>
    <title>Spring Boot管理后台</title>
    <script type="text/javascript">
    </script>
</head>
<body>
<div layout:fragment="content" th:remove="tag">
    <div  id="navbar">
        <h1>系统异常统一处理</h1>
        <h3 th:text="'错误信息：'+${msg}"></h3>
        <h3 th:text="'请求地址：'+${url}"></h3>

        <h2>Debug</h2>
        <a th:href="@{'https://www.google.com/webhp?hl=zh-CN#safe=strict&hl=zh-CN&q='+${msg}}"
           class="btn btn-primary btn-lg" target="_blank" id="Google">Google</a>
        <a th:href="@{'https://www.baidu.com/s?wd='+${msg}}" class="btn btn-info btn-lg"  target="_blank" id="Baidu">Baidu</a>
        <a th:href="@{'http://stackoverflow.com/search?q='+${msg}}"
           class="btn btn-default btn-lg"  target="_blank" id="StackOverFlow">StackOverFlow</a>
        <h2>异常堆栈跟踪日志StackTrace</h2>
        <div th:each="line:${stackTrace}">
            <div th:text="${line}"></div>
        </div>
    </div>
</div>
<div layout:fragment="js" th:remove="tag">
</div>
</body>
</html>

如果是ajax请求，返回的就是错误：

1	{ "msg":"未知异常，请联系管理员", "code":500 }

这里我给带@ModelAttribute注解的方法通过Model设置了author值，在json映射方法中通过 ModelMwap 获取到改值。

认真的你可能发现，全局异常类我用的是@RestControllerAdvice，而不是@ControllerAdvice，因为这里返回的主要是json格式，这样可以少写一个@ResponseBody。

3. 小结

本文中处理异常的顺序会是这样，当发送一个请求：

拦截器那边先判断是否登录，没有则返回登录页。
在进入Controller之前，譬如请求一个不存在的地址，返回404错误界面。
在执行@RequestMapping时，发现的各种错误（譬如数据库报错、请求参数格式错误/缺失/值非法等）统一由@ControllerAdvice处理，根据是否Ajax返回json或者view。

4. 实战一

1. 依赖

spring-boot-starter-parent
spring-boot-starter-web
spring-boot-starter-test
fastjson

配置文件这块基本不需要更改，全局异常的处理只需在代码中实现即可。

2. 代码编写

SpringBoot的项目已经对有一定的异常处理了，但是对于我们开发者而言可能就不太合适了，因此我们需要对这些异常进行统一的捕获并处理。SpringBoot中有一个ControllerAdvice的注解，使用该注解表示开启了全局异常的捕获，我们只需在自定义一个方法使用ExceptionHandler注解然后定义捕获异常的类型即可对这些捕获的异常进行统一的处理。

@ControllerAdvice  
public  class MyExceptionHandler { 

    @ExceptionHandler(value =Exception.class) 
    public String exceptionHandler(Exception e)
        System.out.println("未知异常！原因是:"+e);
        return e.getMessage(); 
    } 
}

对捕获的异常进行简单的二次处理，返回异常的信息，虽然这种能够让我们知道异常的原因，但是在很多的情况下来说，可能还是不够人性化，不符合我们的要求。那么我们这里可以通过自定义的异常类以及枚举类来实现我们想要的效果。

3. 自定义基础接口类

首先定义一个基础的接口类，自定义的错误描述枚举类需实现该接口。

public interface BaseErrorInfoInterface{
    // 错误码
    String getResultCode();
    // 错误描述
    String getResultMsg();
}

4. 自定义枚举类

然后我们这里在自定义一个枚举类，并实现该接口。

public enum CommonEnum implements BaseErrorInfoInterface{
    
    // 数据操作错误定义
    SUCCESS("200","成功"),
    BODY_NOT_MATCH("400","请求的数据格式不符!"),
    SIGNATURE_NOT_MATCH("401","请求的数字签名不匹配!"),
    NOT_FOUND("404", "未找到该资源!"),
    INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
    SERVER_BUSY("503","服务器正忙，请稍后再试!");
    
    // 错误码
    private String resultCode;
    
    // 错误描述
    private String resultMsg;
    
    CommonEnum(String resultCode, String resultMsg) {
                this.resultCode = resultCode;
                this.resultMsg = resultMsg;
    }
    
    @Override
    public String getResultCode() {
            return resultCode;
    }
    
    @Override
    public String getResultMsg() {
            return resultMsg;
    }

}

5. 自定义异常类

然后我们在来自定义一个异常类，用于处理我们发生的业务异常。

public class BizException extends RuntimeException{
    
    private  static  final  long serialVersionUID = 1L;
    
    // 错误码
    protected String errorCode;
    
    // 错误信息
    protected String errorMsg;
    
    public BizException() {
        super();
    }
    
    public BizException(BaseErrorInfoInterface errorInfoInterface) {
        super(errorInfoInterface.getResultCode());
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }
    
    public  BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause）{
        super(errorInfoInterface.getResultCode(), cause);
        this.errorCode = errorInfoInterface.getResultCode();
        this.errorMsg = errorInfoInterface.getResultMsg();
    }
    
    public BizException(String errorMsg) {
        super(errorMsg); 
        this.errorMsg = errorMsg;
    }
    
    public BizException(String errorCode, String errorMsg) {
        super(errorCode); 
        this.errorCode = errorCode; 
        this.errorMsg = errorMsg;
    }
    
    public BizException(String errorCode, String errorMsg, Throwable cause) { 
        super(errorCode, cause);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }
    
    public String getErrorCode() { 
        return errorCode; 
    }
    
    public void setErrorCode(String errorCode) { 
        this.errorCode = errorCode; 
    }
    
    public String getErrorMsg() { 
        return errorMsg; 
    }
    
    public void setErrorMsg(String errorMsg) { 
        this.errorMsg = errorMsg; 
    }
    
    public String getMessage() { 
        return errorMsg; 
    }
    
    @Override  
    public Throwable fillInStackTrace() {
        return  this; 
    }

}

6. 自定义数据格式

顺便这里我们定义一下数据的传输格式。

public  class  ResultBody {
    
    // 响应代码
    private String code;
    
    // 响应消息
    private String message;
    
    // 响应结果
    private Object result;
    
    public ResultBody() {}
    
    public ResultBody(BaseErrorInfoInterface errorInfo) {
        this.code = errorInfo.getResultCode(); 
        this.message = errorInfo.getResultMsg(); 
    }
    
    public String getCode() { 
        return code; 
    }
    
    public void setCode(String code) { 
        this.code = code; 
    }
    
    public String getMessage() { 
        return message; 
    }
    
    public void setMessage(String message) { 
        this.message = message; 
    }
    
    public Object getResult() {
        return result; 
    }
    
    public void setResult(Object result) { 
        this.result = result; 
    }
    
    // 成功
    public static ResultBody success() { 
        return success(null); 
    }
    
    // 成功
    public static ResultBody success(Object data) { 
        ResultBody rb = new ResultBody();
        rb.setCode(CommonEnum.SUCCESS.getResultCode());
        rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
        rb.setResult(data); return rb;
    }
    
    // 失败
    
    public static ResultBody error(BaseErrorInfoInterface errorInfo) { 
        ResultBody rb = new ResultBody();
        rb.setCode(errorInfo.getResultCode());
        rb.setMessage(errorInfo.getResultMsg());
        rb.setResult(null); return rb; 
    }
    
    // 失败
    public static ResultBody error(String code, String message) {
        ResultBody rb = new ResultBody(); 
        rb.setCode(code);
        rb.setMessage(message); 
        rb.setResult(null); 
        return rb; 
    }
    
    public static ResultBody error( String message) {
        ResultBody rb = new ResultBody(); 
        rb.setCode("-1"); 
        rb.setMessage(message); 
        rb.setResult(null); 
        return rb; 
    }
    
    @Override 
    public String toString() { 
        return JSONObject.toJSONString(this); 
    }
    
}

7. 自定义全局异常处理类

最后我们在来编写一个自定义全局异常处理的类。

@ControllerAdvice 
public  class GlobalExceptionHandler {

    private  static  final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    // 处理自定义的业务异常
    @ExceptionHandler(value = BizException.class) 
    @ResponseBody
    public ResultBody bizExceptionHandler(HttpServletRequest req, BizException e){ 
        logger.error("发生业务异常！原因是：{}",e.getErrorMsg()); 
        return ResultBody.error(e.getErrorCode(),e.getErrorMsg());
    }
    
    // 处理空指针的异常
    @ExceptionHandler(value =NullPointerException.class)
    @ResponseBody  
    public ResultBody exceptionHandler(HttpServletRequest req, NullPointerException e){ 
        logger.error("发生空指针异常！原因是:",e); 
        return ResultBody.error(CommonEnum.BODY_NOT_MATCH); 
    }
    
    // 处理其他异常
    @ExceptionHandler(value =Exception.class) 
    @ResponseBody 
    public ResultBody exceptionHandler(HttpServletRequest req, Exception e){ 
        logger.error("未知异常！原因是:",e);
        return ResultBody.error(CommonEnum.INTERNAL_SERVER_ERROR);
    }
}

因为这里我们只是用于做全局异常处理的功能实现以及测试，所以这里我们只需在添加一个实体类和一个控制层类即可。

8. 实体类

万能的用户表

@Data
public  class User implements Serializable{ 
    private  static  final  long serialVersionUID = 1L;
    
    private int id;
    private String name;
    private int age;

9. Controller控制层

控制层这边也比较简单，使用Restful风格实现的CRUD功能，不同的是这里我故意弄出了一些异常，好让这些异常被捕获到然后处理。这些异常中，有自定义的异常抛出，也有空指针的异常抛出，当然也有不可预知的异常抛出(这里我用类型转换异常代替)，那么我们在完成代码编写之后，看看这些异常是否能够被捕获处理成功吧！

@RestController  
@RequestMapping(value = "/api") 
public  class UserRestController {

    @PostMapping("/user") 
    public boolean insert(@RequestBody User user) { 
        System.out.println("开始新增..."); 
        //如果姓名为空就手动抛出一个自定义的异常！  
        if(user.getName()==null){
            throw  new BizException("-1","用户姓名不能为空！");
        } 
        return  true;
    }
    
    @PutMapping("/user") 
    public boolean update(@RequestBody User user) { 
        System.out.println("开始更新..."); 
        //这里故意造成一个空指针的异常，并且不进行处理 
        String str=null; 
        str.equals("111"); 
        return  true; 
    }
    
    @DeleteMapping("/user") 
    public boolean delete(@RequestBody User user) { 
        System.out.println("开始删除...");
        //这里故意造成一个异常，并且不进行处理 
        Integer.parseInt("abc123"); return  true;
    }
    
    @GetMapping("/user") 
    public List<User> findByUser(User user) { 
        System.out.println("开始查询..."); 
        List<User> userList =new ArrayList<>(); 
        User user2=new User(); 
        user2.setId(1L); 
        user2.setName("xuwujing"); 
        user2.setAge(18); 
        userList.add(user2); 
        return userList; 
    }
}

10. App入口

@SpringBootApplication 
public  class App { 
    public  static  void main( String[] args ) { 
        SpringApplication.run(App.class, args); 
        System.out.println("程序正在运行..."); 
    } 
}

11. 功能测试

我们成功启动该程序之后，使用Postman工具来进行接口测试。

首先进行查询，查看程序正常运行是否ok，使用GET 方式进行请求。

1
2
3

GET http://localhost:8181/api/user
# 返回参数
{"id":1,"name":"xuwujing","age":18}

可以看到程序正常返回，并没有因自定义的全局异常而影响。

然后我们再来测试下自定义的异常是否能够被正确的捕获并处理。

使用POST方式进行请求

POST http://localhost:8181/api/user
# Body参数为
{"id":1,"age":18}
# 返回参数
{"code":"-1","message":"用户姓名不能为空！","result":null}

可以看出将我们抛出的异常进行数据封装，然后将异常返回出来。

然后我们再来测试下空指针异常是否能够被正确的捕获并处理。在自定义全局异常中，我们除了定义空指针的异常处理，也定义最高级别之一的Exception异常，那么这里发生了空指针异常之后，它是回优先使用哪一个呢？这里我们来测试下。

使用PUT方式进行请求。

PUT http://localhost:8181/api/user
# Body参数为
{"id":1,"age":18}
# 返回参数为
{"code":"400","message":"请求的数据格式不符!","result":null}

我们可以看到这里的的确是返回空指针的异常护理，可以得出全局异常处理优先处理子类的异常。

那么我们在来试试未指定其异常的处理，看该异常是否能够被捕获。

使用DELETE方式进行请求。

DELETE http://localhost:8181/api/user
# Body参数为
{"id":1}
# 返回参数为
{"code":"500","message":"服务器内部错误!","result":null}

5 实战二

1. 全局异常

将返回值统一封装时我们没有考虑当接口抛出异常的情况。当接口抛出异常时让用户直接看到服务端的异常肯定是不够友好的，而我们也不可能每一个接口都去try/catch进行处理，此时只需要使用@ExceptionHandler注解即可无感知的全局统一处理异常。

import com.chehejia.framework.beans.exception.BizException;
import com.chehejia.framework.beans.model.Response;
import com.saos.wo.consts.StatusCode;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @author jack-cooper
 * @version 1.0.0
 * @ClassName GlobalExceptionHandler.java
 * @Description 全局异常处理器
 * @createTime 2019年11月01日 09:08:00
 */
@Slf4j
@RestController
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Response defaultErrorHandler(HttpServletRequest req, Exception e) throws Exception {
        log.error("---BaseException Handler---Host {} invokes url {} ERROR: ",req.getRemoteHost(),req.getRequestURL(),e);
        return Response.fail(StatusCode.SYS_SERVICE_ERROR.getCode(), ExceptionUtils.getFullStackTrace(e));
    }

    @ExceptionHandler(value = BizException.class)
    @ResponseBody
    public Response jsonErrorHandle(HttpServletRequest req, BizException e) {
        log.warn("---BaseException Handler---Host {} invokes url {}  ",req.getRemoteHost(),req.getRequestURL());
        return Response.fail(e.getCode(),e.getMessage());
    }

}

2. 全局响应

在前后端分离大行其道的今天，有一个统一的返回值格式不仅能使我们的接口看起来更漂亮，而且还可以使前端可以统一处理很多东西，避免很多问题的产生。下面通过实现SpringBoot中为我们提供好的解决方法，只需要在项目中加上以下代码，即可实现相关功能。主要是实现接口ResponseBodyAdvice

import com.chehejia.framework.beans.model.Response;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

/**
 * @author jack-cooper
 * @version 1.0.0
 * @ClassName GlobalReturnConfig.java
 * @Description 全局返回统一封装
 * @createTime 2019年11月08日 15:51:00
 */
@EnableWebMvc
@Configuration
@RestControllerAdvice
public class GlobalResponseAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        if (body instanceof Response) {
            return body;
        } else {
            return Response.success(body);
        }
    }
}

3. 统一返回对象

import com.chehejia.framework.beans.exception.BizException;
import com.chehejia.framework.beans.exception.BizRuntimeException;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import java.io.Serializable;
import java.util.Optional;
import java.util.function.Supplier;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@ApiModel("统一返回")
public class Response<T> implements Serializable {

    private static final long serialVersionUID = -6724401478874316373L;

    public static <T> Response<T> success() {
        return Response.success(RestfulCode.SUCCESS, null, null);
    }

    public static <T> Response<T> success(T data) {
        return Response.success(RestfulCode.SUCCESS, null, data);
    }

    public static <T> Response<T> success(RestfulCode rc, T data) {
        return Response.success(rc, null, data);
    }

    public static <T> Response<T> success(RestfulCode rc, String msg, T data) {
        return Response.<T>builder()
                .code(rc.getCode())
                .msg(Optional.ofNullable(msg).orElse(rc.getMessage()))
                .data(data)
                .build();
    }

    public static <T> Response<T> fail(BizException e) {
        return Response.<T>builder()
                .code(e.getCode())
                .msg(e.getMessage())
                .build();
    }

    public static <T> Response<T> fail(BizRuntimeException e) {
        return Response.<T>builder()
                .code(e.getCode())
                .msg(e.getMessage())
                .build();
    }

    public static <T> Response<T> fail(Integer code, String msg) {
        return Response.<T>builder()
                .code(code)
                .msg(msg)
                .build();
    }

    public static <T> Response<T> fail(RestfulCode rs) {
        return Response.<T>builder()
                .code(rs.getCode())
                .msg(rs.getMessage())
                .build();
    }

    public static <T> Response<T> fail(Integer code, String msg, T data) {
        return Response.<T>builder()
                .code(code)
                .msg(msg)
                .data(data)
                .build();
    }

    public static <T> Response<T> fail(RestfulCode rs, T data) {
        return Response.<T>builder()
                .code(rs.getCode())
                .msg(rs.getMessage())
                .data(data)
                .build();
    }

    public static <T> Response<T> fail(Response source) {
        return Response.<T>builder()
                .code(source.getCode())
                .msg(source.getMsg())
                .build();
    }

    /**
     * 判断返回码是否相同，与是否成功无关
     *
     * @param restfulCode
     *
     * @return
     */
    public boolean codeEquals(RestfulCode restfulCode) {
        if (this.getCode() == null || restfulCode == null) {
            return false;
        }
        return this.getCode().equals(restfulCode.getCode());
    }

    /**
     * 如果成功则返回data，失败则抛出异常
     * @return data
     * @throws BizRuntimeException 失败抛出
     */
    public T orFailThrow() throws BizRuntimeException {
        if (isSuccess()) {
            return getData();
        } else {
            throw new BizRuntimeException(getCode(), getMsg());
        }
    }

    public <X extends Throwable> T orFailThrow(Supplier<? extends X> supplier) throws X {
        if (isSuccess()) {
            return getData();
        } else {
            throw supplier.get();
        }
    }

    /**
     * 期望有data
     * @return data
     * @throws BizRuntimeException 失败或data为null 抛出异常
     */
    public T forceData(RestfulCode error) throws BizRuntimeException {
        return Optional.ofNullable(orFailThrow()).orElseThrow(() -> new BizRuntimeException(error));
    }

    public boolean isSuccess() {
        return RestfulCode.SUCCESS.isEquals(getCode());
    }

    /**
     * 状态码
     */
    @ApiModelProperty("状态码")
    private Integer code = RestfulCode.SUCCESS.getCode();

    /**
     * 描述信息
     */
    @ApiModelProperty("描述信息")
    private String msg = RestfulCode.SUCCESS.getMessage();

    /**
     * 返回数据
     */
    @ApiModelProperty("返回数据")
    private T data;
}