SpringBoot(七) -- 嵌入式Servlet容器

一.嵌入式Servlet容器
  在传统的开发中,我们在完成开发后需要将项目打成war包,在外部配置好TomCat容器,而这个TomCat就是Servlet容器.在使用SpringBoot开发时,我们无需再外部配置Servlet容器,使用的是嵌入式的Servlet容器(TomCat).如果我们使用嵌入式的Servlet容器,存在以下问题:
  1.如果我们是在外部安装了TomCat,如果我们想要进行自定义的配置优化,可以在其conf文件夹下修改配置文件来实现.在使用内置Servlet容器时,我们可以使用如下方法来修改Servlet容器的相关配置:
  (1)例如我们可以使用server.port=80来修改我们的启用端口号为80;及我们可以通过修改和Server有关的配置来实现(ServerProperties)
  (2)修改通用的设置server.XXX;
  (3)修改和Tomcat相关的设置:server.tomcat.xxx
  2.我们可以编写一个EmbeddedServletContainerCustomizer(嵌入式Servlet容器的定制器):

 1     @Bean
 2     public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
 3         return new EmbeddedServletContainerCustomizer() {
 4             //定制嵌入式的Servlet容器相关的规则
 5             @Override
 6             public void customize(ConfigurableEmbeddedServletContainer container) {
 7                     container.setPort(8083);        //设置端口为8083
 8             }
 9         };
10     }

二.注册Servlet Filter Listener
  我们可以分别使用ServletRegisterationBean FilterRegisterationBean ServletListenerRegisterationBean完成这三大组件的注册

--Servlet

 1 package com.zhiyun.springboot.web_restfulcrud.servlet;
 2
 3 import javax.servlet.ServletException;
 4 import javax.servlet.http.HttpServlet;
 5 import javax.servlet.http.HttpServletRequest;
 6 import javax.servlet.http.HttpServletResponse;
 7 import java.io.IOException;
 8
 9 /**
10  * @author : S K Y
11  * @version :0.0.1
12  */
13 public class MyServlet extends HttpServlet {
14     //处理get()请求
15     @Override
16     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
17         doPost(req, resp);
18     }
19
20     @Override
21     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
22         resp.getWriter().write("Hello MyServlet");
23     }
24 }
 1 package com.zhiyun.springboot.web_restfulcrud.config;
 2
 3 import com.zhiyun.springboot.web_restfulcrud.servlet.MyServlet;
 4 import org.springframework.boot.web.servlet.ServletRegistrationBean;
 5 import org.springframework.context.annotation.Bean;
 6 import org.springframework.context.annotation.Configuration;
 7
 8 /**
 9  * @author : S K Y
10  * @version :0.0.1
11  */
12 @Configuration
13 public class MyServerConfig {
14     //注册三大组件
15     @Bean
16     public ServletRegistrationBean servletRegistrationBean() {
17         return new ServletRegistrationBean(new MyServlet(), "/myServlet");
18     }
19 }

--Filter

 1 package com.zhiyun.springboot.web_restfulcrud.filter;
 2
 3 import org.slf4j.Logger;
 4 import org.slf4j.LoggerFactory;
 5
 6 import javax.servlet.*;
 7 import java.io.IOException;
 8
 9 /**
10  * @author : S K Y
11  * @version :0.0.1
12  */
13 public class MyFilter implements Filter {
14     private Logger logger = LoggerFactory.getLogger(this.getClass());
15
16     @Override
17     public void init(FilterConfig filterConfig) throws ServletException {
18
19     }
20
21     @Override
22     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
23         logger.debug("自定义的Filter启用了!");
24         chain.doFilter(request, response);
25     }
26
27     @Override
28     public void destroy() {
29
30     }
31 }
1     @Bean
2     public FilterRegistrationBean filterRegistrationBean() {
3         FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
4         filterRegistrationBean.setFilter(new MyFilter());
5         filterRegistrationBean.setUrlPatterns(Arrays.asList("/hello", "/myServlet"));
6         return filterRegistrationBean;
7     }

