IoC源码简单DEBUG流程

创建测试用例

MyBean类

public class ScBean implements InitializingBean, ApplicationContextAware {
    private ItBean itBean
    public void setItBean(ItBean itBean) {
        this.itBean = itBean;
    }
    /**
     * 构造函数
     */
    public ScBean(){
        System.out.println("ScBean 构造器...");
    }
    /**
     * InitializingBean 接口实现
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("ScBean afterPropertiesSet...");
    }
    public void print() {
        System.out.println("print方法业务逻辑执行");
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("setApplicationContext....");
    }
}

BeanPostProcessor 接⼝实现类

public class MyBeanPostProcessor implements BeanPostProcessor {
    public MyBeanPostProcessor() {
        System.out.println("BeanPostProcessor 实现类构造函数...");
    }
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if("scBean".equals(beanName)) {
            System.out.println("BeanPostProcessor 实现类 postProcessBeforeInitialization 方法被调用中......");
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if("System".equals(beanName)) {
            System.out.println("BeanPostProcessor 实现类 postProcessAfterInitialization 方法被调用中......");
        }
        return bean;
    }
}

BeanFactoryPostProcessor 接⼝实现类

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public MyBeanFactoryPostProcessor() {
        System.out.println("BeanFactoryPostProcessor的实现类构造函数...");
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor的实现方法调用中......");
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
  http://www.springframework.org/schema/beans
  https://www.springframework.org/schema/beans/spring-beans.xsd
">
  <bean id="lagouBean" class="com.lagou.LagouBean"/>
  <bean id="myBeanFactoryPostProcessor"
  class="com.lagou.MyBeanFactoryPostProcessor"/>
  <bean id="myBeanPostProcessor" class="com.lagou.MyBeanPostProcessor"/>
</beans>

测试类

public class IocTest {
    @Test
    public void testIoC() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        ScBean scBean = applicationContext.getBean(ScBean.class);
        System.out.println(scBean);
    }
}

注：

• BeanPostProcessor
  BeanPostProcessor也称为Bean后置处理器，它是Spring中定义的接口，在Spring容器的创建过程中（具体为Bean初始化前后）会回调BeanPostProcessor中定义的两个方法。
  BeanPostProcessor是针对Bean级别的处理，可以针对某个具体的Bean。

• BeanFactoryPostProcessor
  BeanFactoryPostProcessor接口与 BeanPostProcessor接口类似,可以对bean的定义(配置元数据)进行处理
  BeanFactoryPostProcessor是针对BeanFactory级别的处理，是针对整个Bean的⼯⼚进⾏处理。

断点执行分析

1、分析 Bean 的创建是在容器初始化时还是在 getBean 时

根据断点调试，我们发现，在未设置延迟加载的前提****下，Bean 的创建是在容器初始化过程中完成的。

2、分析构造函数调⽤情况

注意：观察调用栈

通过如上观察，我们发现构造函数的调⽤时机在AbstractApplicationContext类 refresh ⽅法的 finishBeanFactoryInitialization(beanFactory) 处;

3、分析 InitializingBean 之 afterPropertiesSet 初始化⽅法调⽤情况

注意：观察调用栈

通过如上观察，我们发现 InitializingBean中afterPropertiesSet ⽅法的调⽤时机也是在 AbstractApplicationContext 类 refresh ⽅法的 finishBeanFactoryInitialization(beanFactory)；

4、分析BeanFactoryPostProcessor 初始化和调⽤情况

分别在构造函数、postProcessBeanFactory ⽅法处打断点，观察调⽤栈，发现：

• BeanFactoryPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的 invokeBeanFactoryPostProcessors(beanFactory);
• postProcessBeanFactory 调⽤在AbstractApplicationContext类refresh⽅法的 invokeBeanFactoryPostProcessors(beanFactory);

5、分析 BeanPostProcessor 初始化和调⽤情况

分别在构造函数、postProcessBeanFactory ⽅法处打断点，观察调⽤栈，发现：

• BeanPostProcessor 初始化在AbstractApplicationContext类refresh⽅法的 registerBeanPostProcessors(beanFactory);
• postProcessBeforeInitialization 调⽤在AbstractApplicationContext类refresh⽅法的 finishBeanFactoryInitialization(beanFactory);
• postProcessAfterInitialization 调⽤在AbstractApplicationContext类refresh⽅法的 finishBeanFactoryInitialization(beanFactory);

6、总结

根据上⾯的调试分析，我们发现 Bean对象创建的⼏个关键时机点代码层级的调⽤都在 AbstractApplicationContext 类 的 refresh ⽅法中，可⻅这个⽅法对于Spring IoC 容器初始化来说相当关键，汇总如下：

关键点	触发代码
构造器	refresh#finishBeanFactoryInitialization(beanFactory)(beanFactory)
BeanFactoryPostProcessor 初始化	refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanFactoryPostProcessor ⽅法调⽤	refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanPostProcessor 初始化	registerBeanPostProcessors(beanFactory)
BeanPostProcessor ⽅法调⽤	refresh#finishBeanFactoryInitialization(beanFactory)

Spring IoC容器初始化主流程

由上分析可知，Spring IoC 容器初始化的关键环节就在 AbstractApplicationContext#refresh() ⽅法中，我们查看 refresh ⽅法来俯瞰容器创建的主体流程，主体流程下的具体⼦流程我们后⾯再来讨论

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 第⼀步：刷新前的预处理
        prepareRefresh();
        
        /*
            第⼆步：
            获取BeanFactory；默认实现是DefaultListableBeanFactory
            加载BeanDefition 并注册到 BeanDefitionRegistry
        */
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        
        // 第三步：BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，⽐如context的类加载器等）
        prepareBeanFactory(beanFactory);
        
