SpringBoot异常处理

1.基本介绍

默认情况下，SpringBoot提供/error处理所有错误的映射，也就是说当出现错误时，SpringBoot底层会请求转发到/error这个映射路径所关联的页面或者控制器方法。（默认异常处理机制）

要验证这个点，我们只需要设置一个拦截器，当每次请求时都在preHandle()中打印请求URI。在浏览器访问不存在的路径映射时：

• 浏览器：SpringBoot会响应一个"whitelabel"的错误视图，并以HTML格式呈现

  

• 服务器：后台输出请求的URI为

  

• 整个过程：当浏览器访问不存在的路径映射时，就产生了错误。这时 SpringBoot（底层由默认错误视图解析器 DefaultErrorViewResolver 请求转发到 /error 路径关联的页面，该路径若没有被排除，也会经过拦截器处理）会立即去请求 /error 映射关联的资源（默认为"whitelabel" 错误视图），然后返回给浏览器，我们就看到了这个错误视图。

2.默认错误视图解析器

在SpringBoot发现浏览器请求的路径不存在后，底层发生了一系列的操作：

（1）当浏览器访问不存在的路径映射时，就产生了错误

（2）底层由 DefaultErrorViewResolver （默认错误视图解析器）先去遍历项目中设置的所有静态资源路径，尝试从这些静态资源路径中找到/error/404.html文件

//第一次执行resolve()方法：
//这里的viewName就是状态码
private ModelAndView resolve(String viewName, Map<String, Object> model) {
   String errorViewName = "error/" + viewName;//第一次：errorViewName=error/404
   TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName,
         this.applicationContext);
   if (provider != null) {
      return new ModelAndView(errorViewName, model);
   }
   return resolveResource(errorViewName, model);//进入resolveResource()方法
}

遍历项目中设置的所有静态资源路径，尝试从这些静态资源路径中找到/error/404.html文件

//第一次执行resolveResource()方法
private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
   //resources.getStaticLocations()就是项目中的静态资源路径，根据你的设置而变化
   for (String location : this.resources.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）如果找不到，退而求其次，再遍历项目中设置的所有静态资源路径，尝试从这些静态资源路径中找到/error/4xx.html文件

@Override
public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
    //再一次调用resolve()方法
   ModelAndView modelAndView = resolve(String.valueOf(status.value()), model);
   if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
      modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
   }
   return modelAndView;
}

//第二次执行resolve()方法：
//这里的viewName就是状态码
private ModelAndView resolve(String viewName, Map<String, Object> model) {
   String errorViewName = "error/" + viewName;//第二次：errorViewName=/error/4xx
   TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName,
         this.applicationContext);
   if (provider != null) {
      return new ModelAndView(errorViewName, model);
   }
   return resolveResource(errorViewName, model);//进入resolveResource()方法
}

遍历项目中设置的所有静态资源路径，尝试从这些静态资源路径中找到/error/4xx.html文件

//第二次执行resolveResource()方法
private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
    //遍历项目中设置的所有静态资源路径
   for (String location : this.resources.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;
}

示例：

（4）以上两轮都找不到匹配的视图，就执行下面的方法（位于AbstractErrorController.java）：

protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status,
      Map<String, Object> model) {
   for (ErrorViewResolver resolver : this.errorViewResolvers) {
      ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
      if (modelAndView != null) {
         return modelAndView;
      }
   }
   return null;
}

如果以上方法仍然返回null，然后去BasicErrorController.java里执行如下方法：

@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
   HttpStatus status = getStatus(request);
   Map<String, Object> model = Collections
         .unmodifiableMap(getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
   response.setStatus(status.value());
   ModelAndView modelAndView = resolveErrorView(request, response, status, model);
    //modelAndView为null，产生一个默认的新的视图，并返回
   return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
}

（5）此时浏览器接收到的视图就是这个默认的视图

3.拦截器VS过滤器