--Listener

 1 package com.zhiyun.springboot.web_restfulcrud.listener;
 2
 3 import org.slf4j.Logger;
 4 import org.slf4j.LoggerFactory;
 5
 6 import javax.servlet.ServletContextEvent;
 7 import javax.servlet.ServletContextListener;
 8
 9 /**
10  * @author : S K Y
11  * @version :0.0.1
12  */
13 public class MyListener implements ServletContextListener {
14     private Logger logger = LoggerFactory.getLogger(this.getClass());
15
16     @Override
17     public void contextInitialized(ServletContextEvent sce) {
18         logger.debug("contextInitialized...当前web应用启动了");
19     }
20
21     @Override
22     public void contextDestroyed(ServletContextEvent sce) {
23         logger.debug("contextDestroyed...当前web项目销毁");
24     }
25 }
1     @Bean
2     public ServletListenerRegistrationBean servletListenerRegistrationBean() {
3         return new ServletListenerRegistrationBean<>(new MyListener());
4     }

--由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用,没有web.xml文件.注册三大组件可以采取这样的方法.
--SpringBoot帮我们自动配置SpringMVC的是惠普,自动的注册SpringMVC的前端控制器:DispatcherServlet.默认拦截"/"所有资源包括静态资源,但是不拦截JSP请求,"/*"会拦截JSP.我们可以通过server.servletPath来修改SpringMVC前端控制器默认拦截的请求路径.

三.使用其他的嵌入式容器
  SpringBoot还支持Jetty(适合开发长连接的应用,例如聊天室),Undertow(不支持JSP):

  1.默认使用了TomCat
  2.切换使用其他Servlet容器,首先需要排除其中的spring-boot-starter-web -->spring-boot-starter-tomcat依赖,而后则可以引入其他的Servlet容器

 1         <!--引入Web模块-->
 2         <dependency>
 3             <groupId>org.springframework.boot</groupId>
 4             <artifactId>spring-boot-starter-web</artifactId>
 5             <exclusions>
 6                 <exclusion>
 7                     <artifactId>spring-boot-starter-tomcat</artifactId>
 8                     <groupId>org.springframework.boot</groupId>
 9                 </exclusion>
10             </exclusions>
11         </dependency>
12
13         <!--引入其他的Servlet容器-->
14         <dependency>
15             <artifactId>spring-boot-starter-jetty</artifactId>
16             <groupId>org.springframework.boot</groupId>
17         </dependency>

四.嵌入式Servlet容器的自动配置原理
  在SpringBoot中拥有如下自动配置类EmbeddedServletContainerAutoConfiguration:

