快上网专注成都网站设计 成都网站制作 成都网站建设
成都网站建设公司服务热线：028-86922220

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后，网站问题一站解决

SpringBoot启动流程-创新互联

使用的SpringBoot版本为2.3.12，配套Spring版本为5.2.15

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：域名注册、网络空间、营销软件、网站建设、内乡网站维护、网站推广。一 SpringBoot启动流程 1.程序入口
// 程序入口
// 运行SpringApplication.run方法
// 主启动类方法
// args是启动参数，我在环境配置处配置程序参数了--server.port=8079端口号信息，则args不为空
public static void main(String[] args) {
    // 加载完成后 执行run方法
    SpringApplication.run(SpringbootQuartzApplication.class, args);
}

// 上面代码实际上是调用spring-boot包里的SpringApplication.class里的方法
// 这里可以看出是先创建SpringApplication对象，再调用run方法完成容器的初始化操作
public static ConfigurableApplicationContext run(Class[] primarySources, String[] args) {
    return (new SpringApplication(primarySources)).run(args);
}
2.主体分为两个步骤

a.构造方法创建SpringApplication实例

b.执行SpringApplication实例的run方法

3.图示 二 new SpringAoolication()构造函数

随版本不同，代码会有较大差异，具体根据自己所用项目来。下面截取构造方法核心部分代码。

// new SpringApplication()构造函数
public static ConfigurableApplicationContext run(Class[] primarySources, String[] args) {
    return (new SpringApplication(primarySources)).run(args);
}
其中new SpringApplication(primarySources)构造函数环节调用的也是SpringApplication.class里的方法

public SpringApplication(Class... primarySources) {
    this((ResourceLoader)null, primarySources);
}

// 下面会逐一展开run方法执行时，是如何使用构造方法里定义的属性的
public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // 1.初始化启动时必要参数
    this.sources = new LinkedHashSet();
    this.bannerMode = Mode.CONSOLE;
    // 打印JVM的启动和运行信息，启动类、java版本等
    this.logStartupInfo = true;
    // 通过命令行参数向application.properties中添加属性配置
    this.addCommandLineProperties = true;
    // 加载默认的类型转换和格式化类
    this.addConversionService = true;
    // 开启java的headless模式，此模式允许java在没有显示器、鼠标等设备的情况下启动服务
    this.headless = true;
    // 创建线程，该线程用来在java程序关闭后释放资源
    this.registerShutdownHook = true;
    // 默认为空，即使用springboot默认配置文件。开发时切dev/sit/prod等分支时会使用
    this.additionalProfiles = new HashSet();
    // 是否加载环境配置
    this.isCustomEnvironment = false;
    // 是否懒加载，可以通过在application.properties设置spring.main.lazy-initialization=true修改
    this.lazyInitialization = false;
    // 
    this.resourceLoader = resourceLoader;
    // 主配置为空则抛出异常
    Assert.notNull(primarySources, "PrimarySources must not be null");
    // 保存主配置类
    this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
    // 2 确认web应用类型，本项目为Servlet
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 3.加载所有初始化器，获取spring工厂文件中的实例。加载了当前项目下全部的spring.factries文件，将文件中的k-v放入缓存中，然后将读取到的ApplicationContextInitializer类型的类实例化
    this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 4.加载所有监听器，这里与上面类似也调用this.getSpringFactoriesInstances()，但是由于之前已经把spring.factries文件读取到缓存中了，因此不用再次读取文件而是读缓存
    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    // 5.设置程序运行的主类MainApplication，以便后面执行run方法
    this.mainApplicationClass = this.deduceMainApplicationClass();
}
2.确定应用程序类型
// 提供三种类型
// 1.NONE 表示当前的应用既不是一个web应用也不是一个reactive应用，是一个纯后台的应用。不启动内嵌的服务
// 2.SERVLET 当前应用是一个基于servlet API的标准的web应用，需启动内嵌servlet web服务
// 3.REACTIVE 是spring5当中的新特性，表示是一个响应式的web应用，需启动内嵌的响应式web服务
this.webApplicationType = WebApplicationType.deduceFromClasspath();

