Spring的Bean的实例化

Posted on | In
Words count in article: 4.3k | Reading time ≈ 19

Bean的实例化

在refresh方法执行到 finishBeanFacotyInitializawtion 时，在方法内部会执行对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
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //  为BeanFactoy添加conversionService
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && // 是否包含 conversionService
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // 尽早初始化LoadTimeWeaverAware Bean，以便尽早注册其转换器。
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // 取消使用临时的classLoader
    beanFactory.setTempClassLoader(null);

    // 允许缓存所有的Bean Definition 元数据，
    beanFactory.freezeConfiguration();

    // 初始化所有剩余的（非懒加载的）单例的Bean
    beanFactory.preInstantiateSingletons();
}

重点在于 preInstantiateSingletons 方法，用来初始化所有的单例Bean。实际上在前面的getBean获取weaverAware就能够看出真正调用获取单实例的Bean的方法就是 getBean 方法。

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
public void preInstantiateSingletons() throws BeansException {
    // logging ....

    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 触发有非懒加载的Bean的初始化
    for (String beanName : beanNames) {
        // 获取所有的RootBeanDefinition,所谓的Rootxxx，其实就是统一的BeanDefinition视图
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                // 如果是FactoryBean，则使用getBean时需要加上前缀 &
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        // 如果继承SmartFactoryBean
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                        ((SmartFactoryBean<?>) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                    // 执行getBean获取Bean
                        getBean(beanName);
                    }
                }
            }
            else {
                // 执行getBean获取Bean
                getBean(beanName);
            }
        }
    }

    // 触发初始化后的callback...
}

在preInstantiateSingletons 中，可以看到它会遍历所有的已经注册到容器中的Bean，最后会通过 getBean() 进行对Bean的初始化操作。

其中判断了如果是 Factorybean 的情况下应该先去添加一个前缀 ‘&’ ，才能获取真正的FactoryBean的实现类的对象Bean。如果不添加前缀 ‘&’，则会返回实现类中的getObject方法返回的对象。

因为经过分析，是 getBean 方法是达到初始化Bean实例的目的，所以接下来看 getBean 中是如何实现的。

getBean

getBean方法比较复杂，所以我依据调用顺序拆出来大致5个小章节来展开讲。

1.getBean通过调用doGetBean创建实例

1
2
3
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

2. 检查缓存中是否存在

调用doGetBean方法后，首先会先使用getSingleton方法判断缓存中是否存在实例，会执行以下逻辑：

  1. 判断缓存中是否存在？
  2. 如果存在，如果当前单例正在创建中，则说明出现了循环引用。
  3. 如果存在，实例没有正在创建，没有循环引用。
  4. 只要缓存中存在，都直接返回缓存中的BeanInstance
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    // 获得Beanname字符串，因为有FactoryBean需要添加&符号
    final String beanName = transformedBeanName(name);
    Object bean;

    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    //...

3. 如果typeCheckOnly为false，则标记已创建

作用是：将指定的bean标记为已创建，允许bean工厂优化其缓存以重复创建指定的bean。

4. 获取depend-on的Bean，先对其进行register和实例化

需要注意的是，这里的 depend-on 的内容是使用 @DependsOn 注解指定的BeanName（注解方式）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 获得RootBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查merge后的beanDefinition
checkMergedBeanDefinition(mbd, beanName, args);
// 确保当前bean依赖的bean的初始化。
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    for (String dep : dependsOn) {
        if (isDependent(beanName, dep)) {
            // throw exception ...
        }
        // 先registr 依赖的Bean
        registerDependentBean(dep, beanName);
        try {
            // 对每一个dep进行先行的实例化
            getBean(dep);
        }
        catch (NoSuchBeanDefinitionException ex) {
            // throw exception ...
        }
    }
}

5.调用createBean创建Bean实例

在使用createBean创建Bean时，会通过 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);来处理初始化Bean前置方法触发AOP的功能。

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
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                // 执行前置方法，获取代理Bean
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        // 使用 EnableAspectJAutoProxy 注解，将AbstractAutoProxyCreator import 进来，
        // 所以在这里可以调用 AbstractAutoProxyCreator后置的处理器方法，来实现AOP功能
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    Object cacheKey = getCacheKey(beanClass, beanName); //获得beanClass
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {// 如果是一个基础设施的类 或者是一个original instance
            this.advisedBeans.put(cacheKey, Boolean.FALSE); //添加到advisedBeans里面
            return null;
        }
    }
    // 如果有自定义的 TargetSource
    // 抑制目标Bean的不必要的默认实例化
    // TargetSource将以自定义方式处理目标实例。
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName); //获得targetSource
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        // 生成代理
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource); //创建代理类
        this.proxyTypes.put(cacheKey, proxy.getClass());
        // 返回生成的代理Bean
        return proxy;
    }
    return null;
}