1 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
2 @Configuration
3 @ConditionalOnWebApplication
4 @Import(BeanPostProcessorsRegistrar.class)
5 public class EmbeddedServletContainerAutoConfiguration {

  --该类就是嵌入式的Servlet容器自动配置类

 1 /**
 2      * Nested configuration if Tomcat is being used.
 3      */
 4     @Configuration
 5     @ConditionalOnClass({ Servlet.class, Tomcat.class })
 6     @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
 7     public static class EmbeddedTomcat {
 8
 9         @Bean
10         public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
11             return new TomcatEmbeddedServletContainerFactory();
12         }
13
14     }

  --如果我们导入了Servlet的相关袭来,那么我们就会存在Servlet.class类以及Tomcat.class类,并且容器中不存在EmbeddedServletContainerFactory嵌入式容器工厂(用户自定义的Servlet容器工厂,那么该配置就会生效),在嵌入式容器工厂中定义了如下类:

 1 public interface EmbeddedServletContainerFactory {
 2
 3     /**
 4      * Gets a new fully configured but paused {@link EmbeddedServletContainer} instance.
 5      * Clients should not be able to connect to the returned server until
 6      * {@link EmbeddedServletContainer#start()} is called (which happens when the
 7      * {@link ApplicationContext} has been fully refreshed).
 8      * @param initializers {@link ServletContextInitializer}s that should be applied as
 9      * the container starts
10      * @return a fully configured and started {@link EmbeddedServletContainer}
11      * @see EmbeddedServletContainer#stop()
12      */
13     EmbeddedServletContainer getEmbeddedServletContainer(
14             ServletContextInitializer... initializers);
15
16 }

  --获取嵌入式的Servlet容器,在SpringBoot的默认实现中存在如下的实现:

  --以嵌入式Tomcat容器工程为例:

 1     @Override
 2     public EmbeddedServletContainer getEmbeddedServletContainer(
 3             ServletContextInitializer... initializers) {
 4         Tomcat tomcat = new Tomcat();
 5         File baseDir = (this.baseDirectory != null ? this.baseDirectory
 6                 : createTempDir("tomcat"));
 7         tomcat.setBaseDir(baseDir.getAbsolutePath());
 8         Connector connector = new Connector(this.protocol);
 9         tomcat.getService().addConnector(connector);
10         customizeConnector(connector);
11         tomcat.setConnector(connector);
12         tomcat.getHost().setAutoDeploy(false);
13         configureEngine(tomcat.getEngine());
14         for (Connector additionalConnector : this.additionalTomcatConnectors) {
15             tomcat.getService().addConnector(additionalConnector);
16         }
17         prepareContext(tomcat.getHost(), initializers);
18         return getTomcatEmbeddedServletContainer(tomcat);
19     }

  --可以发现其内部使用Java代码的方式创建了一个Tomcat,并配置了Tomcat工作的基本环境,最终返回一个嵌入式的Tomcat容器

 1 /**
 2      * Create a new {@link TomcatEmbeddedServletContainer} instance.
 3      * @param tomcat the underlying Tomcat server
 4      * @param autoStart if the server should be started
 5      */
 6     public TomcatEmbeddedServletContainer(Tomcat tomcat, boolean autoStart) {
 7         Assert.notNull(tomcat, "Tomcat Server must not be null");
 8         this.tomcat = tomcat;
 9         this.autoStart = autoStart;
10         initialize();
11     }
12
13     private void initialize() throws EmbeddedServletContainerException {
14         TomcatEmbeddedServletContainer.logger
15                 .info("Tomcat initialized with port(s): " + getPortsDescription(false));
16         synchronized (this.monitor) {
17             try {
18                 addInstanceIdToEngineName();
19                 try {
20                     // Remove service connectors to that protocol binding doesn‘t happen
21                     // yet
22                     removeServiceConnectors();
23
24                     // Start the server to trigger initialization listeners
25                     this.tomcat.start();
26
27                     // We can re-throw failure exception directly in the main thread
28                     rethrowDeferredStartupExceptions();
29
30                     Context context = findContext();
31                     try {
32                         ContextBindings.bindClassLoader(context, getNamingToken(context),
33                                 getClass().getClassLoader());
34                     }
35                     catch (NamingException ex) {
36                         // Naming is not enabled. Continue
37                     }
38
39                     // Unlike Jetty, all Tomcat threads are daemon threads. We create a
40                     // blocking non-daemon to stop immediate shutdown
41                     startDaemonAwaitThread();
42                 }
43                 catch (Exception ex) {
44                     containerCounter.decrementAndGet();
45                     throw ex;
46                 }
47             }
48             catch (Exception ex) {
49                 throw new EmbeddedServletContainerException(
50                         "Unable to start embedded Tomcat", ex);
51             }
52         }
53     }

  --我们对嵌入式容器的配置修改是如何生效的:
  1.修改ServerProperties中的属性
  2.嵌入式Servlet容器定制器:EmbeddedServletContainerCustomizer,帮助我们修改了Sevlet容器的一些默认配置,例如端口号;在EmbeddedServletContainerAutoConfiguration中导入了一个名为BeanPostProcessorsRegistrar,给容器中导入一些组件即嵌入式Servlet容器的后置处理器.后置处理器表示的是在bean初始化前后(创建完对象,还没有赋予初值)执行初始化工作.

  3.EmbeddedServletContainerAutoConfiguration为嵌入式Servlet容器的后置处理器的自动配置类,其存在如下类:

