Spring Boot启动过程完全解析（二）

上篇给大家介绍了spring boot启动过程完全解析(一)，大家可以点击参考下

　　该说refreshcontext(context)了，首先是判断context是否是abstractapplicationcontext派生类的实例，之后调用了强转为abstractapplicationcontext类型并调用它的refresh方法。由于annotationconfigembeddedwebapplicationcontext继承自embeddedwebapplicationcontext，所以会执行embeddedwebapplicationcontext的refresh方法，继而执行其中的super.refresh。这个refresh也就是abstractapplicationcontext的refresh方法了，它内部是一个synchronized锁全局的代码块，同样的加锁方法还有这个类里的close和registershutdownhook方法。

　　同步代码块中第一个方法preparerefresh，首先会执行annotationconfigembeddedwebapplicationcontext的preparerefresh方法：

 protected void preparerefresh() {
  this.scanner.clearcache();
  super.preparerefresh();
 }

　　这个super也就是abstractapplicationcontext，它的preparerefresh方法逻辑是：生成启动时间；设置closed状态为false；active状态为true；initpropertysources方法主要是调用了abstractenvironment的getpropertysources方法获取了之前springapplication的prepareenvironment方法中getorcreateenvironment方法准备的各种环境变量及配置并用于初始化servletpropertysources。具体的servletcontextinitparams这些是在环境对象初始化时由各集成级别environment的customizepropertysources方法中初始化的。

 　　接着的getenvironment().validaterequiredproperties()方法实际执行了abstractenvironment中的this.propertyresolver.validaterequiredproperties()，主要是验证了被占位的key如果是required的值不能为null。preparerefresh的最后是初始化this.earlyapplicationevents = new linkedhashset<applicationevent>()。*****

　　只够是获取beanfactory实例的方法obtainfreshbeanfactory()，首先在refreshbeanfactory方法中用原子布尔类型判断是否刷新过，beanfactory实例是在createapplicationcontext创建context实例时被创建的，如果没有刷新则设置一个用于序列化的id，id是contextidapplicationcontextinitializer初始化设置的（如未配置该初始化器，是有一个默认objectutils.identitytostring(this)生成的），这个id的生成规则是spring.config.name截取的+":"+server.port的占位截取。设置序列化id时，同时保存了一个id和弱引用defaultlistablebeanfactory实例映射。

