SpringBoot源码分析之SpringBoot的启动过程
先看示例html
SpringBoot的启动很简单，在许多状况下，你能够委托给静态SpringApplication.run方法，代码以下：java
@SpringBootApplication public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } }
从代码上能够看出，调用了SpringApplication的静态方法run。这个run方法会构造一个SpringApplication的实例，而后再调用这里实例的run方法就表示启动SpringBoot。git
当你的应用程序启动时，你应该看到相似于如下输出的内容:github
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.5.10.RELEASE)
所以，想要分析SpringBoot的启动过程，咱们须要熟悉SpringApplication的构造过程以及SpringApplication的run方法执行过程便可。web
咱们以上述这段代码为例，分析SpringBoot的启动过程。spring
1、SpringApplication的构造过程
SpringApplication构造的时候内部会调用一个private方法initialize：springboot
public SpringApplication(Object... sources) { initialize(sources); // sources目前是一个MyApplication的class对象 } private void initialize(Object[] sources) { if (sources != null && sources.length > 0) { this.sources.addAll(Arrays.asList(sources)); // 把sources设置到SpringApplication的sources属性中，目前只是一个MyApplication类对象 } this.webEnvironment = deduceWebEnvironment(); // 判断是不是web程序，若是(javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext）都在当前的类加载器中，则为true不然为false，判断结果设置到webEnvironment属性中
// 从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化后设置到SpringApplication的initializers属性中。这个过程也就是找出全部的应用程序初始化器 setInitializers((Collection) getSpringFactoriesInstances( ApplicationContextInitializer.class));
// 从spring.factories文件中找出key为ApplicationListener的类并实例化后设置到SpringApplication的listeners属性中。这个过程就是找出全部的应用程序事件监听器 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); // 找出main类，这里是MyApplication类 this.mainApplicationClass = deduceMainApplicationClass(); }
下面分别介绍下载SpringApplication的构造中，涉及到的几个类：app
1.一、ApplicationContextInitializer，应用程序初始化器，作一些初始化的工做：less
public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> { void initialize(C applicationContext); }
Springboot中目前有以下这些ContextInitializer，看截图：ide
1.二、ApplicationListener，应用程序事件(ApplicationEvent)监听器：
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener { void onApplicationEvent(E event); }
这里的应用程序事件(ApplicationEvent)有：应用程序启动事件(ApplicationStartedEvent)、失败事件(ApplicationFailedEvent)、准备事件(ApplicationPreparedEvent)等。
应用程序事件监听器跟监听事件是绑定的。好比：
- ConfigServerBootstrapApplicationListener只跟ApplicationEnvironmentPreparedEvent事件绑定，
- LiquibaseServiceLocatorApplicationListener只跟ApplicationStartedEvent事件绑定，
- LoggingApplicationListener跟全部事件绑定等。
默认状况下，initialize方法从spring.factories文件中找出的key为ApplicationContextInitializer的类有：
org.springframework.boot.context.config.DelegatingApplicationContextInitializer
org.springframework.boot.context.ContextIdApplicationContextInitializer
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer
org.springframework.boot.context.web.ServerPortInfoApplicationContextInitializer
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer
key为ApplicationListener的有：
org.springframework.boot.context.config.ConfigFileApplicationListener
org.springframework.boot.context.config.AnsiOutputApplicationListener
org.springframework.boot.logging.LoggingApplicationListener
org.springframework.boot.logging.ClasspathLoggingApplicationListener
org.springframework.boot.autoconfigure.BackgroundPreinitializer
org.springframework.boot.context.config.DelegatingApplicationListener
org.springframework.boot.builder.ParentContextCloserApplicationListener
org.springframework.boot.context.FileEncodingApplicationListener
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener
2、SpringApplication的执行
SpringApplication的run方法代码以下：
public ConfigurableApplicationContext run(String... args) { //①开启任务执行时间监听器 StopWatch stopWatch = new StopWatch(); // 开始执行，记录开始时间 stopWatch.start(); ConfigurableApplicationContext context = null; FailureAnalyzers analyzers = null; //设置系统属性『java.awt.headless』，为true则启用headless模式支持 configureHeadlessProperty(); //②经过*SpringFactoriesLoader*检索*META-INF/spring.factories*， //找到声明的全部SpringApplicationRunListener的实现类并将其实例化， //以后逐个调用其started()方法，广播SpringBoot要开始执行了。 SpringApplicationRunListeners listeners = getRunListeners(args); //至关于批量的发布事件，及批量的监听器处理事件进行相应的操做 listeners.starting(); try { //构造一个应用程序参数持有类 ApplicationArguments applicationArguments = new DefaultApplicationArguments( args); //③建立并配置当前SpringBoot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）, //并遍历调用全部的SpringApplicationRunListener的environmentPrepared()方法，广播Environment准备完毕。 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); //④决定是否打印Banner Banner printedBanner = printBanner(environment); //⑤根据webEnvironment的值来决定建立何种类型的ApplicationContext对象 //若是是web环境，则建立org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext //不然建立org.springframework.context.annotation.AnnotationConfigApplicationContext context = createApplicationContext(); //⑥-1注册异常分析器 analyzers = new FailureAnalyzers(context); //⑥-2为ApplicationContext加载environment，以后逐个执行ApplicationContextInitializer的initialize()方法来进一步封装ApplicationContext， //并调用全部的SpringApplicationRunListener的contextPrepared()方法，【EventPublishingRunListener只提供了一个空的contextPrepared()方法】， //以后初始化IoC容器，并调用SpringApplicationRunListener的contextLoaded()方法，广播ApplicationContext的IoC加载完成， //这里就包括经过**@EnableAutoConfiguration**导入的各类自动配置类。 prepareContext(context, environment, listeners, applicationArguments, printedBanner); //⑦初始化全部自动配置类，调用ApplicationContext的refresh()方法 refreshContext(context); //⑧遍历全部注册的ApplicationRunner和CommandLineRunner，并执行其run()方法。 //该过程能够理解为是SpringBoot完成ApplicationContext初始化前的最后一步工做， //咱们能够实现本身的ApplicationRunner或者CommandLineRunner，来对SpringBoot的启动过程进行扩展。 afterRefresh(context, applicationArguments); //⑨调用全部的SpringApplicationRunListener的finished()方法，广播SpringBoot已经完成了ApplicationContext初始化的所有过程。 listeners.finished(context, null); //⑩关闭任务执行时间监听器 stopWatch.stop(); //⑪若是开启日志，则打印执行是时间
if (this.logStartupInfo) { new StartupInfoLogger(this.mainApplicationClass) .logStarted(getApplicationLog(), stopWatch); } return context; } catch (Throwable ex) { //⑫调用异常分析器打印报告，调用全部的SpringApplicationRunListener的finished()方法将异常信息发布出去
handleRunFailure(context, listeners, analyzers, ex); throw new IllegalStateException(ex); } }
相关的分析：
①StopWatch，StopWatch相关见《Spring计时器StopWatch使用》
分析run方法以前，先看一下SpringApplication中的一些事件和监听器概念。
②、首先是SpringApplicationRunListeners类和SpringApplicationRunListener类的介绍
- SpringApplicationRunListeners类：
SpringApplicationRunListeners内部持有SpringApplicationRunListener集合和1个Log日志类。用于SpringApplicationRunListener监听器的批量执行。
class SpringApplicationRunListeners { private final Log log; private final List<SpringApplicationRunListener> listeners;
- SpringApplicationRunListener类：
SpringApplicationRunListener看名字也知道用于监听SpringApplication的run方法的执行。
它定义了5个步骤：
-
- started(run方法执行的时候立马执行；对应事件的类型是ApplicationStartedEvent)：通知监听器，SpringBoot开始执行
- environmentPrepared(ApplicationContext建立以前而且环境信息准备好的时候调用；对应事件的类型是ApplicationEnvironmentPreparedEvent)：通知监听器，Environment准备完成
- contextPrepared(ApplicationContext建立好而且在source加载以前调用一次；没有具体的对应事件)：通知监听器，ApplicationContext已经建立并初始化完成
- contextLoaded(ApplicationContext建立并加载以后并在refresh以前调用；对应事件的类型是ApplicationPreparedEvent)：通知监听器，ApplicationContext已经完成IoC配置价值
- finished(run方法结束以前调用；对应事件的类型是ApplicationReadyEvent或ApplicationFailedEvent)：通知监听器，SpringBoot启动完成
SpringApplicationRunListener目前只有一个实现类EventPublishingRunListener，它把监听的过程封装成了SpringApplicationEvent事件并让内部属性(属性名为multicaster)ApplicationEventMulticaster接口的实现类SimpleApplicationEventMulticaster广播出去，广播出去的事件对象会被SpringApplication中的listeners属性进行处理。
因此说SpringApplicationRunListener和ApplicationListener之间的关系是经过ApplicationEventMulticaster广播出去的SpringApplicationEvent所联系起来的。更多的spring事件知识见《ApplicationEvent事件机制源码分析》
③、SpringBoot的Environment的准备
private ConfigurableEnvironment prepareEnvironment( SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) { // 建立SpringBoot的Environment，多是StandardServletEnvironment或者StandardEnvironment ConfigurableEnvironment environment = getOrCreateEnvironment(); //包括配置要使用的PropertySource以及Profile configureEnvironment(environment, applicationArguments.getSourceArgs()); //遍历调用全部的Environment的environmentPrepared方法，目前只有一个实现类EventPublishRunListener，即调用其multicastEvent，广播事件 listeners.environmentPrepared(environment); if (!this.webEnvironment) { //将给定环境转换为标准环境。若是环境已是一个标准环境，而不是ConfigurableWebEnvironment，则不执行转换，而且不改变返回值。 environment = new EnvironmentConverter(getClassLoader()) .convertToStandardEnvironmentIfNecessary(environment); } return environment; }
④决定是否打印Banner
private Banner printBanner(ConfigurableEnvironment environment) { //判断是否开启打印,若是没有开启，直接返回不执行下面的打印逻辑 if (this.bannerMode == Banner.Mode.OFF) { return null; } //读取banner文件 ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader : new DefaultResourceLoader(getClassLoader()); SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter( resourceLoader, this.banner); if (this.bannerMode == Mode.LOG) { return bannerPrinter.print(environment, this.mainApplicationClass, logger); } return bannerPrinter.print(environment, this.mainApplicationClass, System.out); }
⑤建立ApplicationContext
protected ConfigurableApplicationContext createApplicationContext() { Class<?> contextClass = this.applicationContextClass; if (contextClass == null) { try { //经过反射得到ApplicationContext的类信息
// 若是是web程序，那么构造org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext容器
// 不然构造org.springframework.context.annotation.AnnotationConfigApplicationContext容器
contextClass = Class.forName(this.webEnvironment ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS); } catch (ClassNotFoundException ex) { throw new IllegalStateException( "Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass", ex); } } //经过类的newInstance建立实例 return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass); } public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationException { Assert.notNull(clazz, "Class must not be null"); if (clazz.isInterface()) { throw new BeanInstantiationException(clazz, "Specified class is an interface"); } try { return clazz.newInstance(); } catch (InstantiationException ex) { throw new BeanInstantiationException(clazz, "Is it an abstract class?", ex); } catch (IllegalAccessException ex) { throw new BeanInstantiationException(clazz, "Is the constructor accessible?", ex); } }
⑥-一、注册异常分析器
public FailureAnalyzers(ConfigurableApplicationContext context) { this(context, null); } FailureAnalyzers(ConfigurableApplicationContext context, ClassLoader classLoader) { Assert.notNull(context, "Context must not be null"); this.classLoader = (classLoader == null ? context.getClassLoader() : classLoader); //经过反射，批量建立FailureAnalyzer,顺序的放到list集合里 this.analyzers = loadFailureAnalyzers(this.classLoader); prepareFailureAnalyzers(this.analyzers, context); } //遍历为每一个FailureAnalyzer调用prepareAnalyzer private void prepareFailureAnalyzers(List<FailureAnalyzer> analyzers, ConfigurableApplicationContext context) { for (FailureAnalyzer analyzer : analyzers) { prepareAnalyzer(context, analyzer); } } //将Analyzer拥有的工厂赋值给上面新建立的Analyzer，提供给Analyzer实例的回调。 //在填充普通bean属性以后调用，但在初始化回调(如InitializingBean.afterPropertiesSet()或自定义init-method)以前调用。 private void prepareAnalyzer(ConfigurableApplicationContext context, FailureAnalyzer analyzer) { if (analyzer instanceof BeanFactoryAware) { ((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory()); } }
⑥-二、ApplicationContext的初始化（environment、initializer）
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) { //为context设置上面的Environment context.setEnvironment(environment); //在ApplicationContext中应用任何相关的后处理。子类能够根据须要应用额外的处理。 postProcessApplicationContext(context); //在刷新上下文以前，将全部的applicationcontextinitialalizer应用于上下文。这里是遍历执行全部的initialize()来进一步封装ApplicationContext applyInitializers(context); // listeners.contextPrepared(context); if (this.logStartupInfo) { logStartupInfo(context.getParent() == null); logStartupProfileInfo(context); } // Add boot specific singleton beans context.getBeanFactory().registerSingleton("springApplicationArguments", applicationArguments); if (printedBanner != null) { context.getBeanFactory().registerSingleton("springBootBanner", printedBanner); } // Load the sources Set<Object> sources = getSources(); Assert.notEmpty(sources, "Sources must not be empty"); load(context, sources.toArray(new Object[sources.size()])); //调用SpringApplicationRunListener的contextLoaded()方法，广播ApplicationContext的IoC加载完成 listeners.contextLoaded(context); } //初始化器作的工做，好比ContextIdApplicationContextInitializer会设置应用程序的id；AutoConfigurationReportLoggingInitializer会给应用程序添加一个条件注解解析器报告等：
//在刷新上下文以前，将全部的applicationcontextinitialalizer应用于上下文。 protected void applyInitializers(ConfigurableApplicationContext context) { for (ApplicationContextInitializer initializer : getInitializers()) { Class<?> requiredType = GenericTypeResolver.resolveTypeArgument( initializer.getClass(), ApplicationContextInitializer.class); Assert.isInstanceOf(requiredType, context, "Unable to call initializer."); initializer.initialize(context); } }
⑦refreshContext
Spring容器的刷新refresh方法内部会作不少不少的事情：好比BeanFactory的设置，BeanFactoryPostProcessor接口的执行、BeanPostProcessor接口的执行、自动化配置类的解析、条件注解的解析、国际化的初始化等等。这部份内容会在以后的文章中进行讲解。
private void refreshContext(ConfigurableApplicationContext context) { //刷新底层应用程序上下文 refresh(context); //增长钩子 if (this.registerShutdownHook) { try { context.registerShutdownHook(); } catch (AccessControlException ex) { // Not allowed in some environments. } } } //刷新底层应用程序上下文 protected void refresh(ApplicationContext applicationContext) { Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext); ((AbstractApplicationContext) applicationContext).refresh(); }
⑧遍历全部注册的ApplicationRunner和CommandLineRunner，并执行其run()方法
protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) { callRunners(context, args); } private void callRunners(ApplicationContext context, ApplicationArguments args) { List<Object> runners = new ArrayList<Object>(); // 找出Spring容器中ApplicationRunner接口的实现类 runners.addAll(context.getBeansOfType(ApplicationRunner.class).values()); // 找出Spring容器中CommandLineRunner接口的实现类 runners.addAll(context.getBeansOfType(CommandLineRunner.class).values()); // 对runners进行排序 AnnotationAwareOrderComparator.sort(runners); // 遍历runners依次执行 for (Object runner : new LinkedHashSet<Object>(runners)) { // 若是是ApplicationRunner，进行ApplicationRunner的run方法调用 if (runner instanceof ApplicationRunner) { callRunner((ApplicationRunner) runner, args); } // 若是是CommandLineRunner，进行CommandLineRunner的run方法调用 if (runner instanceof CommandLineRunner) { callRunner((CommandLineRunner) runner, args); } } }
⑨调用全部的SpringApplicationRunListener的finished()方法，广播SpringBoot已经完成了ApplicationContext初始化的所有过程
public void finished(ConfigurableApplicationContext context, Throwable exception) { for (SpringApplicationRunListener listener : this.listeners) { callFinishedListener(listener, context, exception); } } private void callFinishedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context, Throwable exception) { try { listener.finished(context, exception); } catch (Throwable ex) { if (exception == null) { ReflectionUtils.rethrowRuntimeException(ex); } if (this.log.isDebugEnabled()) { this.log.error("Error handling failed", ex); } else { String message = ex.getMessage(); message = (message == null ? "no error message" : message); this.log.warn("Error handling failed (" + message + ")"); } } } @Override public void finished(ConfigurableApplicationContext context, Throwable exception) { //建立springboot初始化完成事件 SpringApplicationEvent event = getFinishedEvent(context, exception); if (context != null && context.isActive()) { //活动上下文 context.publishEvent(event); } else { //非活动上下文没有多播程序，直接使用initialMulticaster进行广播 if (context instanceof AbstractApplicationContext) { for (ApplicationListener<?> listener : ((AbstractApplicationContext) context) .getApplicationListeners()) { this.initialMulticaster.addApplicationListener(listener); } } if (event instanceof ApplicationFailedEvent) { this.initialMulticaster.setErrorHandler(new LoggingErrorHandler()); } this.initialMulticaster.multicastEvent(event); } } private SpringApplicationEvent getFinishedEvent( ConfigurableApplicationContext context, Throwable exception) { //若是出错了，返回ApplicationFailedEvent的事件 if (exception != null) { return new ApplicationFailedEvent(this.application, this.args, context, exception); } return new ApplicationReadyEvent(this.application, this.args, context); }
⑫调用异常分析器打印报告，调用全部的SpringApplicationRunListener的finished()方法将异常信息发布出去
private void handleRunFailure(ConfigurableApplicationContext context, SpringApplicationRunListeners listeners, FailureAnalyzers analyzers, Throwable exception) { try { try { handleExitCode(context, exception); listeners.finished(context, exception); } finally { reportFailure(analyzers, exception); if (context != null) { context.close(); } } } catch (Exception ex) { logger.warn("Unable to close ApplicationContext", ex); } ReflectionUtils.rethrowRuntimeException(exception); } private void handleExitCode(ConfigurableApplicationContext context, Throwable exception) { //根据Exception获得退出码 int exitCode = getExitCodeFromException(context, exception); //若是exitCode不为0，发布ExitCodeEvent事件 if (exitCode != 0) { if (context != null) { context.publishEvent(new ExitCodeEvent(context, exitCode)); } SpringBootExceptionHandler handler = getSpringBootExceptionHandler(); if (handler != null) { handler.registerExitCode(exitCode); } } }
这样run方法执行完成以后。Spring容器也已经初始化完成，各类监听器和初始化器也作了相应的工做。
总结
-
SpringBoot的启动过程，实际上就是对ApplicationContext的初始化过程。
-
ApplicationContext建立后马上为其设置Environment，并由ApplicationContextInitializer对其进一步封装。
-
经过SpringApplicationRunListener在ApplicationContext初始化过程当中各个时点发布各类广播事件，并由ApplicationListener负责接收广播事件。
-
初始化过程当中完成IoC的注入，包括经过@EnableAutoConfiguration导入的各类自动配置类。
-
初始化完成前调用ApplicationRunner和CommandLineRunner的实现类。
SpringBoot启动的时候，不论调用什么方法，都会构造一个SpringApplication的实例，而后调用这个实例的run方法，这样就表示启动SpringBoot。
在run方法调用以前，也就是构造SpringApplication的时候会进行初始化的工做，初始化的时候会作如下几件事：
- 把参数sources设置到SpringApplication属性中，这个sources能够是任何类型的参数。本文的例子中这个sources就是MyApplication的class对象
- 判断是不是web程序，并设置到webEnvironment这个boolean属性中
- 找出全部的初始化器，默认有5个，设置到initializers属性中
- 找出全部的应用程序监听器，默认有9个，设置到listeners属性中
- 找出运行的主类(main class)
SpringApplication构造完成以后调用run方法，启动SpringApplication，run方法执行的时候会作如下几件事：
- 构造一个StopWatch，观察SpringApplication的执行
- 找出全部的SpringApplicationRunListener并封装到SpringApplicationRunListeners中，用于监听run方法的执行。监听的过程当中会封装成事件并广播出去让初始化过程当中产生的应用程序监听器进行监听
- 构造Spring容器(ApplicationContext)，并返回
3.1 建立Spring容器的判断是不是web环境，是的话构造AnnotationConfigEmbeddedWebApplicationContext，不然构造AnnotationConfigApplicationContext
3.2 初始化过程当中产生的初始化器在这个时候开始工做
3.3 Spring容器的刷新(完成bean的解析、各类processor接口的执行、条件注解的解析等等) - 从Spring容器中找出ApplicationRunner和CommandLineRunner接口的实现类并排序后依次执行
例子
写了一个例子用来验证分析的启动逻辑，包括自定义的初始化器、监听器、ApplicationRunner和CommandLineRunner。
地址在：https://github.com/fangjian0423/springboot-analysis/tree/master/springboot-startup
相关文章
- 1. SpringBoot源码解析 -- SpringBoot启动过程
- 2. SpringBoot源码分析之SpringBoot的启动过程
- 3. SpringBoot源码：启动过程分析(一)
- 4. SpringBoot源码：启动过程分析(二)
- 5. SpringBoot启动流程源码分析--SpringBoot源码分析(一)
- 6. springboot源码分析——SpringBoot的启动过程
- 7. springboot 1.5.3 源码分析（一）：springboot启动初始化过程源码分析
- 8. 源码分析SpringBoot启动
- 9. SpringBoot启动过程源码解析
- 10. SpringBoot源码分析之---SpringBoot项目启动类SpringApplication浅析
- 更多相关文章...
- • Swift 析构过程 - Swift 教程
- • 启动MySQL服务 - MySQL教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • SpringBoot中properties文件不能自动提示解决方法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 融合阿里云，牛客助您找到心仪好工作
- 2. 解决jdbc(jdbctemplate)在测试类时不报错在TomCatb部署后报错
- 3. 解决PyCharm GoLand IntelliJ 等 JetBrains 系列 IDE无法输入中文
- 4. vue+ant design中关于图片请求不显示的问题。
- 5. insufficient memory && Native memory allocation (malloc) failed
- 6. 解决IDEA用Maven创建的Web工程不能创建Java Class文件的问题
- 7. [已解决] Error: Cannot download ‘https://start.spring.io/starter.zip?
- 8. 在idea让java文件夹正常使用
- 9. Eclipse启动提示“subversive connector discovery”
- 10. 帅某-技巧-快速转帖博主文章（article_content）
欢迎关注本站公众号,获取更多信息
相关文章
- 1. SpringBoot源码解析 -- SpringBoot启动过程
- 2. SpringBoot源码分析之SpringBoot的启动过程
- 3. SpringBoot源码：启动过程分析(一)
- 4. SpringBoot源码：启动过程分析(二)
- 5. SpringBoot启动流程源码分析--SpringBoot源码分析(一)
- 6. springboot源码分析——SpringBoot的启动过程
- 7. springboot 1.5.3 源码分析（一）：springboot启动初始化过程源码分析
- 8. 源码分析SpringBoot启动
- 9. SpringBoot启动过程源码解析
- 10. SpringBoot源码分析之---SpringBoot项目启动类SpringApplication浅析