1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
public class IocTests {

    @Test
    public void testLifeCycle() {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
                LifeCycleConfig.class,
                TestBeanPostProcessor.class,
                TestBeanFactoryPostProcessor.class);
        System.out.println("========================================================");
        ctx.registerShutdownHook();
    }
}

@Configuration
class LifeCycleConfig {

    @Bean(autowire = Autowire.BY_TYPE)
    TestBean testBean() {
        System.out.println("testBean constructor");
        return new TestBean();
    }

    @Bean
    InjectedBean injectedBean() {
        System.out.println("injectedBean constructor");
        return new InjectedBean();
    }

    @Bean
    BeanA beanA() {
        System.out.println("beanA constructor");
        return new BeanA();
    }

    @Bean
    BeanB beanB() {
        System.out.println("beanB constructor");
        return new BeanB();
    }

    class TestBean implements InitializingBean,
            DisposableBean,
            BeanFactoryAware,
            ApplicationListener<ApplicationEvent> {

        private InjectedBean injectedBean;

        @PostConstruct
        public void customInit() {
            System.out.println("testBean customInit");
        }

        @PreDestroy
        public void customDestroy() {
            System.out.println("testBean customDestroy");
        }

        @Override
        public void destroy() throws Exception {
            System.out.println("testBean destroy");
        }

        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("testBean afterPropertiesSet");
        }

        public InjectedBean getInjectedBean() {
            return injectedBean;
        }

        public void setInjectedBean(InjectedBean injectedBean) {
            this.injectedBean = injectedBean;
        }

        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("testBean setBeanFactory " + beanFactory.getClass().getSimpleName());
        }


        @Override
        public void onApplicationEvent(ApplicationEvent event) {
            System.out.println("testBean " + event.getClass().getSimpleName());
        }
    }

    class InjectedBean {
    }

    class BeanA {
        private BeanB beanB;

        public BeanB getBeanB() {
            return beanB;
        }

        @Autowired
        public void setBeanB(BeanB beanB) {
            this.beanB = beanB;
        }
    }

    class BeanB {
        private BeanA beanA;

        public BeanA getBeanA() {
            return beanA;
        }

        @Autowired
        public void setBeanA(BeanA beanA) {
            this.beanA = beanA;
        }
    }
}

@Component
class TestBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("testBean".equals(beanName)) {
            System.out.println("testBean postProcessBeforeInstantiation");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("testBean".equals(beanName)) {
            System.out.println("testBean postProcessAfterInstantiation");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        if ("testBean".equals(beanName)) {
            Arrays.stream(pvs.getPropertyValues()).forEach(p ->
                    System.out.println("testBean postProcessPropertyValue " + p.toString()));
        }
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("testBean".equals(beanName)) {
            System.out.println("testBean postProcessBeforeInitialization");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("testBean".equals(beanName)) {
            System.out.println("testBean postProcessAfterInitialization");
        }
        return bean;
    }
}

@Component
class TestBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("testBeanFactory postProcessBeanDefinitionRegistry " + registry.getClass().getSimpleName());
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("testBeanFactory postProcessBeanFactory " + beanFactory.getClass().getSimpleName());
    }
}

1
2
3
4
5
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    this(); // 添加注解的解析器
    register(annotatedClasses); // 将注解的解析器注册到IOC容器中
    refresh();  // 更新容器
}

1
2
3
4
public AnnotationConfigApplicationContext() {
    this.reader = new AnnotatedBeanDefinitionReader(this);  // 解析@Configuration等注解
    this.scanner = new ClassPathBeanDefinitionScanner(this);    // 解析@Scan注解，这里没有使用@Scan
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 初始化context环境变量
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 获得BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 配置BeanFactory的EL表达式解析和Resource资源获取，添加系统环境变量和属性单例到spring容器
        // 添加ApplicationContextAwareProcessor，在Bean初始化前后处理各种Aware接口
        // 添加ApplicationListenerDetector，在Bean初始化前把内部Bean转化为ApplicationListeners。
        prepareBeanFactory(beanFactory);

        try {
        // Allows post-processing of the bean factory in context subclasses.
        // 对于AnnotationConfigApplicationContext是空操作
        // 对于GenericWebApplicationContext会初始化servlet和环境的Bean
        postProcessBeanFactory(beanFactory);

        // Invoke factory processors registered as beans in the context.
        // 实例化实现BeanDefinitionRegistryPostProcessor的类，这里是ConfigurationClassPostProcessor
        // 调用BeanFactory注册的预操作和预处理
        // 实例化实现BeanFactoryPostProcessor的类
        // 调用BeanFactory的预处理
        invokeBeanFactoryPostProcessors(beanFactory);

        // Register bean processors that intercept bean creation.
        // 实例化实现BeanPostProcessor的类
        registerBeanPostProcessors(beanFactory);

        // Initialize message source for this context.
        // 初始化多国语言
        initMessageSource();

        // Initialize event multicaster for this context.
        // 注册并实例化SimpleApplicationEventMulticaster，监听Bean的ApplicationListener
        initApplicationEventMulticaster();

        // Initialize other special beans in specific context subclasses.
        // 空操作
        onRefresh();

        // Check for listener beans and register them.
        // 添加实现ApplicationListener的Bean信息，以作为后续回调
        registerListeners();

        // Instantiate all remaining (non-lazy-init) singletons.
        // 注册并实例化非@Lazy的普通Bean，BeanPostProcessor在前面已经实例化完成
        // 会涉及到属性注入的问题，下文会分析
        finishBeanFactoryInitialization(beanFactory);

        // Last step: publish corresponding event.
        // 完成实现Lifecycle接口Bean的回调（应用层用得很少）
        // 通知所用实现ApplicationListener的Bean事件ContextRefreshedEvent
        finishRefresh();
        }

        // ......

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    // 转化beanName
    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    // 获取还没有完全注入属性但已经构造成功的实例
    // 可解决循环依赖
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {
        //.......

        // Create bean instance.
        if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
                return createBean(beanName, mbd, args);
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
        //.......
    }
    return (T) bean;
}
```java
通过以上简略代码可知：
1. 若有循环依赖现象则获取已经构造成功的单例。
2. 否则利用getSingleton的匿名内部类回调createBean，预处理实例化，处理可能存在的代理对象，最后调用doCreateBean。
3. 无论如何都会执行getObjectForBeanInstance，处理实现FactoryBean的类。

继续查看doCreateBean省略与测试代码无关的源码：
```java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;

    // 实例化Bean，并对Bean装饰，处理后续操作field
    // 实例化可通过@Bean下的method，即RootBeanDefinition.getFactoryMethodName（之前流程已经解析到RootBeanDefinition）
    // 或普通的构造方法，有参或无参
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    // 解决循环依赖Bean，通过beanName映射singletonFactories
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

    // Initialize the bean instance.
    Object exposedObject = bean;
    // 通过装饰对象对依赖属性进行注入
    // 如@Bean下method的参数、@Bean(autowire)和@Autowired下field和setField注入依赖Bean
    // 后处理实例化
    populateBean(beanName, mbd, instanceWrapper);

    // 此时Bean是完整对象，预处理初始化、自定义初始化、后处理初始化。
    exposedObject = initializeBean(beanName, exposedObject, mbd);

    // ......

    return exposedObject;
}