spirng源码阅读日记2--spring ioc

以ClassPathXmlApplicationContext的构造函数为入口点。(ClassPathXmlApplicationContext继承图见上一日记)

public ClassPathXmlApplicationContext(

      String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)

      throws BeansException {

   super(parent);

   setConfigLocations(configLocations);

   if (refresh) {

      refresh();

   }

}

重点就在于refresh()方法，该接口是ConfigurableApplicationContext中定义的，AbstractApplicationContext实现了该方法，如下：

public void refresh() throws BeansException, IllegalStateException {

   synchronized ( this. startupShutdownMonitor) {

      // Prepare this context for refreshing.

      //初始化一些参数，校验一些必须的属性是否配置

      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.

      //创建一个新的beanFactory,重新加载bean的定义

      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.

      prepareBeanFactory(beanFactory);

      try {

         // Allows post-processing of the bean factory in context subclasses.

         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.

         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.

         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.

         initMessageSource();

         // Initialize event multicaster for this context.

         //初始化事件广播器

         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.

         onRefresh();

         // Check for listener beans and register them.

         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.

         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.

         finishRefresh();

      }

这只是一个模版方法，定义基本的操作骨架，涉及的一些抽象方法必须在延迟到子类中实现。

Refresh()方法的功能主要是重新生成一个beanFactory(DefaultListableBeanFactory类型)，然后执行加载bean定义，生成对应的BeanDefinition对象保存在beanFactory中的map属性中。这一功能的主要实现主要通过 obtainFreshBeanFactory() 方法，继续跟进：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

   refreshBeanFactory();

   ConfigurableListableBeanFactory beanFactory = getBeanFactory();

   if ( logger.isDebugEnabled()) {

      logger.debug( "Bean factory for " + getDisplayName() + ": " + beanFactory);

   }

   return beanFactory;

}

refreshBeanFactory方法是一个抽象方法，具体的代码逻辑我们可以根据之前的关于applicationContext的继承线中查找离ClassPathXmlApplicationContext最近的实现了该方法的类(这里是AbstractRefreshableApplicationContext)，具体实现代码如下：

@Override

protected final void refreshBeanFactory() throws BeansException {

   if (hasBeanFactory()) {

      //一个模版方法，默认是销毁所有在beanFactory中的缓存的单例对象(CurrentHashMap保存kv)

      destroyBeans();

      //将beanFactory变量指向null

      closeBeanFactory();

   }

   try {

      DefaultListableBeanFactory beanFactory = createBeanFactory();

      beanFactory.setSerializationId(getId());

      //默认实现为设置beanFactory的setAllowBeanDefinitionOverriding和setAllowCircularReferences

      customizeBeanFactory(beanFactory);

      //根据beanFactory得到资源,读取资源并解析,封装为BeanDefinition对象,通过beanFactory注册该bean定义对象到map容器中

      loadBeanDefinitions(beanFactory);

      synchronized ( this. beanFactoryMonitor) {

         this. beanFactory = beanFactory;

      }

   }

   catch (IOException ex) {

      throw new ApplicationContextException( "I/O error parsing bean definition source for " + getDisplayName(), ex);

   }

}

这个方法中的一些操作的具体作用都在注释中标明了，最关键的代码就是loadBeanDefinitions()方法，该方法会加载配置文件中的bean定义，详细代码如下：

@Override

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

   // Create a new XmlBeanDefinitionReader for the given BeanFactory.

   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

   // Configure the bean definition reader with this context's

   // resource loading environment.

   beanDefinitionReader.setEnvironment( this.getEnvironment());

   beanDefinitionReader.setResourceLoader( this);

   beanDefinitionReader.setEntityResolver( new ResourceEntityResolver( this));

   // Allow a subclass to provide custom initialization of the reader,

   // then proceed with actually loading the bean definitions.

   initBeanDefinitionReader(beanDefinitionReader);

   loadBeanDefinitions(beanDefinitionReader);

}

其中的XmlBeanDefinitionReader是xml文件格式配置的bean定义读取类，真正的bean定义的加载逻辑就是委托它来实现的。在这里我们将beanFactory作为构造参数传递给XmlBeanDefinitionReader，XmlBeanDefinitionReader内部会将该beanFactory作为一个bean定义的注册器BeanDefinitionRegistry。继续跟loadBeanDefinitions（），代码如下：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

   Resource[] configResources = getConfigResources();

   if (configResources != null) {

      reader.loadBeanDefinitions(configResources);

   }

   String[] configLocations = getConfigLocations();

   if (configLocations != null) {

      reader.loadBeanDefinitions(configLocations);

   }

}

主要判断下当前上下文中是否有资源，如果有就直接加载，没有的话，会根据location通过 ResourceLoader获取资源，然后再执行这个方法。

