SpringBoot启动过程的实现_Java

springboot启动过程分析，首先打开springboot的启用入口main类：

@springbootapplication
public class applicationmain{
 public static void main(string[] args) {
  springapplication.run(applicationmain.class, args);
 }
}

可以看到main方法里面只有一行核心启用类：springapplication.run(applicationmain.class, args);这个是关键，在改行打上断点，debug模式启动该main类。点击下一步进入springapplication的源码对应的run方法：

public static configurableapplicationcontext run(object[] sources, string[] args) {
  return (new springapplication(sources)).run(args);
 }

初始化springapplication

springapplication实例化之前会调用构造方法进行初始化：

public springapplication(object... sources) {
  this.bannermode = mode.console;
  this.logstartupinfo = true;
  this.addcommandlineproperties = true;
  this.headless = true;
  this.registershutdownhook = true;
  this.additionalprofiles = new hashset();
  this.initialize(sources);
 }

而springapplication构造方法的核心是：this.initialize(sources);初始化方法，springapplication通过调用该方法来初始化。

private void initialize(object[] sources) {
 if (sources != null && sources.length > 0) {
  this.sources.addall(arrays.aslist(sources));
 }
 this.webenvironment = deducewebenvironment();
 setinitializers((collection) getspringfactoriesinstances(
   applicationcontextinitializer.class));
 setlisteners((collection) getspringfactoriesinstances(applicationlistener.class));
 this.mainapplicationclass = deducemainapplicationclass();
}

1.deducewebenvironment方法是用来判断当前应用的环境，该方法通过获取这两个类来判断当前环境是否是web环境，如果能获得这两个类说明是web环境，否则不是。

javax.servlet.servlet
org.springframework.web.context.configurablewebapplicationcontext

2.getspringfactoriesinstances方法主要用来从spring.factories文件中找出key为applicationcontextinitializer的类并实例化，然后调用setinitializers方法设置到springapplication的initializers属性中。这个过程就是找出所有的应用程序初始化器。

private <t> collection<? extends t> getspringfactoriesinstances(class<t> type, class<?>[] parametertypes, object... args) {
  classloader classloader = thread.currentthread().getcontextclassloader();
  set<string> names = new linkedhashset(springfactoriesloader.loadfactorynames(type, classloader));
  list<t> instances = this.createspringfactoriesinstances(type, parametertypes, classloader, args, names);
  annotationawareordercomparator.sort(instances);
  return instances;
 }

public static list<string> loadfactorynames(class<?> factoryclass, classloader classloader) {
  string factoryclassname = factoryclass.getname();

  try {
   //从spring.factories文件中找出key为applicationcontextinitializer的类
   enumeration<url> urls = classloader != null ? classloader.getresources("meta-inf/spring.factories") : classloader.getsystemresources("meta-inf/spring.factories");
   arraylist result = new arraylist();

   while(urls.hasmoreelements()) {
    url url = (url)urls.nextelement();
    properties properties = propertiesloaderutils.loadproperties(new urlresource(url));
    string factoryclassnames = properties.getproperty(factoryclassname);
    result.addall(arrays.aslist(stringutils.commadelimitedlisttostringarray(factoryclassnames)));
   }

   return result;
  } catch (ioexception var8) {
   throw new illegalargumentexception("unable to load [" + factoryclass.getname() + "] factories from location [" + "meta-inf/spring.factories" + "]", var8);
  }
 }

当前的初始化器有如下几个:

在这里插入图片描述

3.同理调用getspringfactoriesinstances从spring.factories文件中找出key为applicationlistener的类并实例化，然后调用setlisteners方法设置到springapplication的listeners属性中。这个过程就是找出所有的应用程序事件监听器。
当前的事件监听器有如下几个：

在这里插入图片描述

4.调用deducemainapplicationclass方法找出main类，就是这里的applicationmain类。

运行springapplication

初始化springapplication完成之后，调用run方法运行：