        try {
            // 第四步：BeanFactory准备⼯作完成后进⾏的后置处理⼯作
            postProcessBeanFactory(beanFactory);
            
            // 第五步：实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
            invokeBeanFactoryPostProcessors(beanFactory);
            
            // 第六步：注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执⾏
            registerBeanPostProcessors(beanFactory);
            
            // 第七步：初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
            initMessageSource();
            
            // 第⼋步：初始化事件派发器
            initApplicationEventMulticaster();
            
            // 第九步：⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
            onRefresh();
            
            // 第⼗步：注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器bean
            registerListeners();
            
            /*
                第⼗⼀步：
                初始化所有剩下的⾮懒加载的单例bean
                初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）
                填充属性
                初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、init-method⽅法）
                调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处
            */
            finishBeanFactoryInitialization(beanFactory);
            
            /*
                第⼗⼆步：
                完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事
                件 （ContextRefreshedEvent）
            */
            finishRefresh();
        }
        ...
    }
}

IoC高级特性流程

BeanFactory创建流程

1、获取BeanFactory⼦流程

2、BeanDefinition加载解析及注册⼦流程

2.1、该⼦流程涉及到如下⼏个关键步骤

• Resource定位：指对BeanDefinition的资源定位过程。通俗讲就是找到定义Javabean信息的XML⽂件，并将其封装成Resource对象。
• BeanDefinition载⼊ ：把⽤户定义好的Javabean表示为IoC容器内部的数据结构，这个容器内部的数据结构就是BeanDefinition。
• 注册BeanDefinition到 IoC 容器

2.2、过程分析

Step 1：⼦流程⼊⼝在 AbstractRefreshableApplicationContext#refreshBeanFactory ⽅法中

**

Step 2：依次调⽤多个类的 loadBeanDefinitions ⽅法 —> AbstractXmlApplicationContext —> AbstractBeanDefinitionReader —> XmlBeanDefinitionReader ⼀直执⾏到 XmlBeanDefinitionReader 的 doLoadBeanDefinitions ⽅法

Step 3：我们重点观察XmlBeanDefinitionReader 类的 registerBeanDefinitions ⽅法，期间产⽣了多次重载调⽤，我们定位到最后⼀个

此处我们关注两个地⽅：⼀个createRederContext⽅法，⼀个是DefaultBeanDefinitionDocumentReader类的registerBeanDefinitions⽅法，先进⼊createRederContext ⽅法看看

我们可以看到，此处 Spring ⾸先完成了 NamespaceHandlerResolver 的初始化。

我们再进⼊ registerBeanDefinitions ⽅法中追踪，调⽤了DefaultBeanDefinitionDocumentReader#registerBeanDefinitions ⽅法

进⼊ doRegisterBeanDefinitions ⽅法

进⼊ parseBeanDefinitions ⽅法

进⼊ parseDefaultElement ⽅法

进⼊ processBeanDefinition ⽅法

⾄此，注册流程结束，我们发现，所谓的注册就是把封装的 XML 中定义的 Bean信息封装为 BeanDefinition 对象之后放⼊⼀个Map中，BeanFactory 是以 Map 的结构组织这些 BeanDefinition的。

可以在DefaultListableBeanFactory中看到此Map的定义

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new
ConcurrentHashMap<>(256);

3、时序图

Bean创建流程

• 通过最开始的关键时机点分析，我们知道Bean创建⼦流程⼊⼝在AbstractApplicationContext#refresh()⽅法的finishBeanFactoryInitialization(beanFactory) 处

• 进⼊finishBeanFactoryInitialization

• 继续进⼊DefaultListableBeanFactory类的preInstantiateSingletons⽅法，我们找到下⾯部分的代码，看到⼯⼚Bean或者普通Bean，最终都是通过getBean的⽅法获取实例

• 继续跟踪下去，我们进⼊到了AbstractBeanFactory类的doGetBean⽅法，这个⽅法中的代码很多，我们直接找到核⼼部分