如果存在需要创建Proxy代理Bean，则先去创建代理Bean，在创建完后，则会开始调用 doCreateBean 方法创建Bean实例。

接着调用 Object beanInstance = doCreateBean(beanName, mbdToUse, args); 创建实例，并返回一个Object的类型的beanInstance

doCreateBean这个方法比较长，大致能通过这几步完成这个方法；

  1. 使用 createBeanInstance 创建一个包装Bean
  2. 允许MergedBeanPostProcessor使用后置方法处理包装后的Bean
  3. 如果 allowCircularReferences 属性为true，则先获取 达到这个Bean的早期的ref ，用来 防止Bean在生成时循环引用 的问题，后面会详细讲这里是如果获取早期的ref应用，和又是如何防止Bean的循环应用的问题。
  4. 通过 populateBean 方法为Bean进行赋值，包括依赖！！
  5. 通过 initializeBean 方法，执行各种初始化方法和前、后置方法。
  6. 通过三级缓存机制，用来防止出现循环引用的问题。
  7. 注册Bean为一次性的

createBeanInstance 创建一个包装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
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    //.....省略部分
    // Shortcut when re-creating the same bean...
    /**
     * 这里指的ShortCut的含义是当多次构建同一个 bean 时，可以使用这个Shortcut，
     * 也就是说不在需要每次推断应该使用哪种方式构造bean
     * 比如在多次构建同一个prototype类型的 bean 时，就可以走此处的Shortcut
     * 这里的 resolved 和 autowireNecessary 将会在 bean 第一次实例化的过程中被设置
     */
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    // 如果已经创建过了
    if (resolved) {
        // 如果以解析构造函数
        if (autowireNecessary) {
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            return instantiateBean(beanName, mbd);
        }
    }
    // Candidate constructors for autowiring?
    // 如果是通过构造函数来自动注入的
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    // Preferred constructors for default construction?
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }
    // 没有特殊处理，使用无参数构造器
    return instantiateBean(beanName, mbd);
}

如果使用默认的无参数构造起，会调用beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent); 获取使用反射生成的实例。

1
2
3
4
5
6
7
8
9
10
11
// 检测 bean 配置中是否配置了 lookup-method 或 replace-method
// 如果没有，则使用默认的JDK代理生成对象，否则使用CGlib代理
if (!bd.hasMethodOverrides()) {
// 省略代码。。。。
    // 实例化
    return BeanUtils.instantiateClass(constructorToUse);
}
else {
    // 必须生成CGLIB子类
    return instantiateWithMethodInjection(bd, beanName, owner);
}

知道最后使用Constructor.newInstance创建一个对象。

先缓存早期的实例

Spring中存在三层缓存，分别为第一级的 singletonObjects 、第二级的 earlySingletonObjects 、第三级的singletonFactories。

1
2
3
4
5
6
7
8
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

那么，Spring如何依靠这三级缓存来防止循环引用（circular references）的作用的呢？先通过下面的图片来简单了解下，当发生循环引用时，Spring如何使用三级缓存的。

图1

如图中所示，对象A依赖于对象B，而对象B依赖对象A的情况。下面根据图中各节点情况来具体分析代码的实现：

1. 实例化A，发现依赖B

在初始化A的过程中，会调用 populateBean 方法进行属性的赋值，其中 AutoWired 的类型来分别处理（By Name 还是 By Type）,
但不管是哪个类型，最后都会使用 getBean 来先获取依赖。

2. 获取B，将A放到三级缓存中

其实在进行A的属性赋值前，就已经通过 doCreateBean 方法中的 addSingletonFactory 方法将A放到三级缓存中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
    // 如果 allowCircularReferences 为true