// 这里实际上是根据类加载器名字具体是哪一种，本项目中SERVLET_INDICATOR_CLASSES为['javax.servlet.Servlet', 'org.springframework.web.context.ConfigurableWebApplicationContext']
// ClassUtils.isPresent()方法，判断指定类名的类是否存在，是否可以进行加载（如果我们导入了，相对应的jar包，就可以加载，如果没有导入就不能加载）
// 如果能够加载DispatcherHandler类，但是无法加载DispatcherServlet和ServletContainer类，就证明是一个响应式web应用
static WebApplicationType deduceFromClasspath() {
    // 判断能否加载响应式web应用
    if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", (ClassLoader)null) && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", (ClassLoader)null) && !ClassUtils.isPresent("org.glassfish.jersey.servlet.ServletContainer", (ClassLoader)null)) {
        return REACTIVE;
    } else {
        String[] var0 = SERVLET_INDICATOR_CLASSES;
        int var1 = var0.length;

        for(int var2 = 0; var2< var1; ++var2) {
            String className = var0[var2];
            // 判断能否加载SERVLET_INDICATOR_CLASSES里的两个类名
            if (!ClassUtils.isPresent(className, (ClassLoader)null)) {
                return NONE;
            }
        }

        return SERVLET;
    }
}

// 补充ClassUtils.isPresent()方法  实际上是调用forName来获取类加载器
public static boolean isPresent(String className, @Nullable ClassLoader classLoader) {
    try {
        forName(className, classLoader);
        return true;
    } catch (IllegalAccessError var3) {
        throw new IllegalStateException("Readability mismatch in inheritance hierarchy of class [" + className + "]: " + var3.getMessage(), var3);
    } catch (Throwable var4) {
        return false;
    }
}
3.加载所有初始化器，获取spring工厂文件中的实例

补充说明，4.加载监听器与下面流程基本一致，不同的是3.加载所有初始化器时读取的一些文件配置会放入缓存中，加载监听器时从缓存读取数据即可。

this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));

privateCollectiongetSpringFactoriesInstances(Classtype) {
    // type为ApplicationContextInitializer.class
    return this.getSpringFactoriesInstances(type, new Class[0]);
}

privateCollectiongetSpringFactoriesInstances(Classtype, Class[] parameterTypes, Object... args) {
    // 获取SpringApplication的类加载器，这里是一个系统类加载器AppClassLoader
    ClassLoader classLoader = this.getClassLoader();
    // 加载spring.factories文件中的类的全类名集合
    Setnames = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 通过反射获取到集合中全类名对应的Class，并创建其实例对象，返回实例对象
    Listinstances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    // 根据优先级排序
    AnnotationAwareOrderComparator.sort(instances);
    // 返回实例
    return instances;
}