　　得到了beanfactory后就是preparebeanfactory(beanfactory)了，逻辑是注册了beanclassloader用于注入的bean实例的创建；standardbeanexpressionresolver用于el表达式，比如配置文件或者@value("#{...}")等使用；用resourceeditorregistrar注册属性转换器，比如xml配置的bean属性都是用的字符串配置的要转成真正的属性类型；addbeanpostprocessor(new applicationcontextawareprocessor(this))注册applicationcontextawareprocessor，它的invokeawareinterfaces方法会对实现指定接口的bean调用指定的set方法；ignoredependencyinterface忽略对这些接口的自动装配，比如aware这些是要做独立处理的，不适合通用的方法；然后是有几个类型直接手动注册，比如beanfactory，这个很好理解；接着注册一个后置处理器applicationlistenerdetector的实例，addbeanpostprocessor注册的会按照注册先后顺序执行；这个方法的最后判断了特定的4个bean名字，如果存在会做相应注册，包括loadtimeweaver、environment、systemproperties和systemenvironment。补充一点，在最开始创建实例的时候还执行过ignoredependencyinterface(beannameaware.class);ignoredependencyinterface(beanfactoryaware.class);ignoredependencyinterface(beanclassloaderaware.class)。

 protected void preparebeanfactory(configurablelistablebeanfactory beanfactory) {
  // tell the internal bean factory to use the context's class loader etc.
  beanfactory.setbeanclassloader(getclassloader());
  beanfactory.setbeanexpressionresolver(new standardbeanexpressionresolver(beanfactory.getbeanclassloader()));
  beanfactory.addpropertyeditorregistrar(new resourceeditorregistrar(this, getenvironment()));
  // configure the bean factory with context callbacks.
  beanfactory.addbeanpostprocessor(new applicationcontextawareprocessor(this));
  beanfactory.ignoredependencyinterface(environmentaware.class);
  beanfactory.ignoredependencyinterface(embeddedvalueresolveraware.class);
  beanfactory.ignoredependencyinterface(resourceloaderaware.class);
  beanfactory.ignoredependencyinterface(applicationeventpublisheraware.class);
  beanfactory.ignoredependencyinterface(messagesourceaware.class);
  beanfactory.ignoredependencyinterface(applicationcontextaware.class);
  // beanfactory interface not registered as resolvable type in a plain factory.
  // messagesource registered (and found for autowiring) as a bean.
  beanfactory.registerresolvabledependency(beanfactory.class, beanfactory);
  beanfactory.registerresolvabledependency(resourceloader.class, this);
  beanfactory.registerresolvabledependency(applicationeventpublisher.class, this);
  beanfactory.registerresolvabledependency(applicationcontext.class, this);
  // register early post-processor for detecting inner beans as applicationlisteners.
  beanfactory.addbeanpostprocessor(new applicationlistenerdetector(this));
  // detect a loadtimeweaver and prepare for weaving, if found.
  if (beanfactory.containsbean(load_time_weaver_bean_name)) {
   beanfactory.addbeanpostprocessor(new loadtimeweaverawareprocessor(beanfactory));
   // set a temporary classloader for type matching.
   beanfactory.settempclassloader(new contexttypematchclassloader(beanfactory.getbeanclassloader()));
  }
  // register default environment beans.
  if (!beanfactory.containslocalbean(environment_bean_name)) {
   beanfactory.registersingleton(environment_bean_name, getenvironment());
  }
  if (!beanfactory.containslocalbean(system_properties_bean_name)) {
   beanfactory.registersingleton(system_properties_bean_name, getenvironment().getsystemproperties());
  }
  if (!beanfactory.containslocalbean(system_environment_bean_name)) {
   beanfactory.registersingleton(system_environment_bean_name, getenvironment().getsystemenvironment());
  }
 }

 　　之后到了refresh的postprocessbeanfactory方法，首先是会走到annotationconfigembeddedwebapplicationcontext的override，需要注意的一点是，这是web环境，如果不是是不会加载这个上下文的，也就不会这么走。它重写的第一步是先走super也就是embeddedwebapplicationcontext的postprocessbeanfactory，这里又注册了个后置处理器webapplicationcontextservletcontextawareprocessor的实例，构造参数是this，也就是当前上下文，同时忽略servletcontextaware接口，这个接口是用于获取servletcontext的，为什么要忽略呢，我猜应该是因为我们既然有了web应用并且内嵌servlet的上下文实例，还要servletcontext的实现就没什么用了，还有可能出现冲突的问题，有空我再确认下。然后是配置的basepackages和annotatedclasses：

@override
 protected void postprocessbeanfactory(configurablelistablebeanfactory beanfactory) {
  super.postprocessbeanfactory(beanfactory);
  if (this.basepackages != null && this.basepackages.length > 0) {
   this.scanner.scan(this.basepackages);
  }
  if (this.annotatedclasses != null && this.annotatedclasses.length > 0) {
   this.reader.register(this.annotatedclasses);
  }
 }

　　到了invokebeanfactorypostprocessors方法，这个方法就是执行之前注册的beanfactory后置处理器的地方。代码一目了然，postprocessorregistrationdelegate的invokebeanfactorypostprocessors中只是有些排序的逻辑，我就不说了：

 /**
  * instantiate and invoke all registered beanfactorypostprocessor beans,
  * respecting explicit order if given.
  * <p>must be called before singleton instantiation.
  */
 protected void invokebeanfactorypostprocessors(configurablelistablebeanfactory beanfactory) {
  postprocessorregistrationdelegate.invokebeanfactorypostprocessors(beanfactory, getbeanfactorypostprocessors());
  // detect a loadtimeweaver and prepare for weaving, if found in the meantime
  // (e.g. through an @bean method registered by configurationclasspostprocessor)
  if (beanfactory.gettempclassloader() == null && beanfactory.containsbean(load_time_weaver_bean_name)) {
   beanfactory.addbeanpostprocessor(new loadtimeweaverawareprocessor(beanfactory));
   beanfactory.settempclassloader(new contexttypematchclassloader(beanfactory.getbeanclassloader()));
  }
 }

 　　beanfactory后置处理器执行之后是注册bean的后置处理器方法registerbeanpostprocessors。例如new beanpostprocessorchecker(beanfactory, beanprocessortargetcount)会在bean没有合适的后置处理器时记条info级日志。applicationlistenerdetector也注册了一个。

