文章目录

错误处理机制
- SpringBoot默认的错误处理机制
- 如何定制错误响应：
- - 如何定制错误的页面
  - 如何定制错误的json数据
配置嵌入式Servlet容器
- 如何定制和修改Servlet容器的相关配置
- 注册Servlet三大组件 Servlet、Filter、Listener
- 更换其他嵌入式Servlet容器
- - Jetty
  - Undertow
使用外置的Servlet容器

项目地址：

链接：https://pan.baidu.com/s/15qQUTPeQ4mpg59Q_RgA6bQ

提取码：re3p

复制这段内容后打开百度网盘手机App，操作更方便哦

错误处理机制

SpringBoot默认的错误处理机制

把拦截器关掉，直接在主配置文件注释掉注入就可以直接关掉了
然后我们现在通过浏览器随便访问一个不存在的连接，会出现下面这样的错误提示。

SpringBoot系列（六）--- Web开发（三）错误处理机制配置嵌入式Servlet容器使用外置的Servlet容器
我们可以查看一下浏览器发送请求的请求头，如下：

SpringBoot系列（六）--- Web开发（三）错误处理机制配置嵌入式Servlet容器使用外置的Servlet容器
SpringBoot还另外规定了客户端访问无效链接的错误机制，如果我们通过客户端使用PostMan访问会返回一个默认的json数据：

{
    "timestamp": "2021-02-26T06:42:41.611+00:00",
    "status": 404,
    "error": "Not Found",
    "message": "",
    "path": "/cz/aaa"
}

原理：
可以参照 ErrorMvcAutoConfiguration ；错误处理的自动配置；
给容器中添加了以下组件
- 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;
	}

BasicErrorController ：处理默认/error请求

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {
    
    @RequestMapping(produces = "text/html")//产生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);
	}

ErrorPageCustomizer ：

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

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

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

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

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

如何定制错误响应：

如何定制错误的页面

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

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

SpringBoot系列（六）--- Web开发（三）错误处理机制配置嵌入式Servlet容器使用外置的Servlet容器

页面能获取的信息；
- timestamp：时间戳
- status：状态码
- error：错误提示
- exception：异常对象
- message：异常消息
- errors：JSR303数据校验的错误都在这里

没有模板引擎（模板引擎找不到这个错误页面），静态资源文件夹下找；
以上都没有错误页面，就是默认来到SpringBoot默认的错误提示页面；

SpringBoot系列（六）--- Web开发（三）错误处理机制配置嵌入式Servlet容器使用外置的Servlet容器

如何定制错误的json数据

自定义异常处理&返回定制json数据；转发到/error进行自适应响应效果处理