public static ListloadFactoryNames(ClassfactoryType, @Nullable ClassLoader classLoader) {
    // 加载初始化器时factoryTypeName="org.springframework.context.ApplicationContextInitializer"，对应之前设置的ApplicationContextInitializer.class
    // 加载监听器时factoryTypeName="org.springframework.context.ApplicationListener"，对应ApplicationListener.calss
    String factoryTypeName = factoryType.getName();
    // 正式加载spring-boot包里META-INF目录下的spring.factories文件
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

// loadSpringFactories()才正式去加载spring-boot包里META-INF目录下的spring.factories文件
private static Map>loadSpringFactories(@Nullable ClassLoader classLoader) {
    // 这里是读缓存，加载初始化器时还没有缓存（在这一环节添加了缓存），到加载监听器时就能从缓存读取数据了
    MultiValueMapresult = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            // 获取当前项目中所有META-INF/spring.factories文件的绝对路径，对于目前使用的项目则是读取下面的路径，因为是测试项目，因此引入的包和版本比较杂乱
            // file:/E:/javaDevelopmentTools/maven/repository/org/springframework/boot/spring-boot/2.3.12.RELEASE/spring-boot-2.3.12.RELEASE.jar!/META-INF/spring.factories
            // file:/E:/javaDevelopmentTools/maven/repository/org/springframework/spring-beans/5.2.15.RELEASE/spring-beans-5.2.15.RELEASE.jar!/META-INF/spring.factories
                      //   file:/E:/javaDevelopmentTools/maven/repository/org/mybatis/spring/boot/mybatis-spring-boot-autoconfigure/2.0.1/mybatis-spring-boot-autoconfigure-2.0.1.jar!/META-INF/spring.factories
            //  file:/E:/javaDevelopmentTools/maven/repository/com/baomidou/mybatis-plus-boot-starter/3.5.1/mybatis-plus-boot-starter-3.5.1.jar!/META-INF/spring.factories
                       //    file:/E:/javaDevelopmentTools/maven/repository/org/springframework/boot/spring-boot-autoconfigure/2.3.12.RELEASE/spring-boot-autoconfigure-2.3.12.RELEASE.jar!/META-INF/spring.factories
            // 这里贴一下pom.xml文件的部分引用Enumerationurls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            // 遍历上面获取到的绝对路径
            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                // 把文件资源加载到Properties中
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Entryentry = (Entry)var6.next();
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11< var10; ++var11) {
                        String factoryImplementationName = var9[var11];
                        // K-V形式，把spring.factories中的的类型，下面图例中会贴上result的内容
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }

            // 将类加载器加载的spring.factories文件结果集放入缓存
            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

并且贴一下对应图片，下图为result.add(factoryTypeName, factoryImplementationName.trim());后的result。大多是与项目启动、异常处理、自动配置等基础配置相关的内容。

下面则是读取了哪些spring.factories文件（实际项目中会很多，这里只是测试项目）

三 执行run方法

下面贴一下主要代码部分

public ConfigurableApplicationContext run(String... args) {
    // 开启计时器。计算程序启动时间用的
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    // 6.开启java的headless模式 是SpringApplication的 this.headless = true;控制的
    this.headless = true;
    // 保证headless一定有值
    this.configureHeadlessProperty();
    // 7.获取并启用监听器 这里获取到的是SpringApplicationRunListeners对象，里面有之前初始化SpringApplication时的监听器
    // args默认为空，我填写了--server.port=8079属性
    SpringApplicationRunListeners listeners = this.getRunListeners(args);
    listeners.starting();

    try {
        // 8.设置应用程序参数
        // 初始化ApplicationArguments对象，提供访问运行SpringApplication时的参数
        // 由于之前的配置 args 里带有--server.port=8079参数，而这个参数就会被封装进Source对象，底层是Spring 框架的 SimpleCommandLinePropertySource
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 9.准备环境变量 参数是监听器和应用程序参数
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        // 忽略掉部分bean信息
        this.configureIgnoreBeanInfo(environment);
        // 打印banner信息 这里实际上是打印了Spring的标志
        Banner printedBanner = this.printBanner(environment);
        // 10.创建应用程序的上下文
        context = this.createApplicationContext();
        // 10.准备上下文环境
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        // 11.刷新上下文，属于Spring的范畴（自动装配+启动tomcat）
        this.refreshContext(context);
        // 11.刷新上下文后置处理（目前是空的）
        this.afterRefresh(context, applicationArguments);
        // 停止计时器
        stopWatch.stop();
                //  打印JVM的启动和运行信息，启动类、java版本等 this.logStartupInfo = true;
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }

        // 创建应用上下文启动完成事件对象ApplicationStartedEvent
        // 发布应用上下文启动完成事件，广播事件，调用监听器相对应的监听方法
        listeners.started(context);
        this.callRunners(context, applicationArguments);
    } catch (Throwable var9) {
        this.handleRunFailure(context, var9, listeners);
        throw new IllegalStateException(var9);
    }


    try {
        // 12.发布上下文准备就绪事件
        listeners.running(context);
        return context;
    } catch (Throwable var8) {
        this.handleRunFailure(context, var8, (SpringApplicationRunListeners)null);
        throw new IllegalStateException(var8);
    }
}
7.获取并启用监听器 9.准备环境变量 9.1ConfigurableEnvironment
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
    // 创建或者返回环境
    ConfigurableEnvironment environment = this.getOrCreateEnvironment();
        // 配置环境
    this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
    ConfigurationPropertySources.attach((Environment)environment);
    // 监听器的环境准备，这部分.class文件断点匹配不上，但是从输出上看多了initialMulticaster
    listeners.environmentPrepared((ConfigurableEnvironment)environment);
    // 把环境绑定到SpringApplication
    this.bindToSpringApplication((ConfigurableEnvironment)environment);
    // 之前配置的 this.isCustomEnvironment = false;
    if (!this.isCustomEnvironment) {
        environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
    }

    ConfigurationPropertySources.attach((Environment)environment);
    // 返回的environment环境信息不仅仅是SpringBoot项目本身的，虚拟机、项目运行系统信息（Linux/Windows等）、JDK、MAVEN等信息也包含其中
    return (ConfigurableEnvironment)environment;
}

