Spring IOC 源码解析(八) Bean 的创建
文章目录
- 一.前言
- 二.源码流程
- 2.1 doGetBean()
- 2.1.1 重点一 (11~25 行):
- 2.1.2 重点二 (37~49 行):
- 2.1.3 重点三 (53行 和 58行):
- 2.1.4 重点四 (64~83 行):
- 2.1.5 重点五 (86~104 行):
- 2.2 createBean();
- 2.2.1 重点一 (12~16 行):
- 2.2.2 重点二 (32~35 行):
- 2.2.3 重点三 (42行)
- 2.3 doGetBean()
- 2.3.1 重点一(14行)
- 2.3.2 重点二 (58行)
- 2.3.3 重点三: (63行)
- 2.4 createBeanInstance()
- 2.5 instantiateBean()
- 2.6 instantiate()
- 2.7 populateBean()
- 2.8 initializeBean()
- 三. 总结
一.前言
在上一遍中,我们了解了从 xml 中转化 BeanDefinition 的流程,最后我们也提到了 BeanFactory 在第一次调用 getBean() 的时候才会实例化真正的 bean (如果是 ApplicationContext 则会在初始化的时候实例化所有未设置 lazily 属性的 bean).所以接下来我们看一下创建 bean 的流程.
二.源码流程
2.1 doGetBean()
我们从 getBean() 入手,可以看到总是都会调用到 doGetBean 方法.所以我们直接从 doGetBean 方法入手,源码里面我都加了中文注释,可以先根据注释了解一下大概流程.后面我们将重点地方讲一下.
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
// 获取 Bean 的原始名字,即如果是别名,则返回最初的 beanName
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 先从缓存中取得 bean , 获取那些已经被创建过的单件模式的 bean,对这种 bean 的请求不需要重复地创建
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 这里的 getObjectForBeanInstance 完成的是 FactoryBean 的相关处理,以取得 FactoryBean 的生产结果
// 一般情况下会直接返回 sharedInstance
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 这里对 ioc 容器中的 BeanDefinition 是否存在进行检查,检查是否能在当前的 BeanFactory 中取得需要的 BeanDefinition
// 如果在当前的工厂中取不到,则到父 BeanFactory 中去取,如果当前的工厂的父 BeanFactory 找不到,那就顺着 BeanFactory 链一直向上找
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
// 在 map 保存标识,记录这个 beanName 已经被创建过了 ,并删除 beanName 合并的 BeanDefinition
markBeanAsCreated(beanName);
}
try {
// 这里根据 bean 的名字取得 BeanDefinition,并重新创建合并的 BeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查 BeanDefinition 是否是抽象的,如果是则抛异常
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 确保当前 bean 所依赖的 bean 的初始化
String[] dependsOn = mbd.getDependsOn();
// 获取当前 bean 的所有依赖 bean,这样会触发 getBean 的递归调用,直到去到一个没有任何依赖的 bean 为止
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 这里添加相互依赖的关系 map, dep 依赖于 B, B 被 dep 依赖.存放到 两个 map 中, dependentBeanMap,dependenciesForBeanMap
registerDependentBean(dep, beanName);
try {
// 递归调用,先创建当前 BeanName 所依赖的对象
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
// 这里通过调用 createBean 方法创建 Singleton bean 的实例,这里有一个回调函数, getObject, 会在 getSingleton 中调用 ObjectFactory 的 CreateBean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
// 创建 bean 的地方
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 如果 BeanDefinition 是原型
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// BeanDefinition 设置了范围,如会话,请求等
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
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);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
// 这里对 创建的 bean 进行类型检查,如果没有问题,就返回这个新创建的 bean,这个 bean 已经是包含了依赖关系的 bean
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
2.1.1 重点一 (11~25 行):
获取已经创建的单例 Bean (默认情况下,我们创建的 bean 都是单例 Bean),如果返回的不为 null,也就是 bean 已经被创建过了,则直接返回.
2.1.2 重点二 (37~49 行):
获取当前工厂的父工厂,做判断,如果有父工厂,并且创建的当前 bean 在当前工厂中找不到 BeanDefinition ,则让父工厂去创建该 Bean ,并返回给子容器.
2.1.3 重点三 (53行 和 58行):
53行和58行,这两个方法主要注意的就是,在创建一个 Bean 的时候,首先将 BeanDefinition 合并完整(如果有父 BeanDefinition, 则会将父 BeanDefinition 克隆一份,然后将子 BeanDefinition 中的属性填充进去,如果重复则覆盖). 如果是重新创建一个 bean 的话,会先将原先合并完的 BeanDefinition 删除掉,在重新创建.防止一些元数据变化.
2.1.4 重点四 (64~83 行):
将当前 bean 依赖的 bean 全部初始化,递归调用 getBean().保证当前 bean 创建时,所要依赖的 bean 初始化全部完毕.
2.1.5 重点五 (86~104 行):
判断创建的当前 bean 的范围是否是单例(默认情况下,我们所创建的 bean 都是单例的).这里的主要方法就是92行,调用了createBean() 方法,创建 bean.下面的一些判断体是创建其他范围 bean ,如 原型,会话,请求等.这里我们只介绍最常用的单例 bean.其他的可以根据研究流程自行查看.
2.2 createBean();
这个方法主要做了一些简单的操作:
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 判断创建的 bean 是否可以实例化,将 BeanDefinition 中的类加载到类加载器中,并返回 Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
// 验证和准备为此 BeanDefinition 的方法重写。检查是否存在具有指定名称的方法
// 一般情况下,这个方法没有什么作用.
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 如果 bean 实现了 InstantiationAwareBeanPostProcessor ,那么这里返回的是一个 proxy 类
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
// 这里是创建 bean 的调用
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
2.2.1 重点一 (12~16 行):
将 BeanDefinition 中的当前 bean Class 加载到虚拟机,可供后续实例化使用,并将 Class 赋值到 BeanDefinition 中,以便后续不需要重复加载.
2.2.2 重点二 (32~35 行):
如果某些 bean 实现了 InstantiationAwareBeanPostProcessor 接口,则会调用它的 applyBeanPostProcessorsBeforeInstantiation() 和 applyBeanPostProcessorsAfterInitialization() 如果返回有对象则直接返回.
2.2.3 重点三 (42行)
调用 doGetBean() 方法来创建 bean.这是我们关注的重点,所以我们进入这个方法来研究它.
2.3 doGetBean()
直接上源码:
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
// Instantiate the bean.
// 这个 BeanWrapper 是用来持有创建出来的 bean 对象的
BeanWrapper instanceWrapper = null;
// 如果是 Singleton, 先把缓存中的同名 bean 清除
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 这里是创建 bean 的地方,由 createBeanInstance 来完成
// 返回的结果就是创建完毕的 bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 调用合并 BeanDefinition 后的后置处理器
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 保存当前 Bean 的 ObjectFactory
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
// 这里是对 bean 的初始化,依赖注入往往在这里发生,这个 exposedObject 在初始化处理完以后 返回作为依赖注入完成后的 bean
Object exposedObject = bean;
try {
// 依赖关系的注入,填充 bean
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 调用一些 bean 生命周期的方法
// 1.BeanNameAware 2.BeanClassLoaderAware 3.BeanFactoryAware
// 4.EnvironmentAware 5.EmbeddedValueResolverAware 6.ResourceLoaderAware 等等
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
// 注册 DisposableBean.在摧毁 bean 的时候调用
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
2.3.1 重点一(14行)
调用 createBeanInstance() ,实例化 Bean 的方法
2.3.2 重点二 (58行)
调用 populateBean() ,注入当前 bean 依赖的其他 bean 或 属性,(详细介绍在 2.7 )
2.3.3 重点三: (63行)
调用 initializeBean() ,执行 bean 生命周期的一系列方法 (详细介绍在 2.8 )
2.4 createBeanInstance()
源码:
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// Make sure bean class is actually resolved at this point.
// 确保 bean 类在此处被实际解析
Class<?> beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
// here using the factory method to instantiate bean
// 这里使用工厂方法创建 bean
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 重新创建相同 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);
}
}
// Need to determine the constructor...
// 使用构造函数实例化 bean, 如果创建该 bean 时,构造函数需要注入其他 bean 则进入下方方法体,创建该 bean
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
// 使用默认的构造对 bean 进行实例化
// 最常见的实例化过程
return instantiateBean(beanName, mbd);
}
这里主要关注的地方是最后一行调用 instantiateBean() 方法的地方,这里使我们最常用的 bena 初始化的地方,当然还有其他初始化的方法,如使用工厂方法,或则构造器上加 @Bean 注解等等.在源码的注解上我也标注了.这里我们只研究下最常用的创建 bean 方法;
2.5 instantiateBean()
距离真正初始化 bean 的地方越来越近了.不要灰心,继续往下看.
源码:
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
// 使用默认的实例化类 CglibSubclassingInstantiationStrategy 对 bean 进行实例化
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
这里的重点显而易见,都是调用 getInstantiationStrategy() 返回 CglibSubclassingInstantiationStrategy 类.然后调用它的 instantiate() 方法,不过在这里调用的 instantiate() 是父类 SimpleInstantiationStrategy 的方法.所以我们直接进入父类中查看.
2.6 instantiate()
源码:
@Override
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
// ioc 容器有要覆盖的方法,如果有则使用 CGLIB 策略,否则使用 BeanUtils 实例化
if (bd.getMethodOverrides().isEmpty()) {
// 这里取得指定的构造器或者生成对象的工厂方法对 bean 进行实例化
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
// 获取 BeanDefinition 的构造函数,
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
@Override
public Constructor<?> run() throws Exception {
return clazz.getDeclaredConstructor((Class[]) null);
}
});
}
else {
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
// 通过 beanUtils 进行实例化,这个 beanUtils 的实例化通过 Constructor 来实例化 bean
// 在 beanUtils 中可以看到具体的调用 ctor.newInstance(args)
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
// 使用 CGLIB 来实例化对象
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
这里基本就算要结束了.方法中会根据该类是否有覆盖方法而使用不同的策略,因为基本情况下我们都不会有覆盖方法所以正常情况下都是获取当前 bean 的构造函数,然后初始化.
代码 37 行就是传入构造器,然后 BeanUtils 工具类会将构造函数的访问范围改为 public 最后调用 newInstance() 方法初始化:
ReflectionUtils.makeAccessible(ctor);
return ctor.newInstance(args);
截止目前为止,我们的 bean 就算初始化完毕了.当然光初始化完毕是不够的,我们在 2.3.2 中提到,创建完 bean 是我们需要做依赖注入,将创建的 bean 属性完善,才能供给我们使用.所以我们来简单看一下 spring 是如果进行依赖注入的.
2.7 populateBean()
这个方法实在 bean 初始化完毕后进行属性注入的地方.
源码:
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
// 这里取得在 BeanDefinition 中设置 prototype 值,这些 property 来自对 BeanDefinition 的解析
PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
boolean continueWithPropertyPopulation = true;
// 调用实现了 InstantiationAwareBeanPostProcessor 接口的 postProcessAfterInstantiation 方法
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
// 如果 bean 在创建时设置了 Autowire.BY_TYPE 或 Autowire.BY_NAME (默认是 no)
// 那么会将当前 bean 的所有字段通过 type 或 name 去容器中查找,如果有的话直接复制,不需要通过 @Autowire 注解来注入
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 这里是对 autowire 注入的处理,可以根据 bean 的名字或类型
// 来完成对 bean 的 autowire
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
// 调用实现了 InstantiationAwareBeanPostProcessor 接口的 postProcessPropertyValues 方法
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
// 对属性进行注入,对数据进行解析 然后注入
applyPropertyValues(beanName, mbd, bw, pvs);
}
这里主要注意 39 ~ 55 行处,如果 bean 在创建的时候设置了(如: @Bean(autowire = Autowire.BY_TYPE)) Autowire.BY_TYPE 或 Autowire.BY_NAME , 则会对所有字段进行装配
2.8 initializeBean()
调用 bean 生命周期的一系列方法;
源码:
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
// 这里调用实现了 1.BeanNameAware 2.BeanClassLoaderAware 3.BeanFactoryAware 接口的方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 调用 postProcessBeforeInitialization 的前置处理器
// 这里会调用 ApplicationContextAwareProcessor 的 postProcessBeforeInitialization 方法
// 会调用 EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware 等等
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 调用 bean 的初始化方法,这个初始化方法是在 BeanDefinition 中通过定义 initMethod 属性指定的
// 同时.如果 bean 实现了 InitializationBean 接口,那么这个 bean 的 afterPropertiesSet 实现也会被调用
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 创建 bean 的后置处理器
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
这个方法较为简单,可以很直观的通过注释的看出来每个方法的作用.所以这里也不多说了;
三. 总结
到这里,我们的完整的 Bean 算是创建完成了.主要的流程是:
- 合并完整的 BeanDefinition
- 初始化 bean
- 注入依赖的属性
- 调用生命周期方法
- 返回完整的 bean
不论是简单容器 (DefaultListableBeanFactory) 还是高级容器 (ApplicationContext ) 都是调用 AbstractBeanFactory 的 doGetBean() 来创建完成的 bean .所以我们了解了 bean 的实例化流程,以后再探索高级容器的时候也会方便许多.
再次说明,简单容器只会在第一次调用
getBean的时候初始化需要的 bean, 而高级容器,则会在容器初始化的时候就创建所有未设置lazily属性的bean, 当然,高级容器的不同之处不仅如此,这也是我们后期需要研究探讨的方向.
Spring IOC 源码解析(九) ApplicationContext refresh()