@Override

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

   //EncodedResource(resource):包装resource，获取字符输入流的时候根据编码和字符集将原始字节流转换。

   return loadBeanDefinitions( new EncodedResource(resource));

}

我们直接跳过一些代码，一直跟进和bean定义加载有关的方法，最后会到这么一个方法中：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

      throws BeanDefinitionStoreException {

   try {

      //使用jdk1.8 rt.jar中的使用sax解析xml文件的方式，得到Document对象

      Document doc = doLoadDocument(inputSource, resource);

      return registerBeanDefinitions(doc, resource);

   }

   catch (BeanDefinitionStoreException ex) {

      throw ex;

   }

   //后续都是一些catch操作，直接省略

   ……………..

}

根据输入源inputSource获取对应的输入流，再解析为代表整个xml配置文件的document对象，最后执行beanDefinitions的注册操作。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

   //创建一个DefaultBeanDefinitionDocumentReader类型的实例

   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

   int countBefore = getRegistry().getBeanDefinitionCount();

   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

   return getRegistry().getBeanDefinitionCount() - countBefore;

}

BeanDefinitionDocumentReader为用于读取解析包含spring bean定义的document的spi。这里的实际类型为DefaultBeanDefinitionDocumentReader。

createReaderContext(resource)方法会生成一个xml读取上下文对象，并且会将this指向XmlBeanDefinitionReader对象赋给上下文内部的reader属性。

@Override

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

   //readerContext中的XmlBeanDefinitionReader类型的reader属性中的registry为传递进去的beanFactory

   // (该beanFactory实现了beanDefineRegister接口)

   this. readerContext = readerContext;

   logger.debug( "Loading bean definitions");

   Element root = doc.getDocumentElement();

   doRegisterBeanDefinitions(root);

}

注意，这里该方法将readerContext对象赋给了同名的内部属性，后面注册beanDefinitions时，使用的就是readerContext中的XmlBeanDefinitionReader对象的registry(其实就是DefaultListableBeanFactory类型的对象)属性，调用相关注册接口完成注册操作。

继续跳过一些非功能性代码，继续跟进：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

   //1.该标签为空，2.该标签的 xmlns = http://www.springframework.org/schema/beans,说明为 <beans>根标签

   if (delegate.isDefaultNamespace(root)) {

      NodeList nl = root.getChildNodes();

      for ( int i = 0; i < nl.getLength(); i++) {

         Node node = nl.item(i);

         if (node instanceof Element) {

            Element ele = (Element) node;

            if (delegate.isDefaultNamespace(ele)) {

               //解析spring中的默认标签

               parseDefaultElement(ele, delegate);

            }

            else {

               delegate.parseCustomElement(ele);

            }

         }

      }

   }

   else {

      delegate.parseCustomElement(root);

   }

}

这里会获取root节点(<beans>)下的所有子节点，下面我跟进parseDefaultElement方法

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {

   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {

      importBeanDefinitionResource(ele);

   }

   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {

      processAliasRegistration(ele);

   }

   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {

      processBeanDefinition(ele, delegate);

   }

   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {

      // recurse

      doRegisterBeanDefinitions(ele);

   }

}

这里它会判断当前节点名为import,alias,bean,还是beans，来进行进一步的操作，这里我们以bean为例子。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

   if (bdHolder != null) {

      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

      try {

         // Register the final decorated instance.

         BeanDefinitionReaderUtils. registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

      }

      catch (BeanDefinitionStoreException ex) {

         getReaderContext().error( "Failed to register bean definition with name '" +

               bdHolder.getBeanName() + "'", ele, ex);

      }

      // Send registration event.

      getReaderContext().fireComponentRegistered( new BeanComponentDefinition(bdHolder));

   }

}

这里第一步生成了BeanDefinitionHolder对象，该对象其实就是BeanDefinition持有对象，内部还有beanName,aliases属性，跟进

