ToB企服应用市场:ToB评测及商务社交产业平台

标题: SpringBoot的两种启动方式原理 [打印本页]
作者: 去皮卡多    时间: 2025-1-16 06:46
标题: SpringBoot的两种启动方式原理
使用内置tomcat启动

配置案例

启动方式

配置内置tomcat属性

关于Tomcat的属性都在 org.springframework.boot.autoconfigure.web.ServerProperties 配置类中做了界说，我们只需在application.properties配置属性做配置即可。通用的Servlet容器配置都以 server 作为前缀
  1. #配置程序端口，默认为8080
  2. server.port= 8080
  3. #用户会话session过期时间，以秒为单位
  4. server.session.timeout=
  5. #配置默认访问路径，默认为/
  6. server.context-path=
复制代码
而Tomcat特有配置都以 server.tomcat 作为前缀
  1. # 配置Tomcat编码,默认为UTF-8
  2. server.tomcat.uri-encoding=UTF-8
  3. # 配置最大线程数
  4. server.tomcat.max-threads=1000
复制代码
注意：使用内置tomcat不需要有tomcat-embed-jasper和spring-boot-starter-tomcat依赖，因为在spring-boot-starter-web依赖中已经集成了tomcat
原理

从main函数说起
  1. public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
  2.     return run(new Class[]{primarySource}, args);
  3. }
  5. // 这里run方法返回的是ConfigurableApplicationContext
  6. public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
  7.         return (new SpringApplication(primarySources)).run(args);
  8. }
复制代码
  1. public ConfigurableApplicationContext run(String... args) {
  2. ConfigurableApplicationContext context = null;
  3. Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
  4. this.configureHeadlessProperty();
  5. SpringApplicationRunListeners listeners = this.getRunListeners(args);
  6. listeners.starting();
  8. Collection exceptionReporters;
  9. try {
  10.   ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  11.   ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
  12.   this.configureIgnoreBeanInfo(environment);
  13.   
  14.   //打印banner，这里可以自己涂鸦一下，换成自己项目的logo
  15.   Banner printedBanner = this.printBanner(environment);
  16.   
  17.   //创建应用上下文
  18.   context = this.createApplicationContext();
  19.   exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
  21.   //预处理上下文
  22.   this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
  23.   
  24.   //刷新上下文
  25.   this.refreshContext(context);
  26.   
  27.   //再刷新上下文
  28.   this.afterRefresh(context, applicationArguments);
  29.   
  30.   listeners.started(context);
  31.   this.callRunners(context, applicationArguments);
  32. } catch (Throwable var10) {
  33.   
  34. }
  36. try {
  37.   listeners.running(context);
  38.   return context;
  39. } catch (Throwable var9) {
  40.   
  41. }
  42. }
复制代码
既然我们想知道tomcat在SpringBoot中是怎么启动的，那么run方法中，重点关注创建应用上下文（createApplicationContext）和刷新上下文（refreshContext）。
创建上下文
  1. //创建上下文
  2. protected ConfigurableApplicationContext createApplicationContext() {
  3. Class<?> contextClass = this.applicationContextClass;
  4. if (contextClass == null) {
  5.   try {
  6.    switch(this.webApplicationType) {
  7.     case SERVLET:
  8.                     //创建AnnotationConfigServletWebServerApplicationContext
  9.         contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
  10.      break;
  11.     case REACTIVE:
  12.      contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
  13.      break;
  14.     default:
  15.      contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
  16.    }
  17.   } catch (ClassNotFoundException var3) {
  18.    throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
  19.   }
  20. }
  22. return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
  23. }