　　initmessagesource这个方法在我这没什么用，都说是国际化的，随便百度一下一堆一堆的，而且其实严格来说这篇多数不属于spring boot的部分，这方法我就不细写了。

　　initapplicationeventmulticaster方法主要也就是初始化并注册applicationeventmulticaster的这两句代码：          

this.applicationeventmulticaster = new simpleapplicationeventmulticaster(beanfactory);
   beanfactory.registersingleton(application_event_multicaster_bean_name, this.applicationeventmulticaster);

 　　onrefresh也是根据环境不同加载的上下文不同而不同的，用于支持子类扩展出来的上下文特定的逻辑的。embeddedwebapplicationcontext的onrefresh首先依然是super.onrefresh，逻辑就是初始化了主题；

createembeddedservletcontainer方法名我就不翻译了，一般情况下是使用getbeanfactory .getbeannamesfortype方法找到embeddedservletcontainerfactory类型的实例，这也就是我之前那个问题解决过程中，为什么只要排除掉tomcat引用，引入jetty引用就可以自动换成jetty的原因。创建容器的过程中初始化方法selfinitialize注册了filter和mappingforurlpatterns等，代码在abstractfilterregistrationbean等onstartup，这里就不细说了，如果能抽出时间说说之前查问题的时候查的容器代码再说。然后初始化propertysources，servletcontextinitparams和servletconfiginitparams：

 public static void initservletpropertysources(
   mutablepropertysources propertysources, servletcontext servletcontext, servletconfig servletconfig) {
  assert.notnull(propertysources, "'propertysources' must not be null");
  if (servletcontext != null && propertysources.contains(standardservletenvironment.servlet_context_property_source_name) &&
    propertysources.get(standardservletenvironment.servlet_context_property_source_name) instanceof stubpropertysource) {
   propertysources.replace(standardservletenvironment.servlet_context_property_source_name,
     new servletcontextpropertysource(standardservletenvironment.servlet_context_property_source_name, servletcontext));
  }
  if (servletconfig != null && propertysources.contains(standardservletenvironment.servlet_config_property_source_name) &&
    propertysources.get(standardservletenvironment.servlet_config_property_source_name) instanceof stubpropertysource) {
   propertysources.replace(standardservletenvironment.servlet_config_property_source_name,
     new servletconfigpropertysource(standardservletenvironment.servlet_config_property_source_name, servletconfig));
  }
 }

　　registerlisteners首先注册静态监听：

 @override
 public void addapplicationlistener(applicationlistener<?> listener) {
  synchronized (this.retrievalmutex) {
   this.defaultretriever.applicationlisteners.add(listener);
   this.retrievercache.clear();
  }
 }

　　接着是：

　

　registerlisteners的最后，初始化过的earlyapplicationevents如果有事件，这时候会被发布。

　　finishbeanfactoryinitialization结束beanfactory的初始化并初始化所有非延迟加载的单例。事实上我们自定义的单例bean都是在这里getbean方法初始化的，所以如果注册的bean特别多的话，这个过程就是启动过程中最慢的。初始化开始前先设置configurationfrozen为true，并this.frozenbeandefinitionnames = stringutils.tostringarray ( this. beandefinitionnames )。如果有bean实例实现了smartinitializingsingleton会有后置处理触发，不包括延迟加载的。例如：org.springframework.context.event. internaleventlistenerprocessor会触发eventlistenermethodprocessor的aftersingletonsinstantiated方法对所有对象（object的子类）处理。