1     @Override
2     public Object postProcessBeforeInitialization(Object bean, String beanName)
3             throws BeansException {
4         if (bean instanceof ConfigurableEmbeddedServletContainer) {
5             postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
6         }
7         return bean;
8     }
1     private void postProcessBeforeInitialization(
2             ConfigurableEmbeddedServletContainer bean) {
3         for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
4             customizer.customize(bean);
5         }
6     }
 1     private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
 2         if (this.customizers == null) {
 3             // Look up does not include the parent context
 4             this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
 5                     this.beanFactory
 6                             .getBeansOfType(EmbeddedServletContainerCustomizer.class,
 7                                     false, false)
 8                             .values());
 9             Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
10             this.customizers = Collections.unmodifiableList(this.customizers);
11         }
12         return this.customizers;
13     }  

  4.获取到了所有的定制器,调用了每一个定制器的customer方法来给Servlet容器进行属性赋值.
  5.ServerProperties也是配置器,因此其配置流程如下:
  (1)SpringBoot根据导入的依赖情况,添加响应的配置容器工厂EmbeddedServletCustomerFactory
  (2)容器中某个组件要创建对象就会惊动后置处理器;
  (3)只要是嵌入式的Servlet容器工厂 后置处理器就工作,从容器中获取所有的EmbeddedServletContainerCustomizer调用定制器的定制方法

五.嵌入式Servlet容器启动原理
  获取嵌入式的Servlet容器工厂:
  1.SpringBoot引用启动运行run方法;
  2.refreshContext(context);SpringBoot刷新容器并初始化容器,创建容器中的每一个组件:如果是Web应用,创建web的IOC容器AnnotationConfigEmbeddedWebApplicationContext,如果不是则创建AnnotationConfigApplicationContext;
  3.refreshContext(context)刷新刚才创建好的容器
  4.onRefresh():web的IOC容器重写了onRefresh方法;
  5.webIOC容器会创建嵌入式的servlet容器:createEmbeddedServletContainer();
  6.获取嵌入式的servlet容器工厂:EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
  7.使用容器工厂获取嵌入式的Servlet容器;
  8.嵌入式的Servlet容器创建对象,并启动servlet容器.

六.使用外置的Servlet容器
  嵌入式Servlet容器:
    优点: 简单,快捷
    缺点:默认不支持JSP,优化定制复杂(使用定制器,自定义配置servlet容器的创建工厂);
  --外部的Servlet容器,:外面安装Tomcat-应用war包的方式打包.
  --我们使用war包的形式创建SpringBoot工程可以发现其目录结构如下:

  --创建项目webapp路径及web-XML文件:

  --部署Tomcat服务器:

  --创建步骤:
  1.必须创建一个war项目;
  2.将嵌入式的Tomcat指定为provided