public configurableapplicationcontext run(string... args) {
  //计时器，统计任务的执行时间
  stopwatch stopwatch = new stopwatch();
  //开始执行
  stopwatch.start();
  configurableapplicationcontext context = null;
  failureanalyzers analyzers = null;
  this.configureheadlessproperty();
  // 获取springapplicationrunlisteners启动事件监听器，这里只有一个eventpublishingrunlistener
  springapplicationrunlisteners listeners = this.getrunlisteners(args);
  // 封装成springapplicationevent事件然后广播出去给springapplication中的listeners所监听
  listeners.starting();

  try {
   // 构造一个应用程序参数持有类
   applicationarguments applicationarguments = new defaultapplicationarguments(args);
   // 准备并配置环境
   configurableenvironment environment = this.prepareenvironment(listeners, applicationarguments);
    // 打印banner图形
   banner printedbanner = this.printbanner(environment);
   // 创建spring容器
   context = this.createapplicationcontext();
   new failureanalyzers(context);
   // 配置spring容器
   this.preparecontext(context, environment, listeners, applicationarguments, printedbanner);
   // 容器上下文刷新
   this.refreshcontext(context);
   // 容器创建完成之后调用afterrefresh方法
   this.afterrefresh(context, applicationarguments);
   // 调用监听器，广播spring启动结束的事件
   listeners.finished(context, (throwable)null);
   // 停止计时器
   stopwatch.stop();
   if (this.logstartupinfo) {
    (new startupinfologger(this.mainapplicationclass)).logstarted(this.getapplicationlog(), stopwatch);
   }

   return context;
  } catch (throwable var9) {
   this.handlerunfailure(context, listeners, (failureanalyzers)analyzers, var9);
   throw new illegalstateexception(var9);
  }
 }

springapplicationrunlisteners

1.获取启动事件监听器，可以看看该方法：

springapplicationrunlisteners listeners = this.getrunlisteners(args);

private springapplicationrunlisteners getrunlisteners(string[] args) {
  class<?>[] types = new class[]{springapplication.class, string[].class};
  return new springapplicationrunlisteners(logger, this.getspringfactoriesinstances(springapplicationrunlistener.class, types, this, args));
 }

同样的通过调用getspringfactoriesinstances方法去meta-inf/spring.factories文件中拿到springapplicationrunlistener监听器，当前的springapplicationrunlistener事件监听器只有一个eventpublishingrunlistener广播事件监听器：

在这里插入图片描述

springapplicationrunlisteners内部持有springapplicationrunlistener集合和1个log日志类。用于springapplicationrunlistener监听器的批量执行。

springapplicationrunlistener用于监听springapplication的run方法的执行，它定义了5个步骤：

1.starting：run方法执行的时候立马执行，对应的事件类型是applicationstartedevent
2.environmentprepared：applicationcontext创建之前并且环境信息准备好的时候调用，对应的事件类型是applicationenvironmentpreparedevent
3.contextprepared：applicationcontext创建好并且在source加载之前调用一次，没有具体的对应事件
4.contextloaded：applicationcontext创建并加载之后并在refresh之前调用，对应的事件类型是applicationpreparedevent
5.finished：run方法结束之前调用，对应事件的类型是applicationreadyevent或applicationfailedevent

springapplicationrunlistener目前只有一个实现类eventpublishingrunlistener，详见获取springapplicationrunlisteners。它把监听的过程封装成了springapplicationevent事件并让内部属性applicationeventmulticaster接口的实现类simpleapplicationeventmulticaster广播出去，广播出去的事件对象会被springapplication中的listeners属性进行处理。

所以说springapplicationrunlistener和applicationlistener之间的关系是通过applicationeventmulticaster广播出去的springapplicationevent所联系起来的

2.启动事件监听器

通过listeners.starting()可以启动事件监听器springapplicationrunlistener ，springapplicationrunlistener 是一个启动事件监听器接口：

public interface springapplicationrunlistener {
 void starting();

 void environmentprepared(configurableenvironment var1);

 void contextprepared(configurableapplicationcontext var1);

 void contextloaded(configurableapplicationcontext var1);

 void finished(configurableapplicationcontext var1, throwable var2);
}

springapplicationrunlistener 接口的具体实现就是eventpublishingrunlistener类，我们主要来看一下它的startting方法，该方法会封装成springapplicationevent事件然后广播出去给springapplication中的listeners所监听。

public void starting() {
  this.initialmulticaster.multicastevent(new applicationstartedevent(this.application, this.args));
 }

配置并准备环境

private configurableenvironment prepareenvironment(
  springapplicationrunlisteners listeners,
  applicationarguments applicationarguments) {
 // 创建应用程序的环境信息。如果是web程序，创建standardservletenvironment；否则，创建standardenvironment
 configurableenvironment environment = getorcreateenvironment();
 // 配置环境信息。比如profile，命令行参数
 configureenvironment(environment, applicationarguments.getsourceargs());
 // 广播出applicationenvironmentpreparedevent事件给相应的监听器执行
 listeners.environmentprepared(environment);
 // 环境信息的校对
 if (!this.webenvironment) {
  environment = new environmentconverter(getclassloader())
    .converttostandardenvironmentifnecessary(environment);
 }
 return environment;
}