复制代码
这里会创建AnnotationConfigServletWebServerApplicationContext类。而AnnotationConfigServletWebServerApplicationContext类继承了ServletWebServerApplicationContext，而这个类是终极集成了AbstractApplicationContext。
刷新上下文
  1. //SpringApplication.java
  2. //刷新上下文
  3. private void refreshContext(ConfigurableApplicationContext context) {
  4. this.refresh(context);
  5. if (this.registerShutdownHook) {
  6.   try {
  7.    context.registerShutdownHook();
  8.   } catch (AccessControlException var3) {
  9.   }
  10. }
  11. }
  13. //这里直接调用最终父类AbstractApplicationContext.refresh()方法
  14. protected void refresh(ApplicationContext applicationContext) {
  15. ((AbstractApplicationContext)applicationContext).refresh();
  16. }
复制代码
  1. //AbstractApplicationContext.java
  2. public void refresh() throws BeansException, IllegalStateException {
  3. synchronized(this.startupShutdownMonitor) {
  4.   this.prepareRefresh();
  5.   ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
  6.   this.prepareBeanFactory(beanFactory);
  8.   try {
  9.    this.postProcessBeanFactory(beanFactory);
  10.    this.invokeBeanFactoryPostProcessors(beanFactory);
  11.    this.registerBeanPostProcessors(beanFactory);
  12.    this.initMessageSource();
  13.    this.initApplicationEventMulticaster();
  14.    //调用各个子类的onRefresh()方法，也就说这里要回到子类：ServletWebServerApplicationContext，调用该类的onRefresh()方法
  15.    this.onRefresh();
  16.    this.registerListeners();
  17.    this.finishBeanFactoryInitialization(beanFactory);
  18.    this.finishRefresh();
  19.   } catch (BeansException var9) {
  20.    this.destroyBeans();
  21.    this.cancelRefresh(var9);
  22.    throw var9;
  23.   } finally {
  24.    this.resetCommonCaches();
  25.   }
  27. }
  28. }
复制代码
  1. //ServletWebServerApplicationContext.java
  2. //在这个方法里看到了熟悉的面孔，this.createWebServer，神秘的面纱就要揭开了。
  3. protected void onRefresh() {
  4. super.onRefresh();
  5. try {
  6.   this.createWebServer();
  7. } catch (Throwable var2) {
  8.   
  9. }
  10. }
  12. //ServletWebServerApplicationContext.java
  13. //这里是创建webServer，但是还没有启动tomcat，这里是通过ServletWebServerFactory创建，那么接着看下ServletWebServerFactory
  14. private void createWebServer() {
  15. WebServer webServer = this.webServer;
  16. ServletContext servletContext = this.getServletContext();
  17. if (webServer == null && servletContext == null) {
  18.   ServletWebServerFactory factory = this.getWebServerFactory();
  19.   this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
  20. } else if (servletContext != null) {
  21.   try {
  22.    this.getSelfInitializer().onStartup(servletContext);
  23.   } catch (ServletException var4) {
  24.   
  25.   }
  26. }
  28. this.initPropertySources();
  29. }
  31. //接口
  32. public interface ServletWebServerFactory {
  33.     WebServer getWebServer(ServletContextInitializer... initializers);
  34. }
  36. //实现
  37. AbstractServletWebServerFactory
  38. JettyServletWebServerFactory
  39. TomcatServletWebServerFactory
  40. UndertowServletWebServerFactory