1. 使用范围不同

   （1）过滤器实现的是javax.servlet.Filter接口，而这个接口是在Servlet规范中定义的，也就是说过滤器Filter的使用依赖于Tomcat等容器，Filter只能在web程序中使用

   （2）拦截器是一个Spring组件，由Spring容器管理，并不依赖Tomcat等容器，是可以单独使用的。它不仅能应用在web程序中，也能用于Application等程序中。

2. 两者的触发时机也不同

   （1）过滤器Filter在请求进入容器后，在进入Servlet之前进行预处理。请求结束则是在servlet处理完以后。

   （2）拦截器Interceptor是在请求进入Servlet之后（即DispatcherServlet，前端控制器），在进入Controller之前进行预处理的，Controller中渲染了对应的视图之后请求结束。

   

3. 过滤器不会处理请求转发，拦截器会处理请求转发（前提是拦截器没有放行此请求）。原因是过滤器处理的是容器接收过来的外部请求，而请求转发是服务器内部，Servlet之间的处理。但拦截器是Spring的一个组件，依然会去处理请求转发，除非请求转发的路径被拦截器放行了。

例子演示1--过滤器与拦截器的执行顺序

我们分别在SpringBoot项目中配置一个过滤器和拦截器，测试它们的执行顺序

（1）创建过滤器

package com.li.thymeleaf.filter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import java.io.IOException;

/**
 * @author 李
 * @version 1.0
 */
@Component
@Slf4j
public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("MyFilter的init()被调用...");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        log.info("MyFilter的doFilter()被调用...");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        log.info("MyFilter的destroy()被调用...");
    }
}

（2）创建拦截器

package com.li.thymeleaf.interceptor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author 李
 * @version 1.0
 */
@Slf4j
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("MyInterceptor的preHandle()被执行...");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("MyInterceptor的postHandle()被执行...");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("MyInterceptor的afterCompletion()被执行...");
    }
}

在配置类中注册拦截器，注入到spring容器中

package com.li.thymeleaf.config;

import com.li.thymeleaf.interceptor.MyInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author 李
 * @version 1.0
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //addInterceptor注册自定义拦截器
        //addPathPatterns指定拦截器规则（拦截所有请求/**）
        registry.addInterceptor(new MyInterceptor())
                .addPathPatterns("/**");

    }
}

（3）浏览器请求某一个资源，后台输出如下：

例子演示2--过滤器不会处理请求转发，拦截器会处理请求转发

我们在浏览器请求一个不存在的资源如http://localhost:8080/xxx，后台输出如下：

这是因为SpringBoot底层处理了/error，进行了请求转发（默认错误视图解析器请求转发到 /error 路径关联的页面）。而过滤器不会处理请求转发，因此可以看到途中只有拦截器被调用了两次。过滤器只在外部请求资源/xxx的时候被调用了一次。

4.自定义异常页面

4.1自定义异常页面说明

Spring Boot Reference Documentation

如果要显示给定状态代码的自定义 HTML 错误页，可以将文件添加到目录中。 错误页面可以是静态 HTML（即，添加到任何静态资源目录下），也可以是使用模板构建的。 文件名应为确切的状态代码或系列掩码。/error

例如，要映射到静态 HTML 文件，目录结构如下所示：404

src/
 +- main/
     +- java/
     |   + <source code>
     +- resources/
         +- public/
             +- error/
             |   +- 404.html
             +- <other public assets>

要使用 Mustache 模板映射所有错误，目录结构如下所示：5xx

src/
 +- main/
     +- java/
     |   + <source code>
     +- resources/
         +- templates/
             +- error/
             |   +- 5xx.mustache
             +- <other templates>

1. 如果发生了404错误，优先匹配 404.html，如果没有，则匹配 4xx.html，再没有则使用默认方式显示错误
2. 500.html 和 5xx.html 是一样的逻辑

4.2应用实例

需求：自定义404.html、500.html、4xx.html、5xx.html，当发生相应错误时，显示自定义的页面信息。

（1）4xx.html，使用thymeleaf标签取出状态码和错误信息，其他页面同理

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>4xx</title>
</head>
<body bgcolor="#cedafe">
<div style="text-align: center">
    <br/><br/><hr/>
    <h1>4xx.html :)</h1>
    状态码：<h1 th:text="${status}"></h1>
    错误信息：<h1 th:text="${error}"></h1>
    <hr/>