if (earlySingletonExposure) {
    // log.....
    // 放到第三级的singletonFactory里
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 第三级缓存，也就是SingleFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
    // 如果对象没有生成过
        if (!this.singletonObjects.containsKey(beanName)) {
        // 放到三级缓存中，同时如果二级缓存中存在，移除掉
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}
3. 实例化B，发现依赖A

在上一步中，A依赖B，会调用getBean先去获取B，但同样在doCreateBean 方法中的 populateBean 方法中同样会调用 getBean 先去获取依赖A。

1
2
3
4
5
6
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// log....
// 通过getObjectForBeanInstance获取Bean，完成实例化
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

通过getSingleton方法从三级缓存获取bean，如果成功的在第三级缓存中找到Bean，则移除第三级缓存中的Bean，并放到二级缓存中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    // 如果三级缓存中有bean，则放到二级缓存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}
4. 实例化完成，将B放到一级缓存中

在调用doGetBean方法时，会通过 getSingleton方法中的addSingleton将实例添加到一级缓存中：

1
2
3
4
5
6
7
8
sharedInstance = getSingleton(beanName, () -> {
    try {
        // 准备好后，进行创建当前Bean实例
        return createBean(beanName, mbd, args);
    }
    catch (BeansException ex) {
    }
});

在getSingleton中调用了addSingleton(beanName, singletonObject),将完成的实例放到一级缓存中。

1
2
3
4
5
6
7
8
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}
5. 返回A的创建过程，继续创建A

最后创建完成A后，同样会将A放到一级缓存中。至此对象A，对象B全部创建完成。利用了三级缓存机制避免了循环引用。

populateBean 执行Bean的初始化

在上一节中提到了，初始化对象时，需要调用populateBean(beanName, mbd, instanceWrapper)该方法来达到属性值的填充。

忽略 BeanPostProcessor后置处理器，那么实际上步骤比较简单明了：

  1. 如果不存在属性值，则直接返回，跳过这个方法。
  2. 如果存在，先获得所有的属性值，依据AutoWired属性，将依赖项注入到容器中
  3. 最后进行真正的属性填充
1. 检查是否存在属性
1
2
3
4
5
6
7
8
9
10
if (bw == null) {
  if (mbd.hasPropertyValues()) {
    throw new BeanCreationException(
      mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
  }
  else {
    // 如果没有直接跳过
    return;
  }
}
2.依据ByName还是ByType进行属性的注入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 获得属性
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 获得autowired类型（by type 还是 by name）核心是pvs.add(propertyName, bean); 获得适当的bean当道pvs中
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  // 如果适用，按名称添加基于自动装配的属性值。
  if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
    autowireByName(beanName, mbd, bw, newPvs);
  }
  // 如果适用，按类型添加基于自动装配的属性值。.
  if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    // 其中resolveDependency包含JSR330中的Inject方法
    autowireByType(beanName, mbd, bw, newPvs);
  }
  // 但是不管是ByType还是ByName最后都是调用getBean方法先获取属性依赖Bean
  pvs = newPvs;
}

根据 resolvedAutowireMode 的值的不同，选择不同的装配方式

  • 按名称注入，使用@Autowired默认的方式
  • 按类型注入，使用@Resource或者使用JSR330标准中的@Inject注解的默认方式

但是，不管依赖哪种方式进行装配，最后都会使用getBean来获取属性依赖，装配到容器中，并将值放到 newPvs 等待填充。

3.属性填充

最后通过使用 applyPropertyValues 方法实现属性的填充：