　　finishrefresh:refresh的最后一步，发布相应事件。同样先执行embeddedwebapplicationcontext中对应方法的super(embeddedwebapplicationcontext)的对应方法：

 /**
  * finish the refresh of this context, invoking the lifecycleprocessor's
  * onrefresh() method and publishing the
  * {@link org.springframework.context.event.contextrefreshedevent}.
  */
 protected void finishrefresh() {
  // initialize lifecycle processor for this context.
  initlifecycleprocessor();
  // propagate refresh to lifecycle processor first.
  getlifecycleprocessor().onrefresh();
  // publish the final event.
  publishevent(new contextrefreshedevent(this));
  // participate in livebeansview mbean, if active.
  livebeansview.registerapplicationcontext(this);
 }

 　　初始化生命周期处理器，逻辑是判断beanfactory中是否已经注册了lifecycleprocessor，没有就new一个defaultlifecycleprocessor并setbeanfactory(beanfactory)，然后将它赋值给私有lifecycleprocessor类型的this变量。然后执行生命周期处理器的onrefresh，其中先startbeans，被start的beans是通过getbeannamesfortype(lifecycle.class, false, false)从beanfactory中取出来的，例如endpointmbeanexporter和lifecycleprocessor，会去调用bean的start方法，endpointmbeanexporter的start中执行 locateandregisterendpoints方法并设置running属性为true，这个过程加了reentrantlock锁。bean都启动完会设置处理器的running为true。刷新完会发布contextrefreshedevent事件，这个事件除了都有的记录时间还执行了configurationpropertiesbindingpostprocessor的freelocalvalidator方法，我这的逻辑是实际上执行了validatorfactoryimpl的close方法。这个逻辑的最后会检查一个配置spring.livebeansview.mbeandomain是否存在，有就会创建一个mbeanserver：

static void registerapplicationcontext(configurableapplicationcontext applicationcontext) {
  string mbeandomain = applicationcontext.getenvironment().getproperty(mbean_domain_property_name);
  if (mbeandomain != null) {
   synchronized (applicationcontexts) {
    if (applicationcontexts.isempty()) {
     try {
      mbeanserver server = managementfactory.getplatformmbeanserver();
      applicationname = applicationcontext.getapplicationname();
      server.registermbean(new livebeansview(),
        new objectname(mbeandomain, mbean_application_key, applicationname));
     }
     catch (throwable ex) {
      throw new applicationcontextexception("failed to register livebeansview mbean", ex);
     }
    }
    applicationcontexts.add(applicationcontext);
   }
  }
 }

　　finishrefresh最后会启动前面创建的内嵌容器，并发布embeddedservletcontainerinitializedevent事件，启动这一部分算是容器的逻辑了，有机会整理容器逻辑再细写，我这里是tomcat的：

@override
 public void start() throws embeddedservletcontainerexception {
  try {
   addpreviouslyremovedconnectors();
   connector connector = this.tomcat.getconnector();
   if (connector != null && this.autostart) {
    startconnector(connector);
   }
   checkthatconnectorshavestarted();
   tomcatembeddedservletcontainer.logger
     .info("tomcat started on port(s): " + getportsdescription(true));
  }
  catch (connectorstartfailedexception ex) {
   stopsilently();
   throw ex;
  }
  catch (exception ex) {
   throw new embeddedservletcontainerexception(
     "unable to start embedded tomcat servlet container", ex);
  }
  finally {
   context context = findcontext();
   contextbindings.unbindclassloader(context, getnamingtoken(context),
     getclass().getclassloader());
  }
 }

　　然后是resetcommoncaches：

 /**
  * reset spring's common core caches, in particular the {@link reflectionutils},
  * {@link resolvabletype} and {@link cachedintrospectionresults} caches.
  * @since 4.2
  * @see reflectionutils#clearcache()
  * @see resolvabletype#clearcache()
  * @see cachedintrospectionresults#clearclassloader(classloader)
  */
 protected void resetcommoncaches() {
  reflectionutils.clearcache();
  resolvabletype.clearcache();
  cachedintrospectionresults.clearclassloader(getclassloader());
 }

　　refreshcontext的最后是注册shutdown的钩子：

 if (this.registershutdownhook) {
   try {
    context.registershutdownhook();
   }
   catch (accesscontrolexception ex) {
    // not allowed in some environments.
   }
  }

 /**
  * register a shutdown hook with the jvm runtime, closing this context
  * on jvm shutdown unless it has already been closed at that time.
  * <p>delegates to {@code doclose()} for the actual closing procedure.
  * @see runtime#addshutdownhook
  * @see #close()
  * @see #doclose()
  */
 @override
 public void registershutdownhook() {
  if (this.shutdownhook == null) {
   // no shutdown hook registered yet.
   this.shutdownhook = new thread() {
    @override
    public void run() {
     synchronized (startupshutdownmonitor) {
      doclose();
     }
    }
   };
   runtime.getruntime().addshutdownhook(this.shutdownhook);
  }
 }

咱最近用的github：

以上所述是小编给大家介绍的spring boot启动过程完全解析（二），希望对大家有所帮助