// 由于没有设置environment，因此根据this.webApplicationType = WebApplicationType.deduceFromClasspath();得知为SERVLET
private ConfigurableEnvironment getOrCreateEnvironment() {
    if (this.environment != null) {
        return this.environment;
    } else {
        switch(this.webApplicationType) {
        case SERVLET:
            return new StandardServletEnvironment();
        case REACTIVE:
            return new StandardReactiveWebEnvironment();
        default:
            return new StandardEnvironment();
        }
    }
}

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    // 之前设置的this.addConversionService = true;加载默认的类型转换和格式化类
    if (this.addConversionService) {
        ConversionService conversionService = ApplicationConversionService.getSharedInstance();
        environment.setConversionService((ConfigurableConversionService)conversionService);
    }

    // 配置environment的PropertySources
    this.configurePropertySources(environment, args);
    // 配置environment的ActiveProfiles
    this.configureProfiles(environment, args);
}
9.2忽略Bean的BeanInfo信息
// spring.beaninfo.ignore默认为true表示跳过对BeanInfo类的搜索
// 忽略所有自定义的BeanInfo信息的搜索
// 通过Java的Introspector.getBeanInfo方法，可以获取到JavaBean的BeanInfo信息（一般有Bean的方法、属性、类相关信息等）
private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {
    if (System.getProperty("spring.beaninfo.ignore") == null) {
        Boolean ignore = (Boolean)environment.getProperty("spring.beaninfo.ignore", Boolean.class, Boolean.TRUE);
        System.setProperty("spring.beaninfo.ignore", ignore.toString());
    }
}
9.3打印banner信息

这里实际上是打印了Spring的标志

private Banner printBanner(ConfigurableEnvironment environment) {
    // 之前设置的this.bannerMode = Mode.CONSOLE;
    if (this.bannerMode == Mode.OFF) {
        return null;
    } else {
        ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader : new DefaultResourceLoader((ClassLoader)null);
        SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter((ResourceLoader)resourceLoader, this.banner);
        return this.bannerMode == Mode.LOG ? bannerPrinter.print(environment, this.mainApplicationClass, logger) : bannerPrinter.print(environment, this.mainApplicationClass, System.out);
    }
}

console控制台会打印出下面标识（默认输出，可以通过配置修改）

10.创建应用程序的上下文 10.1ConfigurableApplicationContext
protected ConfigurableApplicationContext createApplicationContext() {
    ClasscontextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            // 根据Web应用类型创建对应的上下文，目前项目这里根据之前的配置 是SERVLET
            switch(this.webApplicationType) {
            case SERVLET:
                contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
                break;
            case REACTIVE:
                contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
                break;
            default:
                contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
            }
        } catch (ClassNotFoundException var3) {
            throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
        }
    }
    
        // 实例化应用上下文
    return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}