@ControllerAdvice
public class MyExceptionHandler {
    @ExceptionHandler(UserNotExistException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String,Object> map = new HashMap<>();
        //传入我们自己的错误状态码  4xx 5xx
        /**
         * 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","用户出错啦");

        request.setAttribute("ext",map);
        //转发到/error
        return "forward:/error";
    }
}

将我们的定制数据携带出去；

出现错误以后，会来到/error请求，会被 BasicErrorController 处理，响应出去可以获取的数据是由 getErrorAttributes 得到的（是 AbstractErrorController（ErrorController） 规定的方法）；

编写一个 ErrorController 的实现类【或者是编写 AbstractErrorController 的子类】，放在容器中；
页面上能用的数据，或者是json返回能用的数据都是通过 errorAttributes.getErrorAttributes 得到；容器中 DefaultErrorAttributes.getErrorAttributes()； 默认进行数据处理的；

自定义ErrorAttributes

//给容器中加入我们自己定义的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {

    //返回值的map就是页面和json能获取的所有字段
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
        Map<String, Object> map = super.getErrorAttributes((WebRequest) requestAttributes, includeStackTrace);
        map.put("person","cz");

        //我们的异常处理器携带的数据
        Map<String,Object> ext = (Map<String, Object>) requestAttributes.getAttribute("ext", 0);
        map.put("ext",ext);
        return map;
    }
}

最终的效果：响应是自适应的，可以通过定制ErrorAttributes改变需要返回的内容。就不在只有原先的默认属性了，将我们返回的信息就会是如下：

timestamp：时间戳
tstatus：状态码
terror：错误提示
texception：异常对象
tmessage：异常消息
terrors：JSR303数据校验的错误都在这里
author： cz

配置嵌入式Servlet容器

SpringBoot默认使用Tomcat作为嵌入式的Servlet容器；

SpringBoot系列（六）--- Web开发（三）错误处理机制配置嵌入式Servlet容器使用外置的Servlet容器

如何定制和修改Servlet容器的相关配置

修改和server有关的配置（ServerProperties即也是使用 WebServerFactoryCustomizer ），在主配置文件中可以通过这样的形式来设置

server.port=8081
server.context-path=/cz

server.tomcat.uri-encoding=UTF-8

//通用的Servlet容器设置
server.xxx
//Tomcat的设置
server.tomcat.xxx

除了在主配置文件中进行相关的设置之外，我们还可以通过注册 WebServerFactoryCustomizer 组件来在类中自定义配置，也就是嵌入式的Servlet容器的定制器，中修改Servlet容器的配置

@Bean  //一定要将这个定制器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
    return new EmbeddedServletContainerCustomizer() {

        //定制嵌入式的Servlet容器相关的规则
        @Override
        public void customize(ConfigurableEmbeddedServletContainer container) {
            container.setPort(8083);
        }
    };
}

注册Servlet三大组件 Servlet、Filter、Listener

Servlet三大组件分别是

Servlet、Filter、Listener

，如果我们原先熟悉SpringMVC开发的应该知道，我们在Webapp下面的web.xml中，经常需要配置这三大组件用来过滤监听相关的请求，而在SpringBoot中，由于SpringBoot默认是以

jar

包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，所以并没有没有

web.xml

文件。但是我们依旧可以通过SpringBoot特有的相关注册Bean进行注册，分别是：

ServletRegistrationBean
编写MyServlet

public class MyServlet extends HttpServlet {

    //处理get请求
    public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException{
        doPost(request,response);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException{
        response.getWriter().write("hello Servlet");
    }
}

在MyServerConfig中编写如下：

@Configuration
public class MyServerConfig {

    //注册三大组件
    @Bean
    public ServletRegistrationBean myServlet(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
        //启动顺序
        registrationBean.setLoadOnStartup(1);
        return registrationBean;
    }
 //配置嵌入式的Servlet容器
    @Bean//一定要将这个定制器加入到容器中
    public WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryCustomizer(){
        return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
            //定制嵌入式的Servlet容器相关的规则
            @Override
            public void customize(ConfigurableWebServerFactory factory) {
                factory.setPort(8083);
            }
        };
    }
}

FilterRegistrationBean
编写MyFilter

public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter success....");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

在MyServerConfig中编写如下：

@Bean
    public FilterRegistrationBean myFilter(){
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(new MyFilter());
        registrationBean.setUrlPatterns(Arrays.asList("/hello","/"));
        return registrationBean;
    }

ServletListenerRegistrationBean
编写MyListener

public class MyListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("contextInitialized...web应用启动");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("contextDestroyed...当前web项目销毁");
    }
}

在MyServerConfig中编写如下：

@Bean
    public ServletListenerRegistrationBean myListener(){
        ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
        return registrationBean;
    }

SpringBoot帮我们自动配置SpringMVC的时候，会自动的注册SpringMVC的前端控制器，即 DIspatcherServlet ，我们通过查阅 DispatcherServletAutoConfiguration 发现，会默认拦截， “/” 的所有请求，包括静态资源，但是不拦截jsp请求， /* 会拦截jsp，可以通过 server.servletPath 来修改SpringMVC前端控制器默认拦截的请求路径

更换其他嵌入式Servlet容器

SpringBoot是默认支持Tomcat的，也就是在pom.xml中通过如下依赖引入的

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <!--     引入web模块默认就是使用嵌入式的Tomcat作为Servlet容器；-->
</dependency>

Jetty

<!-- 引入web模块 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
      <exclusion>
         <artifactId>spring-boot-starter-tomcat</artifactId>
         <groupId>org.springframework.boot</groupId>
      </exclusion>
   </exclusions>
</dependency>

<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-jetty</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

Undertow

<!-- 引入web模块 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
      <exclusion>
         <artifactId>spring-boot-starter-tomcat</artifactId>
         <groupId>org.springframework.boot</groupId>
      </exclusion>
   </exclusions>
</dependency>

<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-undertow</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

使用外置的Servlet容器

在我们之前学习的SpringBoot应用，是通过嵌入式Servlet容器，应用打成可执行的jar，这样做的优点显而易见，就是简单、便携，但是缺点就是默认不支持JSP、优化定制比较复杂（使用定制器ServerProperties、自定义WebServerFactoryCustomizer，自己编写嵌入式Servlet容器的创建工厂ConfigurableWebServerFactory）；我们可以使用外置的Servlet容器，也就是外面安装Tomcat，然后应用

war

包的方式打包。

步骤：

必须创建一个war项目，利用idea创建好目录结构

SpringBoot系列（六）--- Web开发（三）错误处理机制配置嵌入式Servlet容器使用外置的Servlet容器
将嵌入式的Tomcat指定为provided；

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>

编写一个 SpringBootServletInitializer 的子类，并调用 configure 方法

public class ServletInitializer extends SpringBootServletInitializer {

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
       //传入SpringBoot应用的主程序
      return application.sources(SpringBoot04WebJspApplication.class);
   }

}

启动服务器就可以使用；

jar包和war包启动的区别

jar包：执行SpringBoot主类的main方法，启动ioc容器，创建嵌入式的Servlet容器；

war包：启动服务器，服务器启动SpringBoot应用通过
SpringBootServletInitializer ，启动ioc容器；

SpringBoot系列（六）--- Web开发（三）错误处理机制配置嵌入式Servlet容器使用外置的Servlet容器

文章目录

错误处理机制

SpringBoot默认的错误处理机制

如何定制错误响应：

如何定制错误的页面

如何定制错误的json数据

配置嵌入式Servlet容器

如何定制和修改Servlet容器的相关配置

注册Servlet三大组件 Servlet、Filter、Listener

更换其他嵌入式Servlet容器

Jetty

Undertow

使用外置的Servlet容器

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method