判断环境，如果是web程序，创建standardservletenvironment；否则，创建standardenvironment。

private configurableenvironment getorcreateenvironment() {
  if (this.environment != null) {
   return this.environment;
  } else {
   return (configurableenvironment)(this.webenvironment ? new standardservletenvironment() : new standardenvironment());
  }
 }

创建spring容器上下文

protected configurableapplicationcontext createapplicationcontext() {
 class<?> contextclass = this.applicationcontextclass;
 if (contextclass == null) {
  try {
   // 判断是否是web应用，
   // 如果是则创建annotationconfigembeddedwebapplicationcontext，否则创建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);
  }
 }
 return (configurableapplicationcontext) beanutils.instantiate(contextclass);
}

配置spring容器上下文

private void preparecontext(configurableapplicationcontext context,
  configurableenvironment environment, springapplicationrunlisteners listeners,
  applicationarguments applicationarguments, banner printedbanner) {
 // 设置spring容器上下文的环境信息
 context.setenvironment(environment);
 // spring容器创建之后做一些额外的事
 postprocessapplicationcontext(context);
 // springapplication的初始化器开始工作
 applyinitializers(context);
 // 遍历调用springapplicationrunlistener的contextprepared方法。目前只是将这个事件广播器注册到spring容器中
 listeners.contextprepared(context);
 if (this.logstartupinfo) {
  logstartupinfo(context.getparent() == null);
  logstartupprofileinfo(context);
 }

 // 把应用程序参数持有类注册到spring容器中，并且是一个单例
 context.getbeanfactory().registersingleton("springapplicationarguments",
   applicationarguments);
 if (printedbanner != null) {
  context.getbeanfactory().registersingleton("springbootbanner", printedbanner);
 }

 // 加载sources，sources是main方法所在的类
 set<object> sources = getsources();
 assert.notempty(sources, "sources must not be empty");
 // 将sources加载到应用上下文中。最终调用的是annotatedbeandefinitionreader.registerbean方法
 load(context, sources.toarray(new object[sources.size()]));
 // 广播出applicationpreparedevent事件给相应的监听器执行
 // 执行eventpublishingrunlistener.contextloaded方法
 listeners.contextloaded(context);
}

spring容器创建之后回调方法postprocessapplicationcontext

protected void postprocessapplicationcontext(configurableapplicationcontext context) {
 // 如果springapplication设置了实例命名生成器，则注册到spring容器中
 if (this.beannamegenerator != null) {
  context.getbeanfactory().registersingleton(
    annotationconfigutils.configuration_bean_name_generator,
    this.beannamegenerator);
 }
 // 如果springapplication设置了资源加载器，设置到spring容器中
 if (this.resourceloader != null) {
  if (context instanceof genericapplicationcontext) {
   ((genericapplicationcontext) context)
     .setresourceloader(this.resourceloader);
  }
  if (context instanceof defaultresourceloader) {
   ((defaultresourceloader) context)
     .setclassloader(this.resourceloader.getclassloader());
  }
 }
}

初始化器开始工作

protected void applyinitializers(configurableapplicationcontext context) {
 // 遍历每个初始化器，调用对应的initialize方法
 for (applicationcontextinitializer initializer : getinitializers()) {
  class<?> requiredtype = generictyperesolver.resolvetypeargument(
    initializer.getclass(), applicationcontextinitializer.class);
  assert.isinstanceof(requiredtype, context, "unable to call initializer.");
  initializer.initialize(context);
 }
}

spring容器创建完成之后会调用afterrefresh方法

applicationrunner、commandlinerunner类都是在在afterrefresh方法中调用的，也就是说在spring容器创建之后执行的。

protected void applyinitializers(configurableapplicationcontext context) {
 // 遍历每个初始化器，调用对应的initialize方法
 for (applicationcontextinitializer initializer : getinitializers()) {
  class<?> requiredtype = generictyperesolver.resolvetypeargument(
    initializer.getclass(), applicationcontextinitializer.class);
  assert.isinstanceof(requiredtype, context, "unable to call initializer.");
  initializer.initialize(context);
 }
}

参考：https://blog.wangqi.love/articles/spring/springboot启动过程.html

到此这篇关于springboot启动过程的实现的文章就介绍到这了,更多相关springboot启动过程内容请搜索移动技术网以前的文章或继续浏览下面的相关文章希望大家以后多多支持移动技术网！