10.2准备上下文环境
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    // 把之前的配置的环境加载到应用上下文中
    context.setEnvironment(environment);
    // 实例化单例的beanName生成器
    this.postProcessApplicationContext(context);
    // 遍历之前在SpringApplication中的初始化器，进行初始化
    this.applyInitializers(context);
    // 监听器初始化
    listeners.contextPrepared(context);
    // 打印JVM的启动和运行信息，启动类、java版本等 this.logStartupInfo = true;
    if (this.logStartupInfo) {
        this.logStartupInfo(context.getParent() == null);
        this.logStartupProfileInfo(context);
    }

    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    // 将启动参数注册到容器中
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }

    if (beanFactory instanceof DefaultListableBeanFactory) {
        ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }

    if (this.lazyInitialization) {
        context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    }

    Setsources = this.getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    this.load(context, sources.toArray(new Object[0]));
    listeners.contextLoaded(context);
}


protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    if (this.beanNameGenerator != null) {
        context.getBeanFactory().registerSingleton("org.springframework.context.annotation.internalConfigurationBeanNameGenerator", this.beanNameGenerator);
    }

    if (this.resourceLoader != null) {
        if (context instanceof GenericApplicationContext) {
            ((GenericApplicationContext)context).setResourceLoader(this.resourceLoader);
        }

        if (context instanceof DefaultResourceLoader) {
            ((DefaultResourceLoader)context).setClassLoader(this.resourceLoader.getClassLoader());
        }
    }
    // 加载默认的类型转换和格式化类 this.addConversionService = true;
    if (this.addConversionService) {
        // 设置beanFactory的conversionService属性
        context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance());
    }
}

// 执行初始化方法
protected void applyInitializers(ConfigurableApplicationContext context) {
    Iterator var2 = this.getInitializers().iterator();

    while(var2.hasNext()) {
        ApplicationContextInitializer initializer = (ApplicationContextInitializer)var2.next();
        ClassrequiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        initializer.initialize(context);
    }
}11.刷新上下文（这部分会调用Spring里的代码，包括自动装配Tomcat）
private void refreshContext(ConfigurableApplicationContext context) {
    // 之前设置的this.registerShutdownHook = true;创建线程，该线程用来在java程序关闭后释放资源
    if (this.registerShutdownHook) {
        try {
            context.registerShutdownHook();
        } catch (AccessControlException var3) {
        }
    }
    this.refresh((ApplicationContext)context);
}
上面的this.refresh((ApplicationContext)context);其实就在调用Spring相关包了
  
    

public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {
        // 刷新前准备工作，设置了容器的启动时间、加载environment对象、准备监听器等
        this.prepareRefresh();
        // 获取BeanFactory，类型是DefaultListableBeanFactory
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        // 把配置和属性信息填充到beanFactory中
        this.prepareBeanFactory(beanFactory);

        try {
            // 
            this.postProcessBeanFactory(beanFactory);
            this.invokeBeanFactoryPostProcessors(beanFactory);
            // 注册BeanPostProcessor（初始化时才会调用）
            this.registerBeanPostProcessors(beanFactory);
            // 初始化MessageSource组件，消息处理相关
            this.initMessageSource();
            // 事件广播相关
            this.initApplicationEventMulticaster();
            // 具体由子类实现，根据Spring容器的种类进行不同的事情处理.
            this.onRefresh();
            // 注册引用的监听器
            this.registerListeners();
            // 实例非懒加载的单例
            this.finishBeanFactoryInitialization(beanFactory);
            // 完成刷新并进行通知广播
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }
    }
}
11.1beanFactory
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();这部分
  
    
 
 11.2this.onRefresh();
根据不同Spring容器来的创建不同容器
// 项目时web项目，用的ServletWebServerApplicationContext
// 对应代码如下，由this.createWebServer();创建具体的Servlet容器
protected void onRefresh() {
    super.onRefresh();

    try {
        // 由于SpringBoot内置Tomcat容器，所以这里实际上会创建一个TomcatServletWebServerFactory生成TomcatWebServer
        this.createWebServer();
    } catch (Throwable var2) {
        throw new ApplicationContextException("Unable to start web server", var2);
    }
}
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
            

            网页标题：SpringBoot启动流程-创新互联            

            文章URL：http://6mz.cn/article/csepig.html
        
    
    

        
其他资讯