1         <dependency>
2             <groupId>org.springframework.boot</groupId>
3             <artifactId>spring-boot-starter-web</artifactId>
4         </dependency>
5         <dependency>
6             <groupId>org.springframework.boot</groupId>
7             <artifactId>spring-boot-starter-tomcat</artifactId>
8             <scope>provided</scope>
9         </dependency>

  3.必须编写一个SpringBootServletInitializer的子类,目的就是调用config方法

 1 package com.skykuqi.springboot.exteralservlet;
 2
 3 import org.springframework.boot.builder.SpringApplicationBuilder;
 4 import org.springframework.boot.web.support.SpringBootServletInitializer;
 5
 6 public class ServletInitializer extends SpringBootServletInitializer {
 7
 8     @Override
 9     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
10         //传入SpringBoot应用的主程序
11         return application.sources(ExteralservletApplication.class);
12     }
13
14 }

 七.外置Servlet容器的启动原理
  1.jar包:当我们的应用是使用SpringBoot的jar包形式的话,我们可以直接通过执行SpringBoot主类的main方法,启动IOC容器,创建嵌入式的Servlet容器;
  2.war包:启动服务器,服务器启动SpringBoot应用,启用IOC容器:
  3.在Servlet3.0中有一项规范:

  (1)服务器启动(web应用启动)会创建当前web应用里面每一个jar包里面ServletContainerInitializer的实例;
  (2)ServletContainerInitializer的实现必须放在META-INF/services文件夹下,该文件夹下还必须有一个文件名为javax.servlet.ServletContainerInitializer的文件,文件的内容就是ServletContainerInitializer实现的全类名.
  (3)可以使用@HandlesTypes注解来实现,容器在应用启动的时候,加载我们所感兴趣的类.
  4.启动流程:
  (1)启动Tomcat服务器,Spring的Web模块中存在该文件:

   

 (2)SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)所标注的所有这个类型的类都传入到onStartup方法的集合中为这些不是接口不是抽象类类型的类创建实例;
  (3)每一个WebApplicationInitializer的实现类都调用自己的onStartup方法.

  (4)相当于我们的SpringServletContainerInitializer的类会被创建对象,并执行onStartup方法;
  (6)SpringServletContainerInitializer执行onStartup的时候会创建容器

 1     protected WebApplicationContext createRootApplicationContext(
 2             ServletContext servletContext) {
 3         SpringApplicationBuilder builder = createSpringApplicationBuilder();
 4         StandardServletEnvironment environment = new StandardServletEnvironment();
 5         environment.initPropertySources(servletContext, null);
 6         builder.environment(environment);
 7         builder.main(getClass());
 8         ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
 9         if (parent != null) {
10             this.logger.info("Root context already created (using as parent).");
11             servletContext.setAttribute(
12                     WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
13             builder.initializers(new ParentContextApplicationContextInitializer(parent));
14         }
15         builder.initializers(
16                 new ServletContextApplicationContextInitializer(servletContext));
17         builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
18         builder = configure(builder);
19         SpringApplication application = builder.build();
20         if (application.getSources().isEmpty() && AnnotationUtils
21                 .findAnnotation(getClass(), Configuration.class) != null) {
22             application.getSources().add(getClass());
23         }
24         Assert.state(!application.getSources().isEmpty(),
25                 "No SpringApplication sources have been defined. Either override the "
26                         + "configure method or add an @Configuration annotation");
27         // Ensure error pages are registered
28         if (this.registerErrorPageFilter) {
29             application.getSources().add(ErrorPageFilterConfiguration.class);
30         }
31         return run(application);
32     }

  --将创建RootApplicationContext容器,在创建容器时会进行如下操作:
  a.创建SpringApplicationBuilder
  b.在18行调用了configer(),将SpringBoot的主程序类传入了进来
  c.使用builder创建一个Spring应用

原文地址:https://www.cnblogs.com/skykuqi/p/12000060.html

时间: 2024-10-09 09:06:37

SpringBoot(七) -- 嵌入式Servlet容器的相关文章

springboot(八) 嵌入式Servlet容器自动配置原理和容器启动原理

1.嵌入式Servlet容器自动配置原理 1.1 在spring-boot-autoconfigure-1.5.9.RELEASE.jar => springboot自动配置依赖 jar包下,EmbeddedServletContainerAutoConfiguration => 嵌入式servlet容器自动配置类 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE) @Configuration @ConditionalOnWebApplicatio

SpringBoot源码学习系列之嵌入式Servlet容器