• 接着进⼊到AbstractAutowireCapableBeanFactory类的⽅法，找到以下代码部分

• 进⼊doCreateBean⽅法看看，该⽅法我们关注两块重点区域

  • 创建Bean实例，此时尚未设置属性

• • 给Bean填充属性，调⽤初始化⽅法，应⽤BeanPostProcessor后置处理器

lazy-init 延迟加载机制原理

普通 Bean 的初始化是在容器启动初始化阶段执⾏的，⽽被lazy-init=true修饰的 bean 则是在从容器⾥第⼀次进⾏context.getBean() 时进⾏触发。Spring 启动的时候会把所有bean信息(包括XML和注解)解析转化成Spring能够识别的BeanDefinition并存到Hashmap⾥供下⾯的初始化时⽤，然后对每个BeanDefinition 进⾏处理，如果是懒加载的则在容器初始化阶段不处理，其他的则在容器初始化阶段进⾏初始化并依赖注⼊。

public void preInstantiateSingletons() throws BeansException {
    // 所有beanDefinition集合
    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    // 触发所有⾮懒加载单例bean的初始化
    for (String beanName : beanNames) {
        // 获取bean 定义
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 判断是否是懒加载单例bean，如果是单例的并且不是懒加载的则在容器创建时初始化
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        // 判断是否是 FactoryBean
        if (isFactoryBean(beanName)) {
        final FactoryBean<?> factory = (FactoryBean<?>)
        getBean(FACTORY_BEAN_PREFIX + beanName);
        boolean isEagerInit;
        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
            isEagerInit = AccessController.doPrivileged(new
            PrivilegedAction<Boolean>() {
            @Override
            public Boolean run() {
            return ((SmartFactoryBean<?>) factory).isEagerInit();
            }
            }, getAccessControlContext());
            }
            }else {
            /*
                如果是普通bean则进⾏初始化并依赖注⼊，此 getBean(beanName)接下来触发的逻辑和
                懒加载时 context.getBean("beanName") 所触发的逻辑是⼀样的
            */
            getBean(beanName);
            }
        }
    }
}

总结：

• 对于被修饰为lazy-init的bean Spring 容器初始化阶段不会进⾏ init 并且依赖注⼊，当第⼀次进⾏getBean时候才进⾏初始化并依赖注⼊
• 对于⾮懒加载的bean，getBean的时候会从缓存⾥头获取，因为容器初始化阶段 Bean 已经初始化完成并缓存了起来

Spring IoC循环依赖

1、循环依赖场景

Spring中循环依赖场景有：

• 构造器的循环依赖（构造器注⼊）
• Field 属性的循环依赖（set注⼊）

其中，构造器的循环依赖问题⽆法解决，只能拋出 BeanCurrentlyInCreationException 异常，在解决属性循环依赖时，spring采⽤的是提前暴露对象的⽅法。

2、循环依赖处理机制

• 单例 bean 构造器参数循环依赖（⽆法解决）

• prototype 原型 bean循环依赖（⽆法解决）
  对于原型bean的初始化过程中不论是通过构造器参数循环依赖还是通过setXxx⽅法产⽣循环依赖，Spring都 会直接报错处理。

• 单例bean通过setXxx或者@Autowired进⾏循环依赖
  Spring 的循环依赖的理论依据基于 Java 的引⽤传递，当获得对象的引⽤时，对象的属性是可以延后设置的，但是构造器必须是在获取引⽤之前。
  Spring通setXxx或者@Autowired⽅法解决循环依赖其实是通过提前暴露⼀个ObjectFactory对象来完成的，简单来说ClassA在调⽤构造器完成对象初始化之后，在调⽤ClassA的setClassB⽅法之前就把ClassA实例化的对象通过ObjectFactory提前暴露到Spring容器中。

  • Spring容器初始化ClassA通过构造器初始化对象后提前暴露到Spring容器。

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   if (logger.isDebugEnabled()) {
       logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
   }
   //将初始化后的对象提前已ObjectFactory对象注⼊到容器中
   addSingletonFactory(beanName, new ObjectFactory<Object>() {
       @Override
       public Object getObject() throws BeansException {
           return getEarlyBeanReference(beanName, mbd, bean);
       }
   });
}

• ClassA调⽤setClassB⽅法，Spring⾸先尝试从容器中获取ClassB，此时ClassB不存在Spring容器中。

  • Spring容器初始化ClassB，同时也会将ClassB提前暴露到Spring容器中

  • ClassB调⽤setClassA⽅法，Spring从容器中获取ClassA ，因为第⼀步中已经提前暴露了ClassA，因此可以获取到ClassA实例。

    • ClassA通过spring容器获取到ClassB，完成了对象初始化操作。

• 这样ClassA和ClassB都完成了对象初始化操作，解决了循环依赖问题。

我只是觉得自己不仅仅如此，所以在努力呀！