复制代码
这里ServletWebServerFactory接口有4个实现类，对应着四种容器：
而其中我们常用的有两个：TomcatServletWebServerFactory和JettyServletWebServerFactory。
  1. //TomcatServletWebServerFactory.java
  2. //这里我们使用的tomcat，所以我们查看TomcatServletWebServerFactory。到这里总算是看到了tomcat的踪迹。
  3. @Override
  4. public WebServer getWebServer(ServletContextInitializer... initializers) {
  5. Tomcat tomcat = new Tomcat();
  6. File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
  7. tomcat.setBaseDir(baseDir.getAbsolutePath());
  8.     //创建Connector对象
  9. Connector connector = new Connector(this.protocol);
  10. tomcat.getService().addConnector(connector);
  11. customizeConnector(connector);
  12. tomcat.setConnector(connector);
  13. tomcat.getHost().setAutoDeploy(false);
  14. configureEngine(tomcat.getEngine());
  15. for (Connector additionalConnector : this.additionalTomcatConnectors) {
  16.   tomcat.getService().addConnector(additionalConnector);
  17. }
  18. prepareContext(tomcat.getHost(), initializers);
  19. return getTomcatWebServer(tomcat);
  20. }
  22. protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
  23. return new TomcatWebServer(tomcat, getPort() >= 0);
  24. }
  26. //Tomcat.java
  27. //返回Engine容器，看到这里，如果熟悉tomcat源码的话，对engine不会感到陌生。
  28. public Engine getEngine() {
  29.     Service service = getServer().findServices()[0];
  30.     if (service.getContainer() != null) {
  31.         return service.getContainer();
  32.     }
  33.     Engine engine = new StandardEngine();
  34.     engine.setName( "Tomcat" );
  35.     engine.setDefaultHost(hostname);
  36.     engine.setRealm(createDefaultRealm());
  37.     service.setContainer(engine);
  38.     return engine;
  39. }
  40. //Engine是最高级别容器，Host是Engine的子容器，Context是Host的子容器，Wrapper是Context的子容器
复制代码
getWebServer这个方法创建了Tomcat对象，并且做了两件重要的事情：把Connector对象添加到tomcat中，configureEngine(tomcat.getEngine());
getWebServer方法返回的是TomcatWebServer。
  1. //TomcatWebServer.java
  2. //这里调用构造函数实例化TomcatWebServer
  3. public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
  4. Assert.notNull(tomcat, "Tomcat Server must not be null");
  5. this.tomcat = tomcat;
  6. this.autoStart = autoStart;
  7. initialize();
  8. }
  10. private void initialize() throws WebServerException {
  11.     //在控制台会看到这句日志
  12. logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
  13. synchronized (this.monitor) {
  14.   try {
  15.    addInstanceIdToEngineName();
  17.    Context context = findContext();
  18.    context.addLifecycleListener((event) -> {
  19.     if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
  20.      removeServiceConnectors();
  21.     }
  22.    });
  24.    //===启动tomcat服务===
  25.    this.tomcat.start();
  27.    rethrowDeferredStartupExceptions();
  29.    try {
  30.     ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
  31.    }
  32.    catch (NamingException ex) {
  33.                
  34.    }
  35.             
  36.             //开启阻塞非守护进程
  37.    startDaemonAwaitThread();
  38.   }
  39.   catch (Exception ex) {
  40.    stopSilently();
  41.    destroySilently();
  42.    throw new WebServerException("Unable to start embedded Tomcat", ex);
  43.   }
  44. }
  45. }
复制代码
  1. //Tomcat.java
  2. public void start() throws LifecycleException {
  3. getServer();
  4. server.start();
  5. }
  6. //这里server.start又会回到TomcatWebServer的
  7. public void stop() throws LifecycleException {
  8. getServer();
  9. server.stop();
  10. }
复制代码
  1. //TomcatWebServer.java
  2. //启动tomcat服务
  3. @Override
  4. public void start() throws WebServerException {
  5. synchronized (this.monitor) {
  6.   if (this.started) {
  7.    return;
  8.   }
  9.   try {
  10.    addPreviouslyRemovedConnectors();
  11.    Connector connector = this.tomcat.getConnector();
  12.    if (connector != null && this.autoStart) {
  13.     performDeferredLoadOnStartup();
  14.    }
  15.    checkThatConnectorsHaveStarted();
  16.    this.started = true;
  17.    //在控制台打印这句日志，如果在yml设置了上下文，这里会打印
  18.    logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
  19.      + getContextPath() + "'");
  20.   }
  21.   catch (ConnectorStartFailedException ex) {
  22.    stopSilently();
  23.    throw ex;
  24.   }
  25.   catch (Exception ex) {
  26.    throw new WebServerException("Unable to start embedded Tomcat server", ex);
  27.   }
  28.   finally {
  29.    Context context = findContext();
  30.    ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
  31.   }
  32. }
  33. }
  35. //关闭tomcat服务
  36. @Override
  37. public void stop() throws WebServerException {
  38. synchronized (this.monitor) {
  39.   boolean wasStarted = this.started;
  40.   try {
  41.    this.started = false;
  42.    try {
  43.     stopTomcat();
  44.     this.tomcat.destroy();
  45.    }
  46.    catch (LifecycleException ex) {
  47.    
  48.    }
  49.   }
  50.   catch (Exception ex) {
  51.    throw new WebServerException("Unable to stop embedded Tomcat", ex);
  52.   }
  53.   finally {
  54.    if (wasStarted) {
  55.     containerCounter.decrementAndGet();
  56.    }
  57.   }
  58. }
  59. }
