资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划，从策略到执行的一站式服务

网站建设 >

查看其它板块

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启动流程-创新互联            

            文章分享：http://cdkjz.cn/article/csepig.html
        
        

            返回首页
            了解更多建站资讯
        

    



    
相关资讯

    

        
    





    

        

            

                多年建站经验
            

            

                
多一份参考，总有益处

                
 联系快上网，免费获得专属《策划方案》及报价

                

                    
咨询相关问题或预约面谈，可以通过以下方式与我们联系

                    
 大客户专线   成都：13518219792
                          座机：028-86922220
                    

                

            

        

        

            在线咨询
            提交需求
        

    





    

        

            

                友情链接
                交换友情链接
            

            

                

                    B2C电商系统企业网站建设公司成都西云机房乐尚佳花箱上市集团网站建设网站优化排名推广无边发光字制作H5建站簇桥薇薇新娘中晴建设                

            

        

    

    

        

            
成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询028-86922220

            

                成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

            
专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图