Spring-IoC容器工作原理

本是古典何须时尚 2023-06-25 10:11 3阅读 0赞

# IoC容器工作原理 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMjM5OTEz_size_16_color_FFFFFF_t_70]

## 1. 创建beanFactory ##

容器底层用DefaultListableBeanFactory,即实现了BeanDe ﬁnitionRegistry,又实现了BeanFactory  
**java配置 :**

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

this() 方 法 ----> 调父类无参构造器

public GenericApplicationContext(){
         
      this.beanFactory = new DefaultListableBeanFactory(); 
    }

在 容 器 启 动 之 前 就 创 建 beanFactory  
**xml 配 置 ：**

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");

调 refresh() 后 ，即容器启动过程中创建 beanFactory

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 
    > refreshBeanFactory(); // AbstractApplicationContext#refreshBeanFactory

先创建DefaultListableBeanFactory实例,然后解析xml配置文件,注册bean到beanFactory ，最后再将beanFactory赋值给容器

DefaultListableBeanFactory beanFactory = createBeanFactory(); 
    beanFactory.setSerializationId(getId()); 
    // 定制beanFactory,设置参数 
    customizeBeanFactory(beanFactory); 
    // 注册spring的xml配置的bean到beanFactory,此时容器还未指定beanbeanFactory
    loadBeanDefinitions(beanFactory); 
    // 给容器指定beanFactory 
    synchronized(this.beanFactoryMonitor){
         
      this.beanFactory = beanFactory; 
    }

## 2. 注册bean ##

**核心原理 :**  
通过调用registerBeanDeﬁnition方法将bean的beanName----beanDe ﬁnition注册到beanFactory

DefaultListableBeanFactory#registerBeanDefinition   //实现了BeanDefinitionRegistry 
    > beanDefinitionMap.put(beanName,beanDefinition); //缓存beanDefinition

**代码示例 ：**

// 拿到工厂 实现了BeanDefinitionRegistry 
    DefaultListableBeanFactorybeanFactory = context.getDefaultListableBeanFactory(); 
    // 创建一个beanDefinition 
    RootBeanDefinitionbeanDefinition = newRootBeanDefinition(User.class); 
    // 注册 
    beanFactory.registerBeanDefinition("user",beanDefinition);

**java配置 :**  
容器启动过程中,会调用ConﬁgurationClassPostProcessor\#postProcessBeanDeﬁnitionRegistry解析注解,注册bean

invokeBeanFactoryPostProcessors(beanFactory); // 解析注解,注册bean 
    > ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry

ConﬁgurationClassPostProcessor\#postProcessBeanDeﬁnitionRegistry中有两个很重要的方法

// 解析配置类@ComponentScan(bean注册到容器)@Import @ImportResource @Bean 
    parser.parse(candidates); 
    // 注册bean到容器 
    // 注册实现了ImportSelector的bean 
    // 方法bean注册到容器 
    // @ImportResource("spring.xml")配置的bean注册到容器 
    // 实现ImportBeanDefinitionRegistrar的bean注册到容器 
    this.reader.loadBeanDefinitions(configClasses);

**解析注解**

parser.parse(candidates); 
    > ConfigurationClassParser#processConfigurationClass 
    > ConfigurationClassParser#doProcessConfigurationClass

ConﬁgurationClassParser\#doProcessConﬁgurationClass会处理@ComponentScan,@Import,@ImportResource,@Bean  
@ComponentScan会将@Component修饰的bean注入到容器

ClassPathBeanDefinitionScanner#doScan 
    > 
    // 找到@Component修饰的类的beanDefiniton集合 
    Set<BeanDefinition> candidates = findCandidateComponents(basePackage); 
    // 注册bean 
    registerBeanDefinition(definitionHolder,this.registry);

**注册bean**

this.reader.loadBeanDefinitions(configClasses)
    > ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass 
    if(configClass.isImported()){
         
      // implementsImportSelector的bean注册 
      registerBeanDefinitionForImportedConfigurationClass(configClass); 
    } 
    for(BeanMethodbeanMethod : configClass.getBeanMethods()){
         
      // 方法bean注册到容器 
      loadBeanDefinitionsForBeanMethod(beanMethod); 
    } 
    // @ImportResource("spring.xml")配置的bean注册到容器loadBeanDefinitionsFromImportedResources(configClass.getImportedResources()); 
    //实现ImportBeanDefinitionRegistrar的bean注册到容器 
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

**xml配置:**

ConfigurableListableBeanFactorybeanFactory = obtainFreshBeanFactory(); 
    > refreshBeanFactory(); // AbstractApplicationContext#refreshBeanFactory

将beanFactory赋值给容器之前解析xml,并且注册bean