1.前言简单介绍 SpringBoot的自动配置就是SpringBoot的精髓所在:对于SpringBoot项目是不需要配置Tomcat.jetty等等Servlet容器,直接启动application类既可,SpringBoot为什么能做到这么简捷?原因就是使用了内嵌的Servlet容器,默认是使用Tomcat的,具体原因是什么?为什么启动application就可以启动内嵌的Tomcat或者其它Servlet容器?ok,本文就已SpringBoot嵌入式Servlet的启动原理简单介绍一下

配置嵌入式Servlet容器

SpringBoot默认是用的是Tomcat作为嵌入式的Servlet容器:问题?1).如何定制和修改Servlet容器的相关配置:1.修改和server有关的配置(ServerProperties): server.port=8081 server.context-path=/crud server.tomcat.uri-encoding=UTF-8 //通用的Servlet容器设置 server.xxx //Tomcat的设置 server.tomcat.xxx 2.编写一个Embedded

SpringBoot-配置嵌入式Servlet容器(十三)

SpringBoot默认使用Tomcat作为嵌入式的Servlet容器: 如何定制和修改Servlet容器的相关配置 1.修改和server有关的配置(ServerProperties[也是EmbeddedServletContainerCustomizer]): server.port=8081 server.context-path=/crud server.tomcat.uri-encoding=UTF-8 //通用的Servlet容器设置 server.xxx //Tomcat的设置 s

SpringBoot起飞系列-配置嵌入式Servlet容器(八)

一.前言 springboot中默认使用的是tomcat容器,也叫做嵌入式的servlet容器.因为它和我们平常使用的tomcat容器不一样,这个tomcat直接嵌入到的springboot,平常我们使用tomcat容器是一个独立的应用,配置的时候需要在tomcat中的xml中配置,而使用springboot就不一样了,本文我们来学习怎么配置和替换servlet容器.以及注册传统的servlet组件. 二.自定义Servlet容器的相关配置 2.1 修改配置文件的值 我们可以在applicati

SpringBoot配置嵌入式的Servlet

SpringBoot默认使用Tomcat作为嵌入式的Servlet 问题? 1).如何定制和修改Servlet容器的相关配置: server.port=8081 server.context-path=/crud server.tomcat.uri-encoding=UTF-8 //通用的Servlet容器设置 server.xxx //Tomcat的设置 server.tomcat.xxx 注:在2.0之前的版本当中可以使用以下方式修改 Servlet  (EmbeddedServletCon

使用外置的Servlet容器

嵌入式Servlet容器: 优点:简单.便捷 缺点:默认不支持JSP.优化定制比较复杂(使用定制器[ServerProperties.自定义EmbeddedServletContainerCustomizer]),自己编写嵌入式Servlet容器的创建工厂[EmbeddedServletContainerFactory]: 外置的Servlet容器:外面安装Tomcat--应用war包的方式打包 步骤: 1).必须创建一个war项目(利用idea创建好目录结构) 2).将嵌入式的Tomcat指定

SpringBoot嵌入式Servlet配置原理

SpringBoot嵌入式Servlet配置原理 SpringBoot修改服务器配置 配置文件方式方式修改,实际修改的是ServerProperties文件中的值 server.servlet.context-path=/crud server.port=8081 Java代码方式修改.通过实现WebServerFactoryCusomizer接口来获取到达ConfigurableServletWebServerFactory的通道,ConfigurableServletWebServerFac

Java使用Jetty实现嵌入式Web服务器及Servlet容器

首先来介绍下 Jetty,根据 wiki 的介绍: Jetty 是一个纯粹的基于 Java 的网页服务器和 Java Servlet 容器.尽管网页服务器通常用来为人们呈现文档,但是 Jetty 通常在较大的软件框架中用于计算机与计算机之间的通信. Jetty 作为 Eclipse 基金会的一部分,是一个自由和开源项目.该网页服务器被用在 Apache ActiveMQ.Alfresco.Apache Geronimo.Apache Maven.Google App Engine.Eclipse