【Spring学习】Spring IOC

关键类和接口列表

XmlBeanFactory  // XML文件解析Bean工厂

    XmlBeanDefinitionReader  

        BeanDefinitionReader 

    DefaultBeanDefinitionDocumentReader  //交付给文档解析

 

BeanDefinitionParserDelegate  //解析出BeanDefintion封装到 BeanDefinitionHolder

BeanDefinitionRegistry

BeanDefinitionReaderUtils  //工具类 最后注册BeanDefintion

 

DefaultListableBeanFactory

AbstractAutowireCapableBeanFactory

ConfigurableListableBeanFactory

BeanDefinitionRegistry

AbstractBeanFactory  //Bean创建入口 getBean

ConfigurableBeanFactory

BeanFactory

 

如何运转

//文件解析入口 委托给XmlBeanDefinitionReader 加载

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {

   super(parentBeanFactory);

   this.reader.loadBeanDefinitions(resource);  

}

 

//装饰模式

//xml文件流被封装成Resource并非装饰城EncodeResource被加载

@Override

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

   return loadBeanDefinitions(new EncodedResource(resource));

}

//装载成Doc文档 

try {

   Document doc = doLoadDocument(inputSource, resource);

   return registerBeanDefinitions(doc, resource);

}

//委托给docRealder去注册

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

   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

   int countBefore = getRegistry().getBeanDefinitionCount();

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

   return getRegistry().getBeanDefinitionCount() - countBefore;

}

 

public XmlReaderContext createReaderContext(Resource resource) {

   return new XmlReaderContext(resource, this.problemReporter, this.eventListener,

         this.sourceExtractor, this, getNamespaceHandlerResolver());

}

public class XmlReaderContext extends ReaderContext {



   private final XmlBeanDefinitionReader reader;



   private final NamespaceHandlerResolver namespaceHandlerResolver;

@Override

public final BeanDefinitionRegistry getRegistry() {

   return this.registry;

}

@Override

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

   this.readerContext = readerContext;

   logger.debug("Loading bean definitions");

   Element root = doc.getDocumentElement();

   doRegisterBeanDefinitions(root);

}

//Bean标签默认走第一个分钟

if (delegate.isDefaultNamespace(ele)) {

   parseDefaultElement(ele, delegate);

}

else {

   delegate.parseCustomElement(ele);

} 

 

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);

   }

}

//解析成BeanDefinition

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));

   }

}

 

//在BeanDefinitionParserDelegate的多次重载方法后 BeanDefinition被创建并封装到BeanDefiniton中

BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, org.springframework.beans.factory.config.BeanDefinition)

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

 

 

 

获取bean

 

AbstractBeanFactory

@Override

public Object getBean(String name) throws BeansException {

   return doGetBean(name, null, null, false);

}



@Override

public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {

   return doGetBean(name, requiredType, null, false);

}



@Override

public Object getBean(String name, Object... args) throws BeansException {

   return doGetBean(name, null, args, false);

}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,

      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {



   final String beanName = transformedBeanName(name);

   Object bean;



   // Eagerly check singleton cache for manually registered singletons.

   Object sharedInstance = getSingleton(beanName);

   if (sharedInstance != null && args == null) {

      if (logger.isDebugEnabled()) {

         if (isSingletonCurrentlyInCreation(beanName)) {

            logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +

                  "' that is not fully initialized yet - a consequence of a circular reference");

         }

         else {

            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

         }

      }

      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

   }

 

//这里有三级缓存 解决循环引用问题

@Nullable

protected Object getSingleton(String beanName, boolean allowEarlyReference) {

   Object singletonObject = this.singletonObjects.get(beanName);

   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

      synchronized (this.singletonObjects) {

         singletonObject = this.earlySingletonObjects.get(beanName);

         if (singletonObject == null && allowEarlyReference) {

            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);

            if (singletonFactory != null) {

               singletonObject = singletonFactory.getObject();

               this.earlySingletonObjects.put(beanName, singletonObject);

               this.singletonFactories.remove(beanName);

            }

         }

      }

   }

   return singletonObject;

}

 

//获取合并后的BeanDefiniton 因为此处可能有父类

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

 

// 创建Bean的真正方法 createBean

// Create bean instance.

if (mbd.isSingleton()) {

   sharedInstance = getSingleton(beanName, () -> {

      try {

         return createBean(beanName, mbd, args);

      }

      catch (BeansException ex) {

         // Explicitly remove instance from singleton cache: It might have been put there

         // eagerly by the creation process, to allow for circular reference resolution.

         // Also remove any beans that received a temporary reference to the bean.

         destroySingleton(beanName);

         throw ex;

      }

   });

   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

}

 

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {

   Assert.notNull(beanName, "Bean name must not be null");

   synchronized (this.singletonObjects) {

      Object singletonObject = this.singletonObjects.get(beanName);

      if (singletonObject == null) {

         if (this.singletonsCurrentlyInDestruction) {

            throw new BeanCreationNotAllowedException(beanName,

                  "Singleton bean creation not allowed while singletons of this factory are in destruction " +

                  "(Do not request a bean from a BeanFactory in a destroy method implementation!)");

         }

         if (logger.isDebugEnabled()) {

            logger.debug("Creating shared instance of singleton bean '" + beanName + "'");

         }

         beforeSingletonCreation(beanName);



finally {

   if (recordSuppressedExceptions) {

      this.suppressedExceptions = null;

   }

   afterSingletonCreation(beanName);

}

if (newSingleton) {

   addSingleton(beanName, singletonObject);

}

//如果是新创建的bean 需要从二三级缓存删除移动到1级缓存

protected void addSingleton(String beanName, Object singletonObject) {

   synchronized (this.singletonObjects) {

      this.singletonObjects.put(beanName, singletonObject);

      this.singletonFactories.remove(beanName);

      this.earlySingletonObjects.remove(beanName);

      this.registeredSingletons.add(beanName);

   }

}

 

解决循环引用

图例：