DefaultListableBeanFactorybeanFactory = createBeanFactory(); 
    beanFactory.setSerializationId(getId()); 
    // 定制beanFactory,设置参数 
    customizeBeanFactory(beanFactory); 
    // 注册spring的xml配置的bean到beanFactory,此时容器还未指定beanbeanFactoryloadBeanDefinitions(beanFactory); 
    // 给容器指定beanFactory 
    synchronized(this.beanFactoryMonitor){
         
      this.beanFactory = beanFactory ; 
    }

**解析xml**  
loadBeanDeﬁnitions(beanFactory)最终会调DefaultBeanDeﬁnitionDocumentReader\#doRegisterBeanDeﬁnitions

// 注册spring的xml配置的bean到beanFactory,此时容器还未指定beanbeanFactory
    loadBeanDefinitions(beanFactory); 
    > DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions 
    preProcessXml(root); 
    parseBeanDefinitions(root,this.delegate); // 解析xml 
    postProcessXml(root); 
    > DefaultBeanDefinitionDocumentReader#parseDefaultElement 
    else if(delegate.nodeNameEquals(ele,BEAN_ELEMENT)){
         
    // 解析bean 
    processBeanDefinition(ele,delegate); 
    } 
    > DefaultBeanDefinitionDocumentReader#processBeanDefinition 
    // 注册最后修饰后的实例beanDefinition 
    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
    getReaderContext().getRegistry());

**注册bean**  
BeanDeﬁnitionReaderUtils\#registerBeanDeﬁnition中会注册bean

// 注册beanDefiniton 
    registry.registerBeanDefinition(beanName,definitionHolder.getBeanDefinition());

## 3. 创建bean实例 ##

容器启动过程中会实例化非懒加载单例bean,通过AbstractBeanFactory创建bean的实例

AbstractApplicationContext#refresh 
    // Instantiateallremaining(non-lazy-init)singletons. 
    // 实例化所有剩余的(非懒加载)单例 。 
    > finishBeanFactoryInitialization(beanFactory); 
    > AbstractApplicationContext#getBean(String)

调用context.getBean(name)获取bean实例,实际会去调用AbstractBeanFactory的getBean()方法 。

AbstractApplicationContext #getBean(String)
    > AbstractBeanFactory #getBean(String)

调用AbstractBeanFactory\#doGetBean,先从singletonObjects中去获取bean

// 转换对应的beanName 
    // 1. 带 & 前缀的去掉前缀 
    // 2. 从aliasMap中找name对应id,bean没有配id就用name 
    finalStringbeanName = transformedBeanName(name);
    // 先从缓存singletonObjects中找,没有则去创建 
    // 处理循环依赖的问题,比如A ->B,B->A 
    ObjectsharedInstance = getSingleton(beanName); 
    // 判断单例 
    if(mbd.isSingleton()){
         
    	sharedInstance = getSingleton(beanName,()-> {
         
    		return createBean(beanName,mbd,args); 
      });   
      bean = getObjectForBeanInstance(sharedInstance,name,beanName,mbd); }

调用AbstractAutowireCapableBeanFactory\#doCreateBean返回bean

AbstractAutowireCapableBeanFactory#createBean(String,RootBeanDefinition,Object[])
    // 返回bean实例 
    > Object beanInstance = doCreateBean(beanName,mbdToUse,args);

**实例化bean**  
调用AbstractAutowireCapableBeanFactory\#doCreateBean

/** 
    * 第2次调用后置处理器 
    * 创建bean实例,并将实例放在包装类BeanWrapper中返回 
    * 1. 通过工厂方法创建bean实例 
    * 2. 通过构造方法自动注入创建bean实例 
    * 3. 通过无参构造器创建bean实例 
    */ 
    instanceWrapper = createBeanInstance(beanName,mbd,args); 
    finalObjectbean = instanceWrapper.getWrappedInstance();

**填充bean**

// 填充bean设置属性 
    InstantiationAwareBeanPostProcessors 
    // 第5次,第6次调用后置处理器   注入依赖 
    populateBean(beanName,mbd,instanceWrapper);

**初始化bean**

// 初始化bean 
    exposedObject = initializeBean(beanName,exposedObject,mbd);

**返回bean**

// 返回类型判断FactoryBeanBeanFactroy 
    bean = getObjectForBeanInstance(sharedInstance,name,beanName,mbd);> 
    //涉及FactoryBean的判断,直接返回普通bean的条件类型是否是FactoryBean || name首字符是否是 & 
    if(!(beanInstanceinstanceofFactoryBean)|| BeanFactoryUtils.isFactoryDereference(name){
         
    	return beanInstance ; 
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMjM5OTEz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191227232222342.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMjM5OTEz,size_16,color_FFFFFF,t_70