delegate.parseBeanDefinitionElement(ele)方法，这次跳过中间的一些方法，直接到最终解析element节点封装为BeanDefinition对象的方法

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,

      @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

   if (ele.hasAttribute( SINGLETON_ATTRIBUTE)) {

      error( "Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);

   }

   else if (ele.hasAttribute( SCOPE_ATTRIBUTE)) {

      bd.setScope(ele.getAttribute( SCOPE_ATTRIBUTE));

   }

   else if (containingBean != null) {

      // Take default from containing bean in case of an inner bean definition.

      bd.setScope(containingBean.getScope());

   }

   if (ele.hasAttribute( ABSTRACT_ATTRIBUTE)) {

      bd.setAbstract( TRUE_VALUE.equals(ele.getAttribute( ABSTRACT_ATTRIBUTE)));

   }

   String lazyInit = ele.getAttribute( LAZY_INIT_ATTRIBUTE);

   if ( DEFAULT_VALUE.equals(lazyInit)) {

      lazyInit = this. defaults.getLazyInit();

   }

   bd.setLazyInit( TRUE_VALUE.equals(lazyInit));

   String autowire = ele.getAttribute( AUTOWIRE_ATTRIBUTE);

   bd.setAutowireMode(getAutowireMode(autowire));

   if (ele.hasAttribute( DEPENDS_ON_ATTRIBUTE)) {

      String dependsOn = ele.getAttribute( DEPENDS_ON_ATTRIBUTE);

      bd.setDependsOn(StringUtils. tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));

   }

   String autowireCandidate = ele.getAttribute( AUTOWIRE_CANDIDATE_ATTRIBUTE);

   if ( "".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {

      String candidatePattern = this. defaults.getAutowireCandidates();

      if (candidatePattern != null) {

         String[] patterns = StringUtils. commaDelimitedListToStringArray(candidatePattern);

         bd.setAutowireCandidate(PatternMatchUtils. simpleMatch(patterns, beanName));

      }

   }

   else {

      bd.setAutowireCandidate( TRUE_VALUE.equals(autowireCandidate));

   }

   if (ele.hasAttribute( PRIMARY_ATTRIBUTE)) {

      bd.setPrimary( TRUE_VALUE.equals(ele.getAttribute( PRIMARY_ATTRIBUTE)));

   }

   if (ele.hasAttribute( INIT_METHOD_ATTRIBUTE)) {

      String initMethodName = ele.getAttribute( INIT_METHOD_ATTRIBUTE);

      bd.setInitMethodName(initMethodName);

   }

   else if ( this. defaults.getInitMethod() != null) {

      bd.setInitMethodName( this. defaults.getInitMethod());

      bd.setEnforceInitMethod( false);

   }

   if (ele.hasAttribute( DESTROY_METHOD_ATTRIBUTE)) {

      String destroyMethodName = ele.getAttribute( DESTROY_METHOD_ATTRIBUTE);

      bd.setDestroyMethodName(destroyMethodName);

   }

   else if ( this. defaults.getDestroyMethod() != null) {

      bd.setDestroyMethodName( this. defaults.getDestroyMethod());

      bd.setEnforceDestroyMethod( false);

   }

   if (ele.hasAttribute( FACTORY_METHOD_ATTRIBUTE)) {

      bd.setFactoryMethodName(ele.getAttribute( FACTORY_METHOD_ATTRIBUTE));

   }

   if (ele.hasAttribute( FACTORY_BEAN_ATTRIBUTE)) {

      bd.setFactoryBeanName(ele.getAttribute( FACTORY_BEAN_ATTRIBUTE));

   }

   return bd;

经过上面的解析，成功构造出一个BeanDefinitionHolder对象，该对象中的属性详细记录了bean创建时的一些细节，比如是否支持懒加载，是否为单例，初始化方法和销毁方法等等...

bean定义解析完成后，就是注册方法

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

   if (bdHolder != null) {

      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

      try {

         // Register the final decorated instance.

         BeanDefinitionReaderUtils. registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

      }

      catch (BeanDefinitionStoreException ex) {

         getReaderContext().error( "Failed to register bean definition with name '" +

               bdHolder.getBeanName() + "'", ele, ex);

      }

      // Send registration event.

      getReaderContext().fireComponentRegistered( new BeanComponentDefinition(bdHolder));

   }

}

继续跟进注册方法：

public static void registerBeanDefinition(

      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)

      throws BeanDefinitionStoreException {

   // Register bean definition under primary name.

   String beanName = definitionHolder.getBeanName();

   //注册bean定义,这里的registry对象的实际类型为实现了BeanDefinitionRegistry接口的DefaultListableBeanFactory对象

   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // Register aliases for bean name, if any.

   String[] aliases = definitionHolder.getAliases();

   if (aliases != null) {

      for (String alias : aliases) {

         registry.registerAlias(beanName, alias);

      }

   }

}

这里首先取出beanName, 然后获得registry对象(也就是DefaultListableBeanFactory对象)，有了beanName, beanDefinition，beanFactory就可以将该xml配置文件中<bean>标签定义的beanName和创建细节维护到一个DefaultListableBeanFactory内部的一个beanDefinitionMap对象中。

到现在为止，bean定义的加载逻辑就全部理完了。

加载bean定义完成后，spring就会执行非懒加载的单例对象的初始化。这点主要在finishBeanFactoryInitialization(beanFactory)方法中实现。

首先spring会获取beanFactory中的beanDefinitionMap, 然后遍历判断是否为非抽象非懒加载单例模式，然后执行创建逻辑。如果该单例对象不是一个factoryBean，那么会直接调用getBean(beanName)方法，判断beanFactory中的单例缓存池(DefaultSingletonBeanRegistry中的 singletonObjects)中是否含有该对象，有，返回该对象，没有，根据beanDefinition执行创建逻辑，并将创建后的对象添加进singletonObjects中 ， 然后返回。