本文主要记录Spring容器创建 源码分析过程。
首先贴上一张时序图，好久没画，忘的差不多了，画的不好，可以凑合看一下。
接下来，贴上一份测试代码，这里使用AnnotationConfigApplicationContext来初始化Spring容器
@Test
public void test1() {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
System.out.println("spring容器初始化结束");
Person person = (Person) ctx.getBean("person");
System.out.println(person.toString());
}
@Configuration
public class AppConfig {
@Bean(value="person")
public Person getPerson() {
Person person = new Person();
person.setName("zhangsan");
return person;
}
}
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person [name=" + name + "]";
}
}
代码看完了，直接进入正题，开始Debug。
Debug从AnnotationConfigApplicationContext的构造器方法开始，找到该构造方法。
往下继续走，进入到AbstractApplicationContext的refresh()方法，Spring容器的初始化过程就在该方法中完成的。
本文会进入每个方法，看看方法里面的代码，但可能不会很细。
1、接下来，继续Debug，进入第一个方法prepareRefresh(),该方法主要是进行刷新前的预处理操作。
2、进入第二个方法ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()，该方法主要是获取beanFactory。
进入refreshBeanFactory()，会跳到GenericApplicationContext的refreshBeanFactory()方法。这里讲一下
GenericApplicationContext有个构造方法，会new一个新的DefaultListableBeanFactory。
而进入refreshBeanFactory()先当于new一个DefaultListableBeanFactory，并设置一个序列化值。
返回接在再看getBeanFactory()方法，跳到GenericApplicationContext的getBeanFactory(),返回上一步创建的DefaultListableBeanFactory
最后将该beanFactory(DefaultListableBeanFactory)返回。
3、接着进入第三个方法prepareBeanFactory(beanFactory)，该方法主要是beanFactory的预准备工作,也就是对beanFactory进行一些初始化后的设置;
1）、设置BeanFactory的类加载器、支持表达式解析器…
2）、添加部分BeanPostProcessor（ApplicationContextAwareProcessor）
3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware等；
4）、注册可以解析的自动装配，我们能直接在任何组件中自动注入：
BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
5）、添加BeanPostProcessor【ApplicationListenerDetector】
6）、添加编译时的AspectJ；
7）、往BeanFactory中注册组件；environment、 systemProperties、systemEnvironment。
4、接着往下走,进入第4个方法postProcessBeanFactory(beanFactory)，发现该方法是交给子类重写的,子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {}
——————————–以上是BeanFactory的创建及预准备工作—————————–
5、继续进入第5个方法invokeBeanFactoryPostProcessors(beanFactory)，该方法主要是调用beanFactory的后置处理器，在BeanFactory标准初始化之后执行的。这里我们主要跟踪一下AppConfig.class中person bean的生成。看下图，继续进入跟踪
在processConfigBeanDefinitions(BeanDefinitionRegistry registry)中找到下图代码，该代码就是加载person bean定义的。往后就不继续了。
执行完这句代码，可以看一下beanFactory中的beanDefinitionMap属性，已经多了一个person bean 定义
考虑到篇幅，以下几个步骤就不展示代码，只说一下方法里面的操作。
6、registerBeanPostProcessors(beanFactory)。该方法主要往beanFactory注册Bean的后置处理器。
不同接口类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的。有以下几个步骤：
一、获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
二、先注册PriorityOrdered优先级接口的BeanPostProcessor；
把每一个BeanPostProcessor；添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);
三、再注册Ordered接口的
四、 最后注册没有实现任何优先级接口的
五、最终注册MergedBeanDefinitionPostProcessor；
六、注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是
applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7、initMessageSource()。该方法主要初始化MessageSource组件（国际化功能；消息绑定，消息解析）。有以下几个步骤：
一、 获取BeanFactory
二、看容器中是否有id为messageSource的，类型是MessageSource的组件
如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
三、 把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
8、initApplicationEventMulticaster();该方法主要初始化事件派发器；有以下几个步骤：
一、获取BeanFactory
二、 从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
三、如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
四、 将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
9、onRefresh();该方法主要在容器刷新的时候可以自定义逻辑，留给子类实现。
10、registerListeners();该方法主要在容器中将所有项目里面的ApplicationListener注册进来。有以下几个步骤：
一、从容器中拿到所有的ApplicationListener
二、 将每个监听器添加到事件派发器中；
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
三、派发之前步骤产生的事件；
11 、接下来重点看一下这个方法finishBeanFactoryInitialization(beanFactory);该方法作用是实例化所有剩下的懒加载单实例。
重点看一下下面这段代码
@Override
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
// 获取容器中的所有Bean定义名字
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
1.先获取bean定义
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
2.判断Bean是不是抽象的，是不是单实例的，是不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
判断是否是FactoryBean；
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
是否是实现FactoryBean接口的Bean
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
//我们重点看一下这个方法。不是工厂bean，通过该方法获取创建bean实例
getBean(beanName);
}
}
}
xxxxxx
当循环的beanName 为person的时候，我们debug进这个getBean(beanName)方法。
继续debug，进入方法。因为person实例还没有创建，beanFactory中的singletonObjects肯定找不到。一些判断这里就不展示，直接跳过了。找到下面代码
继续debug，进入createBean(beanName, mbd, args);
找到下面代码，进入doCreateBean(beanName, mbdToUse, args);
debug了半天，终于要创建bean实例了。这里Spring容器使用BeanWrappe。BeanWrapper是对Bean的包装，大部分情况下是在spring ioc内部进行使用，用来设置获取被包装的bean对象，获取被包装bean的属性描述器等。
Debug进入createBeanInstance(beanName, mbd, args);
进入debug，进入。通过工厂方法来实例化
继续进入，找到下面代码。beanFactory通过实例化策略来实例化bean
继续debug，进入。找到图中的代码，箭头标记的方法，就是最后生成bean的方法，通过工作方法调用生成实例bean。
执行完上图箭头代码factoryMethod.invoke(factoryBean, args)，bean实例已经生成了，控制台会打印下面这句话。
一路返回，返回到
AbstractAutowireCapableBeanFactory的 doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)方法。想方便点的话，断点直接打到箭头标记的那行，就不需要一路return回去了。这时候可以看到实例bean的信息。
往下继续走，找到下图的代码，箭头中的方法是对实例bean进行赋值。里面有赋值之前的一些后置处理器的处理和利用setter方法等为属性进行赋值操作。这里简单介绍下。
往下看到initializeBean(beanName, exposedObject, mbd)方法。在该方法中进行bean的初始化。里面也是一些后置处理器的操作。
然后，继续返回出去，来到AbstractBeanFactory的doGetBean方法。
这个方法上面见过了，之前只对图中的createBean(beanName, mbd, args)进行分析。现在我们看一下getSingleton(…)这个方法。这个方法也简单，就是从beanFactory的singletonObjects(Map)属性中获取该beanName的值，如果存在，则返回；否则，将该beanName和对应的bean实例添加到singletonObjects属性中。
12、最后看一下refresh() 方法里面的最后一个方法finishRefresh()。该方法主要完成BeanFactory的初始化创建工作。这样IOC容器就创建完成了。
经过上面n多步骤，spring ioc容器初始化过程就结束了
Person person = (Person) ctx.getBean("person");
接下来这个获取person bean就简单了。它的原理就是从beanFactory的singletonObjects(map)中，通过key，获取value了。源码上面也看过了。
学习源码的过程是枯燥的，由于是全英文，可能看着也比较累，但是学习完，感觉收获还是颇多了。由于这个初始化过程步骤比较多，涉及到的东西也比较多，这里看一下，那里看一下，多个类之间切来切去，可能看着也会比较乱一点。但是多看几遍，相信大家也会对这个过程比较了解了。
个人总结：从上面几个步骤可以看出，IOC容器初始化的过程，大部分都是往ioc容器的诸多Map中添加值，方便后续读取使用。读取的时候只需要从Map中根据key取值就可以了。
到此，本篇文章也就结束了。该篇文章主要是记录本人学习spring ioc容器源码的一个过程。中间可能存在一些问题,或有一些不够严谨完善的地方,希望大家体谅体谅。有问题的话,欢迎大家留意,交流交流。