主要步骤如下：

  1. 如果pvs是空的，则直接返回
  2. 否则创建一个deep copy，用于解决所有对值的引用，对未被解析的先解析&&已解析的直接加入deepCopy中。
  3. 获取到 deepCopy 后，使用 setPropertyValues 添加到BeanWrapper中
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
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
	// 如果pvs内容是空的，则直接return
	if (pvs.isEmpty()) {
		return;
	}
	// 设置 SecurityContextProvider
	if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
		((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
	}
	MutablePropertyValues mpvs = null;
	List<PropertyValue> original;
	if (pvs instanceof MutablePropertyValues) {
		mpvs = (MutablePropertyValues) pvs;
		// 已经是转化过的
		if (mpvs.isConverted()) {
			// Shortcut: use the pre-converted values as-is.
			// 照原样使用预先转换的值
			try {
				bw.setPropertyValues(mpvs);
				return;
			}
			catch (BeansException ex) {
			}
		}
		original = mpvs.getPropertyValueList(); // 获取一个List<PropertyValue> 属性组
	}
	else {
		original = Arrays.asList(pvs.getPropertyValues());
	}
	// 获得 BeanDefinitionValueResolver
	TypeConverter converter = getCustomTypeConverter();
	if (converter == null) {
		converter = bw;
	}
	BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

	// Create a deep copy, resolving any references for values. 
	// 创建一个深层副本，以解决所有对值的引用。对未被解析的先解析/已解析的直接加入deepCopy中
	List<PropertyValue> deepCopy = new ArrayList<>(original.size());
	boolean resolveNecessary = false;
	for (PropertyValue pv : original) {
		if (pv.isConverted()) {
			// 如果已转化，直接添加到deepCopy中
			deepCopy.add(pv);
		}
		else {
			// 获得属性名和属性值
			String propertyName = pv.getName();
			Object originalValue = pv.getValue();
			// 是否是AutowiredPropertyMarker
			if (originalValue == AutowiredPropertyMarker.INSTANCE) {
				//获取应用于写入属性值的方法
				Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
				if (writeMethod == null) {
					throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
				}
				originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
			}
			// 使用valueResolver解析属性值,给定一个PropertyValue，返回一个值，如有必要，解析工厂中对其他bean的任何引用
			Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
			Object convertedValue = resolvedValue;
			boolean convertible = bw.isWritableProperty(propertyName) &&
					!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
			if (convertible) {
				// 如果可转化，转化这个属性
				convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
			}
			// 可能将转换后的值存储在合并的bean定义中，避免对每个创建的bean实例进行重新转换
			if (resolvedValue == originalValue) {
				if (convertible) {
					pv.setConvertedValue(convertedValue);
				}
				deepCopy.add(pv);
			}
			else if (convertible && originalValue instanceof TypedStringValue &&
					!((TypedStringValue) originalValue).isDynamic() &&
					!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
				pv.setConvertedValue(convertedValue);
				deepCopy.add(pv);
			}
			else {
				resolveNecessary = true;
				deepCopy.add(new PropertyValue(pv, convertedValue));
			}
		}
	}
	if (mpvs != null && !resolveNecessary) {
		// 设置已转化属性
		mpvs.setConverted();
	}

	try {
		// 放到PropertyValues里面
		bw.setPropertyValues(new MutablePropertyValues(deepCopy));
	}
}

initializeBean 初始化Bean

在使用populateBean后，调用initializeBean方法进行bean的init，在init方法内部，可分为一下几部分调用

  1. invokeAwareMethods 方法，设置Aware属性
  2. applyBeanPostProcessorsBeforeInitialization 方法，调用 BeanProcessor中的Bean初始化前的后置方法
  3. invokeInitMethods 方法，激活自定义的init方法
  4. 执行BeanProcessor中的初始化后的后置方法
1. invokeAwareMethods

寻找是否满足特定的条件，如果满足则进行相关属性的填充

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private void invokeAwareMethods(final String beanName, final Object bean) {
	if (bean instanceof Aware) {
	    // 如果是 BeanNameAware，设置BeanName
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		// 如果是  BeanClassLoaderAware，设置classloader
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}
2. applyBeanPostProcessorsBeforeInitialization

循环容器中每一个BeanPostProcessor，执行BeanPostProcessor的postProcessBeforeInitialization方法。

1
2
3
4
5
6
7
8
9
10
11
12
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}
3.invokeInitMethods 执行init方法

如果是isInitializingBean则先会执行自己的内置方法afterPropertiesSet。如果制定了initMethod，那么后续会通过反射执行这个方法

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
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

	boolean isInitializingBean = (bean instanceof InitializingBean);
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
					((InitializingBean) bean).afterPropertiesSet();
					return null;
				}, getAccessControlContext());
			}
		}
		else {
			((InitializingBean) bean).afterPropertiesSet();
		}
	}

	if (mbd != null && bean.getClass() != NullBean.class) {
		String initMethodName = mbd.getInitMethodName();
		if (StringUtils.hasLength(initMethodName) &&
				!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
				!mbd.isExternallyManagedInitMethod(initMethodName)) {
			invokeCustomInitMethod(beanName, bean, mbd);
		}
	}
}
4.applyBeanPostProcessorsAfterInitialization

循环容器中每一个BeanPostProcessor，执行BeanPostProcessor的 postProcessAfterInitialization 方法。

至此Bean的实例化过程就大致完成了。

-------------本文结束感谢您的阅读-------------

本文标题:Spring的Bean的实例化

文章作者:NanYin

发布时间:2020年01月17日 - 15:01

最后更新:2020年01月18日 - 09:01

原始链接:https://nanyiniu.github.io/2020/01/17/Spring%E4%BB%8E%E9%9B%B6%E5%BC%80%E5%A7%8B%E4%B9%8B%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E5%9B%9B%EF%BC%89/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。