Spring Bean创建过程

    通过前面几篇文章的分析，我们对Spring框架，Bean，Context和Core都有了一定了解，结合之前的基础，我们研究下ApplicationContext创建Bean的的过程。
    Bean的创建过程可以分为两类：第一类是容器创建时就创建，这类Bean必须是Singleton的，并且lazy-init为false，这也是Bean的默认配置；第二类是获取时才创建，一般是Prototype或者lazy-init为true。所以分析Bean的创建过程我们可以通过两个方面来分析，分别是容器创建时和获取Bean时。

ClassPathXmlApplicationContext创建Bean过程：
1. ClassPathXmlApplicationContext容器创建时就创建Bean
1) ClassPathXmlApplicationContext构造过程

1public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
2    super(parent);
3    // 设置配置参数
4    setConfigLocations(configLocations);
5    if (refresh) {
6        // 刷新容器
7       refresh();
8    }
9}

2) AbstractApplicationContext刷新容器

1public void refresh() throws BeansException, IllegalStateException {
2    synchronized (this.startupShutdownMonitor) {
3    prepareRefresh();
4
5    // 第一步：
6    // AbstractRefreshableApplicationContext的obtainFreshBeanFactory创建DefaultListableBeanFactory,
7    // 通过XmlBeanDefinitionReader将Bean加载到BeanFactory中，BeanFactory中用Map存储BeanDefinition
8    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
9
10    prepareBeanFactory(beanFactory);
11
12    try {
13        postProcessBeanFactory(beanFactory);
14
15        invokeBeanFactoryPostProcessors(beanFactory);
16
17        registerBeanPostProcessors(beanFactory);
18
19        initMessageSource();
20
21        initApplicationEventMulticaster();
22
23        onRefresh();
24
25        registerListeners();
26
27        // 第二步：
28        // 通过调用DefaultListableBeanFactory的preInstantiateSingletons方法，
29        // 初始化单例no-lazy的singletons，并存储到beanFactory的singleObjects成员上
30        finishBeanFactoryInitialization(beanFactory);
31
32        finishRefresh();
33    }
34    catch (BeansException ex) {
35        logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);
36        destroyBeans();
37        cancelRefresh(ex);
38        throw ex;
39    }
40}

3) AbstractRefreshableConfigApplicationContext创建BeanFactory

1protected final void refreshBeanFactory() throws BeansException {
2    if (hasBeanFactory()) {
3        destroyBeans();
4        closeBeanFactory();
5    }
6    try {
7        DefaultListableBeanFactory beanFactory = createBeanFactory();
8        beanFactory.setSerializationId(getId());
9        customizeBeanFactory(beanFactory);
10
11        // loadBeanDefinitions方法由子类实现
12        loadBeanDefinitions(beanFactory);
13        synchronized (this.beanFactoryMonitor) {
14            this.beanFactory = beanFactory;
15        }
16    }
17    catch (IOException ex) {
18        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
19    }
20}

4) AbstractXmlApplicationContext实现loadBeanDefinitions方法创建BeanDefinition

1@Override
2protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
3    // 创建BeanDefinitionReader负责从xml文件中读入BeanDefinition
4    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
5
6    beanDefinitionReader.setEnvironment(this.getEnvironment());
7    beanDefinitionReader.setResourceLoader(this);
8    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
9
10    // 通过BeanDefinitionReader从xml文件读入并创建BeanDefinition
11    // 并将BeanDefinition注册到BeanFactory上
12    initBeanDefinitionReader(beanDefinitionReader);
13    loadBeanDefinitions(beanDefinitionReader);
14}

5) DefaultBeanDefinitionDocumentReader解析生成BeanDefinition

1protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
2    if (delegate.isDefaultNamespace(root)) {
3        NodeList nl = root.getChildNodes();
4        for (int i = 0; i < nl.getLength(); i++) {
5            Node node = nl.item(i);
6            if (node instanceof Element) {
7                Element ele = (Element) node;
8                if (delegate.isDefaultNamespace(ele)) {
9                    // 解析生成BeanDefinition
10                    parseDefaultElement(ele, delegate);
11                }
12                else {
13                    delegate.parseCustomElement(ele);
14                }
15            }
16        }
17    }
18    else {
19        delegate.parseCustomElement(root);
20    }
21}
22
23private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
24    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
25        importBeanDefinitionResource(ele);
26    }
27    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
28        processAliasRegistration(ele);
29    }
30    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
31        // 处理BeanDefinition，使用delegate注册BeanDefinition
32        processBeanDefinition(ele, delegate);
33    }
34    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
35        // recurse
36        doRegisterBeanDefinitions(ele);
37    }
38}

6) DefaultListableBeanFactory注册BeanDefinition

1public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
2    /* 省略部分代码 */
3
4    BeanDefinition oldBeanDefinition;
5    oldBeanDefinition = this.beanDefinitionMap.get(beanName);
6
7    if (oldBeanDefinition != null) {
8        if (!isAllowBeanDefinitionOverriding()) {
9            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound.");
10        }
11        else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
12            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
13            if (this.logger.isWarnEnabled()) {
14                this.logger.warn("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
15            }
16        }
17        else {
18            if (this.logger.isInfoEnabled()) {
19                this.logger.info("Overriding bean definition for bean '" + beanName + "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
20            }
21        }
22    }
23    else {
24        this.beanDefinitionNames.add(beanName);
25        this.manualSingletonNames.remove(beanName);
26        this.frozenBeanDefinitionNames = null;
27    }
28
29    // 将BeanDefinition注册到beanDefinitionMap上
30    this.beanDefinitionMap.put(beanName, beanDefinition);
31    if (oldBeanDefinition != null || containsSingleton(beanName)) {
32        resetBeanDefinition(beanName);
33    }
34}

7) DefaultListableBeanFactory创建lazy-init设置为false的Singletons

1public void preInstantiateSingletons() throws BeansException {
2    if (this.logger.isDebugEnabled()) {
3        this.logger.debug("Pre-instantiating singletons in " + this);
4    }
5
6    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
7    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
8    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
9
10    // Trigger initialization of all non-lazy singleton beans...
11    for (String beanName : beanNames) {
12        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
13        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
14            if (isFactoryBean(beanName)) {
15                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
16                boolean isEagerInit;
17                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
18                    isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
19                        @Override
20                        public Boolean run() {
21                           return ((SmartFactoryBean<?>) factory).isEagerInit();
22                        }
23                    }, getAccessControlContext());
24                }
25                else {
26                    isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit());
27                }
28                if (isEagerInit) {
29                   // 生成FactoryBean并存储到singletonObjects上
30                   getBean(beanName);
31                }
32            }
33            else {
34                // 不是FactoryBean，生成Object并存储到singletonObjects上
35                getBean(beanName);
36            }
37        }
38    }
39
40    /* 省略部分代码 */
41}

2. ClassPathXmlApplicationContext获取Bean时才创建Bean
1) AbstractBeanFactory获取Object

1protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
2    final String beanName = transformedBeanName(name);
3    Object bean;
4
5    // 如果是Object已经创建的Singleton则直接返回，否则使用BeanDefinition创建新的Object
6    Object sharedInstance = getSingleton(beanName);
7    if (sharedInstance != null && args == null) {
8        if (logger.isDebugEnabled()) {
9            if (isSingletonCurrentlyInCreation(beanName)) {
10                logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
11            }
12            else {
13                logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
14            }
15        }
16        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
17    }
18
19    else {
20        // Fail if we're already creating this bean instance:
21        // We're assumably within a circular reference.
22        if (isPrototypeCurrentlyInCreation(beanName)) {
23            throw new BeanCurrentlyInCreationException(beanName);
24        }
25
26        // Check if bean definition exists in this factory.
27        BeanFactory parentBeanFactory = getParentBeanFactory();
28        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
29            // Not found -> check parent.
30            String nameToLookup = originalBeanName(name);
31            if (args != null) {
32                // Delegation to parent with explicit args.
33                return (T) parentBeanFactory.getBean(nameToLookup, args);
34            }
35            else {
36                // No args -> delegate to standard getBean method.
37                return parentBeanFactory.getBean(nameToLookup, requiredType);
38            }
39        }
40
41        if (!typeCheckOnly) {
42            markBeanAsCreated(beanName);
43        }
44
45        try {
46            // 如果已经创建，则从本地BeanDefinition列表中获取BeanDefinition，否则创建新的BeanDefinition
47            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
48            checkMergedBeanDefinition(mbd, beanName, args);
49
50            // Guarantee initialization of beans that the current bean depends on.
51            String[] dependsOn = mbd.getDependsOn();
52            if (dependsOn != null) {
53                for (String dependsOnBean : dependsOn) {
54                    if (isDependent(beanName, dependsOnBean)) {
55                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
56                    }
57                    registerDependentBean(dependsOnBean, beanName);
58                    getBean(dependsOnBean);
59                }
60            }
61
62            // Create bean instance.
63            if (mbd.isSingleton()) {
64                // 使用beanDefinition创建Singleton Object
65                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
66                    @Override
67                    public Object getObject() throws BeansException {
68                        try {
69                            return createBean(beanName, mbd, args);
70                        }
71                        catch (BeansException ex) {
72                            // Explicitly remove instance from singleton cache: It might have been put there
73                            // eagerly by the creation process, to allow for circular reference resolution.
74                            // Also remove any beans that received a temporary reference to the bean.
75                            destroySingleton(beanName);
76                            throw ex;
77                        }
78                    }
79                });
80                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
81            }
82
83            else if (mbd.isPrototype()) {
84                // It's a prototype -> create a new instance.
85                Object prototypeInstance = null;
86                try {
87                    beforePrototypeCreation(beanName);
88                    // 使用beanDefinition创建Prototype Object
89                    prototypeInstance = createBean(beanName, mbd, args);
90                }
91                finally {
92                    afterPrototypeCreation(beanName);
93                }
94                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
95            }
96
97            else {
98                String scopeName = mbd.getScope();
99                final Scope scope = this.scopes.get(scopeName);
100                if (scope == null) {
101                    throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
102                }
103                try {
104                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
105                        @Override
106                        public Object getObject() throws BeansException {
107                            beforePrototypeCreation(beanName);
108                            try {
109                                return createBean(beanName, mbd, args);
110                            }
111                            finally {
112                                afterPrototypeCreation(beanName);
113                            }
114                        }
115                    });
116                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
117                }
118                catch (IllegalStateException ex) {
119                    throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; " + "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex);
120                }
121            }
122        }
123        catch (BeansException ex) {
124            cleanupAfterBeanCreationFailure(beanName);
125            throw ex;
126        }
127    }
128
129    // Check if required type matches the type of the actual bean instance.
130    if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
131        try {
132            return getTypeConverter().convertIfNecessary(bean, requiredType);
133        }
134        catch (TypeMismatchException ex) {
135            if (logger.isDebugEnabled()) {
136                logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", ex);
137            }
138            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
139        }
140    }
141    return (T) bean;
142}

2) AbstractBeanFactory分别对Bean和FactoryBean返回Object

1protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
2    // Don't let calling code try to dereference the factory if the bean isn't a factory.
3    if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
4        throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
5    }
6
7    // 如果不是FactoryBean直接返回Object，否则执行下面操作
8    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
9        return beanInstance;
10    }
11
12    Object object = null;
13    if (mbd == null) {
14        // 如果有缓存的Object直接使用
15        object = getCachedObjectForFactoryBean(beanName);
16    }
17    if (object == null) {
18        // Return bean instance from factory.
19        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
20        // Caches object obtained from FactoryBean if it is a singleton.
21        if (mbd == null && containsBeanDefinition(beanName)) {
22            mbd = getMergedLocalBeanDefinition(beanName);
23        }
24        boolean synthetic = (mbd != null && mbd.isSynthetic());
25
26        // 利用FactoryBean创建新的Object
27        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
28    }
29    return object;
30}