复制代码
使用外置tomcat部署

配置案例

外置Tomcat启动SpringBoot源码点击这里
继承SpringBootServletInitializer

方式一：启动类继承SpringBootServletInitializer实现configure：
  1. @SpringBootApplication
  2. public class SpringBootHelloWorldTomcatApplication extends SpringBootServletInitializer {
  3.         @Override
  4.     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
  5.         return builder.sources(Application.class);
  6.     }
  7. }
复制代码
这个类的作用与在web.xml中配置负责初始化Spring应用上下文的监听器作用类似，只不过在这里不需要编写额外的XML文件了。
方式二：新增加一个类继承SpringBootServletInitializer实现configure：
  1. public class ServletInitializer extends SpringBootServletInitializer {
  2.     @Override
  3.     protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
  4.         //此处的Application.class为带有@SpringBootApplication注解的启动类
  5.         return builder.sources(Application.class);
  6.     }
  7. }
复制代码
pom.xml修改tomcat相干的配置

首先需要将 jar 变成war war
如果要将终极的打包情势改为war的话，还需要对pom.xml文件进行修改，因为spring-boot-starter-web中包含内嵌的tomcat容器，所以直接部署在外部容器会冲突报错。因此需要将内置tomcat排除
  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4.     <exclusions>
  5.         <exclusion>
  6.             <groupId>org.springframework.boot</groupId>
  7.             <artifactId>spring-boot-starter-tomcat</artifactId>
  8.         </exclusion>
  9.     </exclusions>
  10. </dependency>
复制代码
在这里需要移除对嵌入式Tomcat的依赖，这样打出的war包中，在lib目次下才不会包含Tomcat相干的jar包，否则将会出现启动错误。
但是移除了tomcat后，原始的sevlet也被移除了，因此还需要额外引入servet的包
  1. <dependency>
  2.       <groupId>javax.servlet</groupId>
  3.       <artifactId>javax.servlet-api</artifactId>
  4.       <version>3.0.1</version>
  5. </dependency>
复制代码
注意的题目

此时打成的包的名称应该和 application.properties 的 server.context-path=/test 保持同等
  1. <build>
  2.     <finalName>test</finalName>
  3. </build>
复制代码
如果不一样发布到tomcat的webapps下上下文会变化
原理

