spring BeanFactory中Bean的实例化过程

来源：互联网发布：清风冰桶算法编辑：程序博客网时间：2024/05/16 11:59

转载 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===nullp===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重点代码

//********************重点*******************// 创建单实例Beanif (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 框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：

0 0