</div>
</body>
</html>

（2）5xx.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>5xx</title>
</head>
<body bgcolor="#cedafe">
<div style="text-align: center">
    <br/><br/><hr/>
    <h1>5xx.html :(</h1>
    状态码：<h1 th:text="${status}"></h1>
    错误信息：<h1 th:text="${error}"></h1>
    <hr/>
</div>
</body>
</html>

（3）404.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>404</title>
</head>
<body bgcolor="#cedafe">
<div style="text-align: center">
    <br/><br/><hr/>
    <h1>404 Not Found~~</h1>
    状态码：<h1 th:text="${status}"></h1>
    错误信息：<h1 th:text="${error}"></h1>
    <hr/>
</div>
</body>
</html>

（4）500.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>500</title>
</head>
<body bgcolor="#cedafe">
<div style="text-align: center">
    <br/><br/><hr/>
    <h1>500 服务器内部发生错误 :(</h1>
    状态码：<h1 th:text="${status}"></h1>
    错误信息：<h1 th:text="${error}"></h1>
    <hr/>
</div>
</body>
</html>

（5）模拟500和405错误

package com.li.thymeleaf.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

/**
 * @author 李
 * @version 1.0
 */
@Controller
public class MyErrorController {
    //模拟一个服务器内部错误500
    @GetMapping("/abc")
    public String abc() {
        int i = 10 / 0;
        return "manage";
    }

    //如果get方式请求此路径，会产生405的客户端错误
    @PostMapping("/xyz")
    public String xyz() {
        return "manage";
    }
}

（6）浏览器访问不存在的资源时，显示的是404.html。因为发生错误时首先会在静态资源目录中按照：404.html-->4xx.html的顺序寻找视图。

（7）服务器内部错误-500错误：

（8）如果出现出现的是4开头的错误，就会返回4xx.html

5.全局异常处理

5.1全局异常说明

在 Java 程序发生异常时，可以通过全局异常来捕获处理异常。

在 SpringBoot 中通过 @ControllerAdvice（修饰的类即为全局异常处理器）加上@ExceptionHandler（修饰方法）处理全局异常，它的底层由 ExceptionHandlerExceptionResolver 类支撑。

• 默认异常处理机制，是通过不同的状态码（status），确定要返回的页面
• 而全局异常的处理，则是根据 Java异常种类，来显式指定返回的错误页面
• 全局异常处理优先级 > 默认异常处理优先级

5.2全局异常-应用实例

需求：演示全局异常使用，当发生类似 ArithmeticException、NullPointException 时，不使用默认异常机制（通过状态码）匹配的 xxx.html，而是通过全局异常机制显式指定的错误页面。

（1）创建全局异常处理器 GlobalExceptionHandler.java

package com.li.thymeleaf.exception;

import lombok.extern.slf4j.Slf4j;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

/**
 * @author 李
 * @version 1.0
 */
@ControllerAdvice //标识一个全局异常处理器/对象，标识的类将会被注入到spring容器中
@Slf4j
public class GlobalExceptionHandler {
    /**
     * 编写方法，处理指定异常（这里要处理的异常由你指定）
     * @param e     表示发生异常后传递的异常对象
     * @param model 将异常信息放入model，传递给下一个页面
     * @return
     */
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})
    public String handleException(Exception e, Model model) {
        log.info("异常信息={}", e.getMessage());
        //model的数据会自动放入request域中
        model.addAttribute("msg", e.getMessage());
        return "/error/global";//指定转发到global.html
    }
}