tomcat不会自动去启动springboot应用 ，， 所以tomcat启动的时候肯定调用了SpringBootServletInitializer的SpringApplicationBuilder ， 就会启动springboot。
ServletContainerInitializer的实现放在jar包的META-INF/services文件夹下，有一个名为javax.servlet.ServletContainerInitializer的文件，内容就是ServletContainerInitializer的实现类的全类名。当servlet容器启动时候就会去该文件中找到ServletContainerInitializer的实现类，从而创建它的实例调用onstartUp。这里就是用了SPI机制
HandlesTypes(WebApplicationInitializer.class)

  1. @HandlesTypes(WebApplicationInitializer.class)
  2. public class SpringServletContainerInitializer implements ServletContainerInitializer {
复制代码
  1. @Override
  2. public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
  3.       throws ServletException {
  5.    List<WebApplicationInitializer> initializers = new LinkedList<>();
  7.    if (webAppInitializerClasses != null) {
  8.       for (Class<?> waiClass : webAppInitializerClasses) {
  9.         // 如果不是接口 不是抽象 跟WebApplicationInitializer有关系  就会实例化
  10.          if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
  11.                WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
  12.             try {
  13.                initializers.add((WebApplicationInitializer)
  14.                      ReflectionUtils.accessibleConstructor(waiClass).newInstance());
  15.             }
  16.             catch (Throwable ex) {
  17.                throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
  18.             }
  19.          }
  20.       }
  21.    }
  23.    if (initializers.isEmpty()) {
  24.       servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
  25.       return;
  26.    }
  28.    servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
  29.    // 排序
  30.    AnnotationAwareOrderComparator.sort(initializers);
  31.    for (WebApplicationInitializer initializer : initializers) {
  32.       initializer.onStartup(servletContext);
  33.    }
  34. }
复制代码
  1. @Override
  2. public void onStartup(ServletContext servletContext) throws ServletException {
  3.    // Logger initialization is deferred in case an ordered
  4.    // LogServletContextInitializer is being used
  5.    this.logger = LogFactory.getLog(getClass());
  6.    WebApplicationContext rootApplicationContext = createRootApplicationContext(servletContext);
  7.    if (rootApplicationContext != null) {
  8.       servletContext.addListener(new SpringBootContextLoaderListener(rootApplicationContext, servletContext));
  9.    }
  10.    else {
  11.       this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not "
  12.             + "return an application context");
  13.    }
  14. }
复制代码
SpringBootServletInitializer
  1. protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
  2.    SpringApplicationBuilder builder = createSpringApplicationBuilder();
  3.    builder.main(getClass());
  4.    ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
  5.    if (parent != null) {
  6.       this.logger.info("Root context already created (using as parent).");
  7.       servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
  8.       builder.initializers(new ParentContextApplicationContextInitializer(parent));
  9.    }
  10.    builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
  11.    builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
  12.    // 调用configure
  13.    builder = configure(builder); //①
  14.    builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
  15.    SpringApplication application = builder.build();//②
  16.    if (application.getAllSources().isEmpty()
  17.          && MergedAnnotations.from(getClass(), SearchStrategy.TYPE_HIERARCHY).isPresent(Configuration.class)) {
  18.       application.addPrimarySources(Collections.singleton(getClass()));
  19.    }
  20.    Assert.state(!application.getAllSources().isEmpty(),
  21.          "No SpringApplication sources have been defined. Either override the "
  22.                + "configure method or add an @Configuration annotation");
  23.    // Ensure error pages are registered
  24.    if (this.registerErrorPageFilter) {
  25.       application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
  26.    }
  27.    application.setRegisterShutdownHook(false);
  28.    return run(application);//③
  29. }
复制代码
① 当调用configure就会来到TomcatStartSpringBoot .configure，将Springboot启动类传入到builder.source
  1. @Override
  2. protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
  3.     return builder.sources(Application.class);
  4. }
复制代码
② 调用SpringApplication application = builder.build(); 就会根据传入的Springboot启动类来构建一个SpringApplication
  1. public SpringApplication build(String... args) {
  2.    configureAsChildIfNecessary(args);
  3.    this.application.addPrimarySources(this.sources);
  4.    return this.application;
  5. }
复制代码
③ 调用 return run(application); 就会启动springboot应用
  1. protected WebApplicationContext run(SpringApplication application) {
  2.    return (WebApplicationContext) application.run();
  3. }
复制代码
也就相当于Main函数启动：
  1. public static void main(String[] args) {
  2.     SpringApplication.run(Application.class, args);
  3. }
复制代码
之后的流程就与上面 使用内置Tomcat的Main函数同等了

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4