spring BeanFactory中Bean的实例化过程

转载 http://blog.csdn.net/u011179993/article/details/51672734

参考：http://www.cnblogs.com/charlesblc/p/6124224.html?utm_source=itdadao&utm_medium=referral

一、实例

class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("=======BeanPostProcessor的postProcessBeforeInitialization=========");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("=======BeanPostProcessor的postProcessAfterInitialization=========");
        return bean;
    }
} 

public class Tester implements InitializingBean, DisposableBean, BeanNameAware {

    private String p;

    public Tester() {
        System.out.println("---构造方法---");
        System.out.println("p===" + p);
    }

    public void setP(String p) {
        this.p = p;
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("p===" + p);
        System.out.println("---BeanNameAware接口setBeanName---");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("---InitializingBean接口afterPropertiesSet---");
    }

    public void initMethod() {
        System.out.println("---指定的InitMethod---");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("---DisposableBean的destroy方法---");
    }

    public void destroyMethod() {
        System.out.println("--指定的Destroy方法---");
    }

    @Override
    public String toString() {
        return "toString+++"+p;
    }


    public static void main(String[] args) throws Exception {
        //创建一个BeanFactory
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        factory.addBeanPostProcessor(new MyBeanPostProcessor());

        //构造一个BeanDefinition
        RootBeanDefinition definition = new RootBeanDefinition(Tester.class);
        definition.setInitMethodName("initMethod");
        definition.setDestroyMethodName("destroyMethod");

        //设置这个bean的属性
        Map<String, Object> map = new HashMap<>();
        map.put("p", "jack");
        definition.setPropertyValues(new MutablePropertyValues(map));

        //注册BeanDefinition
        factory.registerBeanDefinition("tester", definition);

        //执行获取和销毁bean的方法
        factory.getBean("tester");
        factory.destroySingleton("tester");
    }
}

 
 
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
 
 
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

去掉多余日志，输出如下：

---构造方法---
p===null

p===jack

---BeanNameAware接口setBeanName---

=======BeanPostProcessor的postProcessBeforeInitialization=========

---InitializingBean接口afterPropertiesSet---

---指定的InitMethod---

=======BeanPostProcessor的postProcessAfterInitialization=========

---DisposableBean的destroy方法---

--指定的Destroy方法---
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们可以得到实例化bean的大致过程~ 
1：调用Bean的默认构造方法（当然也可以是指定的其它构造方法），生成bean实例。 
2：检查BeanDefinition中是否注入了Bean的属性值，如果有注入，则在bean实例的基础上对其属性进行注入。 
3 : 调用Aware相关接口的方法 
4 :postProcessBeforeInitialization 
5：检查Bean是否实现了InitializingBean接口，如果实现了此接口，则调用afterPropertiesSet()方法。 
6：检查Bean配置文件中是否指定了initMethodName属性，如果已指定，则调用此属性对应方法。 
7 : postProcessAfterInitialization

销毁过程 
1：检查Bean是否实现了DisposableBean 接口，如果实现了此接口，则调用destroy()方法。 
2：检查Bean配置文件中是否指定了destroyMethodName属性，如果已指定，则调用此属性对应方法

二、AbstractBeanFactory#doGetBean(..)源码

无论以何种方式获取Bean,都会调用AbstractBeanFactory#doGetBean(..)方法。

去除了这个方法的非重点代码, 保留了部分重要的代码，如下：

protected <T> T doGetBean( String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly)  {

        final String beanName = transformedBeanName(name);
        Object bean;


        Object sharedInstance = getSingleton(beanName);//是否已经创建过Bean
        if (sharedInstance != null && args == null) {
            //1.查找手动注册的Bean实例 或者已经创建过的Bean实例
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else { 
            // 2.检查父容器是否含有这个Bean，有则返回
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                String nameToLookup = originalBeanName(name);
                if (args != null) {
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            } 

            //3.获取MergedLocalBeanDefinition
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 初始化指定的依赖Bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dependsOnBean : dependsOn) { 
                    registerDependentBean(dependsOnBean, beanName);
                    getBean(dependsOnBean);
                }
            }

            //********************重点*******************
            // 创建单实例Bean
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    @Override
                    public Object getObject() throws BeansException { 
                        return createBean(beanName, mbd, args); 
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            //***************************************

            //创建多实例Bean
            else if (mbd.isPrototype()) {
                     //.....
            } 

        }

        // 根据指定的类型进行转换
        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
             return getTypeConverter().convertIfNecessary(bean, requiredType);

        }
        return (T) bean;
    }
 
 
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
 
 
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

1.查找手动注册的Bean实例 或者已经创建过的Bean实例 
获取DefaultSingletonBeanRegistry中保存的Bean 
2. 
代码中 //***之间就是创建Bean的主要代码。下面将针对这部分进行讲解。

三 ，创建Bean重点代码

//********************重点*******************
// 创建单实例Bean
if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException { 
                return createBean(beanName, mbd, args); //1
            }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//***************************************
 
 
1
2
3
4
5
6
7
8
9
10
11
12
 
 
1
2
3
4
5
6
7
8
9
10
11
12

1中进入匿名类ObjectFactory的createBean部分，他实际调用AbstractAutowireCapableBeanFactory#createBean(..)方法

AbstractAutowireCapableBeanFactory#createBean(..)方法

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)   {


    RootBeanDefinition mbdToUse = mbd;  
    //设置RootBeanDefinition的BeanClass
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // Prepare method overrides.
    mbdToUse.prepareMethodOverrides();

    // 允许BeanPostProcessors返回一个代理代替Bean实例
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        return bean;
    }

    //实际生成Bean的方法,调用AbstractAutowireCapableBeanFactory#doCreateBean(..)
    Object beanInstance = doCreateBean(beanName, mbdToUse, args); 
    return beanInstance;
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

AbstractAutowireCapableBeanFactory#doCreateBean(..)

重点代码如下：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    // 创建BeanWrapper
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }

    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;
        }
    }


    Object exposedObject = bean;
    //设置Bean的属性值     
    populateBean(beanName, mbd, instanceWrapper);

    if (exposedObject != null) {
        //***************重点***************
        //处理Bean（Aware接口相关方法，前处理器，初始化方法，后处理器）
        exposedObject = initializeBean(beanName, exposedObject, mbd);
        //调用的是AbstractAutowireCapableBeanFactory#initializeBean(..)方法
        //**********************************

    }

    // Register bean as disposable.
    registerDisposableBeanIfNecessary(beanName, bean, mbd); 

    return exposedObject;
}
 
 
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
 
 
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

调用的是AbstractAutowireCapableBeanFactory#initializeBean(..)方法

这个方法代码简化如下

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    //调用Aware相关接口的方法 
    invokeAwareMethods(beanName, bean);

    Object wrappedBean = bean;
    //Bean前处理器
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

    //调用指定的InitMethod方法
    invokeInitMethods(beanName, wrappedBean, mbd);

    //调用Bean后处理器
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

    return wrappedBean;
}

一个非常重要的部分就是建立 Bean 对象实例之间的关系，这也是 Spring 框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：