（2）global.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>全局异常</title>
</head>
<body bgcolor="#cedafe">
<div style="text-align: center">
    <br/><br/><hr/>
    <h1>发生了全局异常/错误 :(</h1>
    错误信息：<h1 th:text="${msg}"></h1>
    <hr/>
</div>
</body>
</html>

（3）模拟一个500错误

（4）浏览器访问，可以看到显示的是global.html而不是500.html，因为全局异常处理的优先级高于默认异常处理

5.3拓展

全局异常的两个注解是通过 ExceptionHandlerExceptionResolver 类来支撑的，该类有一个重要方法：doResolveHandlerMethodException()

执行上述方法时，会获取异常发生的方法以及发生的异常。并在返回的模型和视图类也会带有这两个数据，我们可以根据这两个信息进行日志输出，在异常发生时可以迅速定位处理异常：

日志输出：

6.自定义异常的处理

6.1自定义异常说明

1. 如果SpringBoot提供的异常不能满足开发需求，我们也可以自定义异常。

2. 自定义异常处理（若采用默认的处理机制） = 自定义异常类 + @ResponseStatus

   @ResponseStatus 底层是 ResponseStatusExceptionResolve，底层调用 response.sendError(statusCode,resolvedReason);

3. 自定义异常的处理方式：

   • 当抛出自定义异常时，仍然会根据状态码，去匹配使用 xxx.html 显示（默认的异常处理机制）。
   • 或者将自定义异常类，放在你创建的全局异常处理器中进行处理（全局异常处理机制）

6.2自定义异常-应用实例

需求：自定义一个异常类 AccessException，当用户访问某个无权访问的路径时，抛出该异常，显示自定义异常的状态码。

（1）自定义异常类：AccessException.java

package com.li.thymeleaf.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

/**
 * @author 李
 * @version 1.0
 * 自定义的异常类
 * （1）如果继承Exception，属于编译异常
 * （2）如果继承RuntimeException，属于运行异常（一般来说都是继承RuntimeException）
 * （3）@ResponseStatus(value = HttpStatus.FORBIDDEN)
 * 	    指定发生此异常时，通过http协议返回的的状态码（403-Forbidden）
 */
@ResponseStatus(value = HttpStatus.FORBIDDEN)
public class AccessException extends RuntimeException {

    public AccessException() {
    }

    //提供一个构造器，可以指定信息
    public AccessException(String message) {
        super(message);
    }
}

（2）在Controller中模拟发生异常

//模拟发生 AccessException
@GetMapping("/errTest")
public String test(String name) {
    if (!"tom".equals(name)) {
        throw new AccessException();
    }
    return "manage";//视图地址
}

（3）4xx.html（略）

（4）浏览器访问localhost:8080/errTest?name=jack，返回的页面如下：

因为返回的状态码为403，根据默认的异常处理机制，这里会寻找4xx.html页面返回给浏览器。如果是全局异常处理机制的话就会走全局异常处理的流程。

6.3注意事项和使用细节

如果把自定义异常类放在全局异常处理器，因为全局异常处理优先级高，因此会走全局异常的处理机制。

比如在上一个例子中，添加如下代码：

package com.li.thymeleaf.exception;

import ...

/**
 * @author 李
 * @version 1.0
 * 全局异常处理器
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler({AccessException.class})
    public String handleException(Exception e, Model model,HandlerMethod handlerMethod) {
        log.info("出现异常的方法={}", handlerMethod.getMethod());
        log.info("异常信息={}", e.getMessage());
        //model的数据会自动放入request域中
        model.addAttribute("msg", e.getMessage());
        return "/error/global";//指定转发到global.html
    }
}

浏览器访问localhost:8080/errTest?name=jack，返回的页面如下：（global.html）

本栏目推荐文章
• 代码随想录 day18 找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树
• VMware虚拟机安装银河麒麟桌面版V10系统
• Scala编程语言day1
• 2024-1-13 DAY4
• 算法学习Day26组合总和、分割回文串
• socket编程 [补档-2023-07-10]
• Linux的守护进程 [补档-2023-08-10]
• 10-函数进阶-作用域
• 【GDKOI 2024 TG Day2】染色（set） 题解
• 盘点C#最有价值的10个语法糖

SpringBoot day 10springboot day 10 2024 day1 day 10 day 10 day aop 10 03 days drf 10 好友day 10 队列day 10 springboot错误404 10 hot 100 day 10 日记day 10