Spring BeanFactory

Author: HuiFer
源码阅读仓库: SourceHot-spring

BeanFactory 概述

org.springframework.beans.factory.BeanFactory

类图

方法列表

贴出部分代码. 仅表示方法作用

publicinterfaceBeanFactory { // 从容器中根据beanname获取ObjectgetBean(Stringname) throwsBeansException; // 延迟加载对象 <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType); // 是否存在beanNamebooleancontainsBean(Stringname); // 这个 beanName 是否是单例的. 映射成 beanbooleanisSingleton(Stringname) throwsNoSuchBeanDefinitionException; // 是否多例.booleanisPrototype(Stringname) throwsNoSuchBeanDefinitionException; // 类型是否匹配booleanisTypeMatch(Stringname, ResolvableTypetypeToMatch) throwsNoSuchBeanDefinitionException; // 获取bean的类型Class<?> getType(Stringname) throwsNoSuchBeanDefinitionException; // 获取别名String[] getAliases(Stringname); }

解析

用例

bean 的实例化有如下几种方法

静态方法
工厂方法创建
FactoryBean 接口创建

代码部分

publicclassUserBean { privateStringname; privateIntegerage; publicstaticUserBeancreateInstance() { UserBeanuserBean = newUserBean(); userBean.setAge(18); userBean.setName("zhangsan"); returnuserBean; } // get set 忽略 }

publicinterfaceUserBeanFactory { UserBeanfactory(); } publicclassUserBeanFactoryImplimplementsUserBeanFactory { @OverridepublicUserBeanfactory() { returnUserBean.createInstance(); } }

publicclassUserFactoryBeanimplementsFactoryBean<UserBean> { @OverridepublicbooleanisSingleton() { returntrue; } @OverridepublicUserBeangetObject() throwsException { returnUserBean.createInstance(); } @OverridepublicClass<?> getObjectType() { returnUserBean.class; } }

<?xml version="1.0" encoding="UTF-8"?> <beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- 静态方法--> <beanid="static-method-user"class="org.source.hot.spring.overview.ioc.bean.init.UserBean"factory-method="createInstance"/> <!-- 工厂方法创建--> <beanid="factory-use"class="org.source.hot.spring.overview.ioc.bean.init.UserBean"factory-bean="userFactory"factory-method="factory"></bean> <!--user 工厂bean--> <beanid="userFactory"class="org.source.hot.spring.overview.ioc.bean.init.UserBeanFactoryImpl"/> <!--factory bean--> <beanid="factory-bean-user"class="org.source.hot.spring.overview.ioc.bean.init.UserFactoryBean"/> </beans>

publicclassSpringBeanInstantiation { publicstaticvoidmain(String[] args) { BeanFactorycontext = newClassPathXmlApplicationContext( "META-INF/beans/spring-bean-instantiation.xml"); UserBeanstaticMethodBean = context.getBean("static-method-user", UserBean.class); UserBeanfactoryUser = context.getBean("factory-use", UserBean.class); UserBeanfactoryBean = context.getBean("factory-bean-user", UserBean.class); System.out.println(); } }

分析

对下面代码进行分析

UserBeanstaticMethodBean = context.getBean("static-method-user", UserBean.class);

org.springframework.context.support.AbstractApplicationContext#getBean(java.lang.String, java.lang.Class<T>)

@Overridepublic <T> TgetBean(Stringname, Class<T> requiredType) throwsBeansException { // 判断 beanFactory 是否存活assertBeanFactoryActive(); // 1. 获取 beanFactory// 2. 根据 beanName + class 获取 BeanreturngetBeanFactory().getBean(name, requiredType); }

从方法参数
- name: beanName
- requiredType: 唯一的类型. 对象类型

assertBeanFactoryActive

beanFactory 是否存活判断

protectedvoidassertBeanFactoryActive() { // 是否存活if (!this.active.get()) { // 是否关闭if (this.closed.get()) { thrownewIllegalStateException(getDisplayName() + " has been closed already"); } else { thrownewIllegalStateException(getDisplayName() + " has not been refreshed yet"); } } }

getBeanFactory

获取 beanFactory

获取方法是一个抽象方法

publicabstractConfigurableListableBeanFactorygetBeanFactory() throwsIllegalStateException;

子类实现

org.springframework.context.support.AbstractRefreshableApplicationContext#getBeanFactory

@OverridepublicfinalConfigurableListableBeanFactorygetBeanFactory() { synchronized (this.beanFactoryMonitor) { if (this.beanFactory == null) { thrownewIllegalStateException("BeanFactory not initialized or already closed - " + "call 'refresh' before accessing beans via the ApplicationContext"); } returnthis.beanFactory; } }

org.springframework.context.support.GenericApplicationContext#getBeanFactory

@OverridepublicfinalConfigurableListableBeanFactorygetBeanFactory() { returnthis.beanFactory; }

获取到的对象是org.springframework.beans.factory.support.DefaultListableBeanFactory

整体类图

doGetBean

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
获取 bean 的核心

transformedBeanName

protectedStringtransformedBeanName(Stringname) { // 转换 beanName .// 1. 通过·BeanFactoryUtils.transformedBeanName· 求beanName// 2. 如果是有别名的(方法参数是别名) . 会从别名列表中获取对应的 beanNamereturncanonicalName(BeanFactoryUtils.transformedBeanName(name)); }

publicstaticStringtransformedBeanName(Stringname) { Assert.notNull(name, "'name' must not be null"); // 名字不是 & 开头直接返回if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) { returnname; } // 截取字符串 在返回returntransformedBeanNameCache.computeIfAbsent(name, beanName -> { do { beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length()); } while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)); returnbeanName; }); }

publicStringcanonicalName(Stringname) { StringcanonicalName = name; // Handle aliasing...StringresolvedName; do { // 别名的获取resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); returncanonicalName; }

别名对象

privatefinalMap<String, String> aliasMap = newConcurrentHashMap<>(16);

<beanid="factory-bean-user"class="org.source.hot.spring.overview.ioc.bean.init.UserFactoryBean"/> <aliasname="factory-bean-user"alias="userFactoryBean"/>

aliasMap 和别名标签的对应关系

alias 标签的 alias 值作为别名的 key ， alias 标签的 name 值作为 value

getSingleton

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String)

@Override@NullablepublicObjectgetSingleton(StringbeanName) { returngetSingleton(beanName, true); }

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)

@NullableprotectedObjectgetSingleton(StringbeanName, booleanallowEarlyReference) { // 尝试从单例缓存中获取ObjectsingletonObject = this.singletonObjects.get(beanName); // 单例对象是否null// 这个 beanName 是否正在创建if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { // 锁synchronized (this.singletonObjects) { // 从延迟加载的map中获取singletonObject = this.earlySingletonObjects.get(beanName); // 对象是否空 ， 是否允许提前应用if (singletonObject == null && allowEarlyReference) { // 从对象工厂map中获取对象工厂ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { // 对象获取后设置singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } returnsingletonObject; }

相关属性值

/** * Cache of singleton objects: bean name to bean instance. * * 单例对象容器, key: beanName , value: bean实例 * */privatefinalMap<String, Object> singletonObjects = newConcurrentHashMap<>(256); /** * Cache of singleton factories: bean name to ObjectFactory. * key: beanName * value: 对象工厂 * */privatefinalMap<String, ObjectFactory<?>> singletonFactories = newHashMap<>(16); /** * Names of beans that are currently in creation. * * 当前正在实例化的beanName * * */privatefinalSet<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(newConcurrentHashMap<>(16));

getObjectForBeanInstance

org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance

protectedObjectgetObjectForBeanInstance( ObjectbeanInstance, Stringname, StringbeanName, @NullableRootBeanDefinitionmbd) { // Don't let calling code try to dereference the factory if the bean isn't a factory.// 判断 beanName 是不是 bean 工厂if (BeanFactoryUtils.isFactoryDereference(name)) { // 类型判断if (beanInstanceinstanceofNullBean) { returnbeanInstance; } if (!(beanInstanceinstanceofFactoryBean)) { thrownewBeanIsNotAFactoryException(beanName, beanInstance.getClass()); } if (mbd != null) { mbd.isFactoryBean = true; } // 返回实例returnbeanInstance; } // Now we have the bean instance, which may be a normal bean or a FactoryBean.// If it's a FactoryBean, we use it to create a bean instance, unless the// caller actually wants a reference to the factory.// 判断是否是 factoryBeanif (!(beanInstanceinstanceofFactoryBean)) { returnbeanInstance; } Objectobject = null; if (mbd != null) { mbd.isFactoryBean = true; } else { // 缓存中获取object = getCachedObjectForFactoryBean(beanName); } if (object == null) { // Return bean instance from factory.// 如果还是 null 从 factory bean 中创建FactoryBean<?> factory = (FactoryBean<?>) beanInstance; // Caches object obtained from FactoryBean if it is a singleton.if (mbd == null && containsBeanDefinition(beanName)) { mbd = getMergedLocalBeanDefinition(beanName); } booleansynthetic = (mbd != null && mbd.isSynthetic()); // 从 FactoryBean 中获取bean实例object = getObjectFromFactoryBean(factory, beanName, !synthetic); } returnobject; }

getObjectFromFactoryBean

org.springframework.beans.factory.support.FactoryBeanRegistrySupport#getObjectFromFactoryBean
从 FactoryBean 中获取对象

protectedObjectgetObjectFromFactoryBean(FactoryBean<?> factory, StringbeanName, booleanshouldPostProcess) { // 是否单例 是否已经包含if (factory.isSingleton() && containsSingleton(beanName)) { synchronized (getSingletonMutex()) { // 从工厂bean的缓存中获取Objectobject = this.factoryBeanObjectCache.get(beanName); if (object == null) { // 从 factoryBean 接口中获取object = doGetObjectFromFactoryBean(factory, beanName); // Only post-process and store if not put there already during getObject() call above// (e.g. because of circular reference processing triggered by custom getBean calls)// 从缓存map中获取ObjectalreadyThere = this.factoryBeanObjectCache.get(beanName); if (alreadyThere != null) { // 如果缓存中获取有值// object 覆盖object = alreadyThere; } else { if (shouldPostProcess) { if (isSingletonCurrentlyInCreation(beanName)) { // Temporarily return non-post-processed object, not storing it yet..returnobject; } // 单例创建前的验证beforeSingletonCreation(beanName); try { // 从 FactoryBean 接口创建的 后置处理object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwableex) { thrownewBeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", ex); } finally { // 单例bean创建之后afterSingletonCreation(beanName); } } // 是否包含bean nameif (containsSingleton(beanName)) { // 插入缓存// 后续使用的时候可以直接获取this.factoryBeanObjectCache.put(beanName, object); } } } returnobject; } } else { Objectobject = doGetObjectFromFactoryBean(factory, beanName); if (shouldPostProcess) { try { object = postProcessObjectFromFactoryBean(object, beanName); } catch (Throwableex) { thrownewBeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex); } } returnobject; } }

beforeSingletonCreation

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#beforeSingletonCreation
单例创建前的验证

protectedvoidbeforeSingletonCreation(StringbeanName) { // 排除的单例beanName 是否包含当前beanName// 添加当前正在初始化的beanName 是否正确if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { thrownewBeanCurrentlyInCreationException(beanName); } }

postProcessObjectFromFactoryBean

两种实现

org.springframework.beans.factory.support.FactoryBeanRegistrySupport#postProcessObjectFromFactoryBean

protectedObjectpostProcessObjectFromFactoryBean(Objectobject, StringbeanName) throwsBeansException { returnobject; }

直接返回 object

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#postProcessObjectFromFactoryBean 调用 BeanPostProcessor

@OverrideprotectedObjectpostProcessObjectFromFactoryBean(Objectobject, StringbeanName) { returnapplyBeanPostProcessorsAfterInitialization(object, beanName); } @OverridepublicObjectapplyBeanPostProcessorsAfterInitialization(ObjectexistingBean, StringbeanName) throwsBeansException { Objectresult = existingBean; for (BeanPostProcessorprocessor : getBeanPostProcessors()) { Objectcurrent = processor.postProcessAfterInitialization(result, beanName); if (current == null) { returnresult; } result = current; } returnresult; }

两个方法军返回 Bean 对象 . 一种是直接返回。另一种是执行接口 BeanPostProcessor 接口返回

afterSingletonCreation

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#afterSingletonCreation

protectedvoidafterSingletonCreation(StringbeanName) { // 排除的单例beanName 是否包含当前beanName// 移除当前正在初始化的beanName 是否正确if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { thrownewIllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); } }

代码现在进入的很深了，回到 doGetBean
org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

protected <T> TdoGetBean(finalStringname, @NullablefinalClass<T> requiredType, @NullablefinalObject[] args, booleantypeCheckOnly) throwsBeansException { // 转换beanNamefinalStringbeanName = transformedBeanName(name); Objectbean; // Eagerly check singleton cache for manually registered singletons.// 获取单例对象ObjectsharedInstance = 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 + "'"); } } // 实例化beanbean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } // 省略后续内容 }

目前未知doGetBean的第一个if分支已经分析完毕. 接下来看下面的代码
下面这段代码就简单说一下就跳过了。
- 从容器中获取，最后还是回到 doGetBean 方法中. 来进行 bean 创建这里不进行展开。

else { // Fail if we're already creating this bean instance:// We're assumably within a circular reference.// 循环依赖的问题if (isPrototypeCurrentlyInCreation(beanName)) { thrownewBeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory.BeanFactoryparentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent.StringnameToLookup = originalBeanName(name); if (parentBeanFactoryinstanceofAbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } elseif (args != null) { // Delegation to parent with explicit args.return (T) parentBeanFactory.getBean(nameToLookup, args); } elseif (requiredType != null) { // No args -> delegate to standard getBean method.returnparentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } }

markBeanAsCreated

org.springframework.beans.factory.support.AbstractBeanFactory#markBeanAsCreated
方法作用将 bean 标记为已创建

protected void markBeanAsCreated(String beanName) { // 已创建的beanName 是否包含当前beanName if (!this.alreadyCreated.contains(beanName)) { synchronized (this.mergedBeanDefinitions) { if (!this.alreadyCreated.contains(beanName)) { // Let the bean definition get re-merged now that we're actually creating // the bean... just in case some of its metadata changed in the meantime. // 将属性stale设置true clearMergedBeanDefinition(beanName); // 放入已创建集合中 this.alreadyCreated.add(beanName); } } } }

protectedvoidclearMergedBeanDefinition(StringbeanName) { RootBeanDefinitionbd = this.mergedBeanDefinitions.get(beanName); if (bd != null) { bd.stale = true; } }

stale 的解释

/** * Determines if the definition needs to be re-merged. * 是否需要重新合并定义 * */volatilebooleanstale;

属性值已创建的 beanName

privatefinalSet<String> alreadyCreated = Collections.newSetFromMap(newConcurrentHashMap<>(256));

getMergedLocalBeanDefinition

org.springframework.beans.factory.support.AbstractBeanFactory#getMergedLocalBeanDefinition
这个方法获取一个RootBeanDefinition对象，这个对象也是 bean 的一种定义。
从目前的几个方法名称来看，暂且认为这是一个合并了多个 BeanDefinition的对象吧

protectedRootBeanDefinitiongetMergedLocalBeanDefinition(StringbeanName) throwsBeansException { // Quick check on the concurrent map first, with minimal locking.// 缓存中获取RootBeanDefinitionmbd = this.mergedBeanDefinitions.get(beanName); if (mbd != null && !mbd.stale) { returnmbd; } // 合并的 bean 定义returngetMergedBeanDefinition(beanName, getBeanDefinition(beanName)); } protectedRootBeanDefinitiongetMergedBeanDefinition(StringbeanName, BeanDefinitionbd) throwsBeanDefinitionStoreException { returngetMergedBeanDefinition(beanName, bd, null); }

getBeanDefinition

获取 beanDefinition
org.springframework.beans.factory.support.DefaultListableBeanFactory#getBeanDefinition

@OverridepublicBeanDefinitiongetBeanDefinition(StringbeanName) throwsNoSuchBeanDefinitionException { BeanDefinitionbd = this.beanDefinitionMap.get(beanName); if (bd == null) { if (logger.isTraceEnabled()) { logger.trace("No bean named '" + beanName + "' found in " + this); } thrownewNoSuchBeanDefinitionException(beanName); } returnbd; }

从 beanDefinition map 中获取

getMergedBeanDefinition

获取RootBeanDefinition
org.springframework.beans.factory.support.AbstractBeanFactory#getMergedBeanDefinition(java.lang.String, org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.config.BeanDefinition)
第一部分代码
- map 中获取 RootBeanDefinition
- 是否存在父名称
- 类型是否是 RootBeanDefinition
  - 是: 拷贝
  - 否: 将 BeanDefinition 转换成 RootBeanDefinition

protectedRootBeanDefinitiongetMergedBeanDefinition( StringbeanName, BeanDefinitionbd, @NullableBeanDefinitioncontainingBd) throwsBeanDefinitionStoreException { synchronized (this.mergedBeanDefinitions) { RootBeanDefinitionmbd = null; RootBeanDefinitionprevious = null; // Check with full lock now in order to enforce the same merged instance.if (containingBd == null) { // 从缓存中获取mbd = this.mergedBeanDefinitions.get(beanName); } if (mbd == null || mbd.stale) { previous = mbd; // 是否存在父名称if (bd.getParentName() == null) { // Use copy of given root bean definition.// 类型是否等于RootBeanDefinitionif (bdinstanceofRootBeanDefinition) { // 做一次对象拷贝mbd = ((RootBeanDefinition) bd).cloneBeanDefinition(); } else { // 将 beanDefinition 创建成 RootBeanDefinitionmbd = newRootBeanDefinition(bd); } } // 省略其他 }

overrideFrom

覆盖方法
org.springframework.beans.factory.support.AbstractBeanDefinition#overrideFrom
最后一段

// Set default singleton scope, if not configured before.// 作用域设置if (!StringUtils.hasLength(mbd.getScope())) { // 没有设置作用域直接给单例类型mbd.setScope(SCOPE_SINGLETON); } // A bean contained in a non-singleton bean cannot be a singleton itself.// Let's correct this on the fly here, since this might be the result of// parent-child merging for the outer bean, in which case the original inner bean// definition will not have inherited the merged outer bean's singleton status.// 修正 作用域if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) { mbd.setScope(containingBd.getScope()); } // Cache the merged bean definition for the time being// (it might still get re-merged later on in order to pick up metadata changes)if (containingBd == null && isCacheBeanMetadata()) { // 放入缓存this.mergedBeanDefinitions.put(beanName, mbd); } } if (previous != null) { copyRelevantMergedBeanDefinitionCaches(previous, mbd); } returnmbd;

checkMergedBeanDefinition

org.springframework.beans.factory.support.AbstractBeanFactory#checkMergedBeanDefinition

protectedvoidcheckMergedBeanDefinition(RootBeanDefinitionmbd, StringbeanName, @NullableObject[] args) throwsBeanDefinitionStoreException { if (mbd.isAbstract()) { thrownewBeanIsAbstractException(beanName); } }

判断是否 abstract 标记的情况

继续回到 doGetBean 方法

// 需要依赖的beanString[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (Stringdep : dependsOn) { if (isDependent(beanName, dep)) { thrownewBeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } // 注册依赖beanregisterDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionExceptionex) { thrownewBeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } }

isDependent

是否存在依赖关系
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#isDependent(java.lang.String, java.lang.String, java.util.Set<java.lang.String>)

privatebooleanisDependent(StringbeanName, StringdependentBeanName, @NullableSet<String> alreadySeen) { if (alreadySeen != null && alreadySeen.contains(beanName)) { returnfalse; } // 别名StringcanonicalName = canonicalName(beanName); // 依赖列表中获取Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName); if (dependentBeans == null) { returnfalse; } if (dependentBeans.contains(dependentBeanName)) { returntrue; } for (StringtransitiveDependency : dependentBeans) { if (alreadySeen == null) { alreadySeen = newHashSet<>(); } alreadySeen.add(beanName); if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) { returntrue; } } returnfalse; }

registerDependentBean

注册依赖关系
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#registerDependentBean
- 在前文调用 isDependent 方法的的时候我们找到了一个依赖映射dependentBeanMap ，在这个方法中会将依赖关系放入dependentBeanMap

publicvoidregisterDependentBean(StringbeanName, StringdependentBeanName) { // 别名StringcanonicalName = canonicalName(beanName); synchronized (this.dependentBeanMap) { // 向依赖关系中放入数据Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName, k -> newLinkedHashSet<>(8)); if (!dependentBeans.add(dependentBeanName)) { return; } } synchronized (this.dependenciesForBeanMap) { Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> newLinkedHashSet<>(8)); dependenciesForBean.add(canonicalName); } }

再回到 doGetBean
接下来就是实例化的过程了.

if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { returncreateBean(beanName, mbd, args); } catch (BeansExceptionex) { // 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); throwex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); }

getSingleton

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)
获取单例对象
1. 从单例对象的 map 缓存中获取
2. 从 ObjectFactory 中获取
周边方法
- beforeSingletonCreation
- afterSingletonCreation
- addSingleton

publicObjectgetSingleton(StringbeanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { // 从单例对象缓存中获取ObjectsingletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { if (this.singletonsCurrentlyInDestruction) { thrownewBeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); } // 单例创建前的验证beforeSingletonCreation(beanName); booleannewSingleton = false; booleanrecordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = newLinkedHashSet<>(); } try { // 从 ObjectFactory 中获取singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateExceptionex) { // Has the singleton object implicitly appeared in the meantime ->// if yes, proceed with it since the exception indicates that state.singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { throwex; } } catch (BeanCreationExceptionex) { if (recordSuppressedExceptions) { for (ExceptionsuppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throwex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } // 创建单例对象后的验证afterSingletonCreation(beanName); } if (newSingleton) { // 添加到 单例容器中addSingleton(beanName, singletonObject); } } returnsingletonObject; } }

回到 doGetBean 方法中

if (mbd.isSingleton()) { // 判断是否是单例sharedInstance = getSingleton(beanName, () -> { try { returncreateBean(beanName, mbd, args); } catch (BeansExceptionex) { // 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); throwex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); }

这里又要给 createBean方法，从 getSingleton 的参数看可以知道，第二个匿名函数是ObjectFactory接口实现.

@FunctionalInterfacepublicinterfaceObjectFactory<T> { /** * Return an instance (possibly shared or independent) * of the object managed by this factory. * 获取对象 * @return the resulting instance * @throws BeansException in case of creation errors */TgetObject() throwsBeansException; }

createBean 返回的就是单例 bean 对象的实例

createBean

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
两个核心方法

// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.Objectbean = resolveBeforeInstantiation(beanName, mbdToUse); ObjectbeanInstance = doCreateBean(beanName, mbdToUse, args);

resolveBeforeInstantiation

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
方法概述:
获取BeanPostProcessor接口的实现列表
- applyBeanPostProcessorsBeforeInstantiation 前置方法执行
- applyBeanPostProcessorsAfterInitialization后置方法执行

@NullableprotectedObjectresolveBeforeInstantiation(StringbeanName, RootBeanDefinitionmbd) { Objectbean = 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) { /** * 主要实现{@link org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation(java.lang.Class, java.lang.String)} */bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } mbd.beforeInstantiationResolved = (bean != null); } returnbean; }

doCreateBean

创建 bean
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

// Instantiate the bean.BeanWrapperinstanceWrapper = null; if (mbd.isSingleton()) { // beanFactory 移除当前创建的beanNameinstanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } // beanWrapper 是否存在if (instanceWrapper == null) { // 创建 bean 实例instanceWrapper = createBeanInstance(beanName, mbd, args); }

createBeanInstance

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
创建 bean 实例

protectedBeanWrappercreateBeanInstance(StringbeanName, RootBeanDefinitionmbd, @NullableObject[] args) { // Make sure bean class is actually resolved at this point.// 获取 bean classClass<?> beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { thrownewBeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName() ); } // 返回一个用来创建bean实例的回调接口// Supplier get 直接获取bean对象Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { returnobtainFromSupplier(instanceSupplier, beanName); } if (mbd.getFactoryMethodName() != null) { // 通过工厂方法创建returninstantiateUsingFactoryMethod(beanName, mbd, args); } // Shortcut when re-creating the same bean...booleanresolved = false; booleanautowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } if (resolved) { if (autowireNecessary) { // 自动构造 beanreturnautowireConstructor(beanName, mbd, null, null); } else { // 实例化beanreturninstantiateBean(beanName, mbd); } } // Candidate constructors for autowiring?Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { returnautowireConstructor(beanName, mbd, ctors, args); } // Preferred constructors for default construction?ctors = mbd.getPreferredConstructors(); if (ctors != null) { returnautowireConstructor(beanName, mbd, ctors, null); } // No special handling: simply use no-arg constructor.returninstantiateBean(beanName, mbd); }

resolveBeanClass

org.springframework.beans.factory.support.AbstractBeanFactory#resolveBeanClass
获取 bean 的 class

@NullableprotectedClass<?> resolveBeanClass(finalRootBeanDefinitionmbd, StringbeanName, finalClass<?>... typesToMatch) throwsCannotLoadBeanClassException { try { // 是否包含 bean 类型if (mbd.hasBeanClass()) { // 直接返回returnmbd.getBeanClass(); } if (System.getSecurityManager() != null) { returnAccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext()); } else { // 从 bean definition 中获取returndoResolveBeanClass(mbd, typesToMatch); } } catch (PrivilegedActionExceptionpae) { ClassNotFoundExceptionex = (ClassNotFoundException) pae.getException(); thrownewCannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex); } catch (ClassNotFoundExceptionex) { thrownewCannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex); } catch (LinkageErrorerr) { thrownewCannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err); } }

doResolveBeanClass

org.springframework.beans.factory.support.AbstractBeanFactory#doResolveBeanClass

第一段

ClassLoaderbeanClassLoader = getBeanClassLoader(); ClassLoaderdynamicLoader = beanClassLoader; booleanfreshResolve = false; // 判断 typesToMatch 是否为空if (!ObjectUtils.isEmpty(typesToMatch)) { // When just doing type checks (i.e. not creating an actual instance yet),// use the specified temporary class loader (e.g. in a weaving scenario).// 获取临时类加载器ClassLoadertempClassLoader = getTempClassLoader(); if (tempClassLoader != null) { dynamicLoader = tempClassLoader; freshResolve = true; // 类型比较if (tempClassLoaderinstanceofDecoratingClassLoader) { DecoratingClassLoaderdcl = (DecoratingClassLoader) tempClassLoader; for (Class<?> typeToMatch : typesToMatch) { // 添加排除的类dcl.excludeClass(typeToMatch.getName()); } } } }

第二段

if (className != null) { // bean 属性值Objectevaluated = evaluateBeanDefinitionString(className, mbd); if (!className.equals(evaluated)) { // A dynamically resolved expression, supported as of 4.2...if (evaluatedinstanceofClass) { return (Class<?>) evaluated; } elseif (evaluatedinstanceofString) { className = (String) evaluated; freshResolve = true; } else { thrownewIllegalStateException("Invalid class name expression result: " + evaluated); } }

evaluateBeanDefinitionString

@NullableprotectedObjectevaluateBeanDefinitionString(@NullableStringvalue, @NullableBeanDefinitionbeanDefinition) { // 占位符解析if (this.beanExpressionResolver == null) { returnvalue; } Scopescope = null; if (beanDefinition != null) { // 获取 scopeStringscopeName = beanDefinition.getScope(); if (scopeName != null) { // scope 转换成 接口值scope = getRegisteredScope(scopeName); } } // 返回对象returnthis.beanExpressionResolver.evaluate(value, newBeanExpressionContext(this, scope)); }

evaluate

org.springframework.context.expression.StandardBeanExpressionResolver#evaluate

@Override@NullablepublicObjectevaluate(@NullableStringvalue, BeanExpressionContextevalContext) throwsBeansException { if (!StringUtils.hasLength(value)) { returnvalue; } try { Expressionexpr = this.expressionCache.get(value); if (expr == null) { // el表达式解析expr = this.expressionParser.parseExpression(value, this.beanExpressionParserContext); // 解析结果放入缓存this.expressionCache.put(value, expr); } // spring 中默认的表达式上下文StandardEvaluationContextsec = this.evaluationCache.get(evalContext); if (sec == null) { // 设置属性sec = newStandardEvaluationContext(evalContext); sec.addPropertyAccessor(newBeanExpressionContextAccessor()); sec.addPropertyAccessor(newBeanFactoryAccessor()); sec.addPropertyAccessor(newMapAccessor()); sec.addPropertyAccessor(newEnvironmentAccessor()); sec.setBeanResolver(newBeanFactoryResolver(evalContext.getBeanFactory())); sec.setTypeLocator(newStandardTypeLocator(evalContext.getBeanFactory().getBeanClassLoader())); ConversionServiceconversionService = evalContext.getBeanFactory().getConversionService(); if (conversionService != null) { sec.setTypeConverter(newStandardTypeConverter(conversionService)); } customizeEvaluationContext(sec); this.evaluationCache.put(evalContext, sec); } // 把值获取returnexpr.getValue(sec); } catch (Throwableex) { thrownewBeanExpressionException("Expression parsing failed", ex); } }

类图

BeanExpressionContext

两个属性

privatefinalConfigurableBeanFactorybeanFactory; @NullableprivatefinalScopescope;

几个方法

publicbooleancontainsObject(Stringkey) { return (this.beanFactory.containsBean(key) || (this.scope != null && this.scope.resolveContextualObject(key) != null)); } @NullablepublicObjectgetObject(Stringkey) { if (this.beanFactory.containsBean(key)) { returnthis.beanFactory.getBean(key); } elseif (this.scope != null) { returnthis.scope.resolveContextualObject(key); } else { returnnull; } }

beanName 是否存在

根据 beanName 获取 bean 实例

回到解析方法

parseExpression

@OverridepublicExpressionparseExpression(StringexpressionString, @NullableParserContextcontext) throwsParseException { if (context != null && context.isTemplate()) { // 是否使用 template 解析returnparseTemplate(expressionString, context); } else { // 自定义的解析规则returndoParseExpression(expressionString, context); } }

doParseExpression
- spring 中的两种解析方式
  - org.springframework.expression.spel.standard.InternalSpelExpressionParser#doParseExpression
  - org.springframework.expression.spel.standard.SpelExpressionParser#doParseExpression
parseTemplate 方法
- org.springframework.expression.common.TemplateAwareExpressionParser#parseTemplate

privateExpressionparseTemplate(StringexpressionString, ParserContextcontext) throwsParseException { // 表达式为空if (expressionString.isEmpty()) { // 创建空的 LiteralExpressionreturnnewLiteralExpression(""); } // 表达式解析成接口Expression[] expressions = parseExpressions(expressionString, context); if (expressions.length == 1) { returnexpressions[0]; } else { // 返回字符串的表达式returnnewCompositeStringExpression(expressionString, expressions); } }

parseExpressions
- org.springframework.expression.common.TemplateAwareExpressionParser#parseExpressions
- 说简单一些这个地方就是拿出表达式的值
回到 evaluate 方法

StandardEvaluationContextsec = this.evaluationCache.get(evalContext); if (sec == null) { // 设置属性sec = newStandardEvaluationContext(evalContext); sec.addPropertyAccessor(newBeanExpressionContextAccessor()); sec.addPropertyAccessor(newBeanFactoryAccessor()); sec.addPropertyAccessor(newMapAccessor()); sec.addPropertyAccessor(newEnvironmentAccessor()); sec.setBeanResolver(newBeanFactoryResolver(evalContext.getBeanFactory())); sec.setTypeLocator(newStandardTypeLocator(evalContext.getBeanFactory().getBeanClassLoader())); ConversionServiceconversionService = evalContext.getBeanFactory().getConversionService(); if (conversionService != null) { sec.setTypeConverter(newStandardTypeConverter(conversionService)); } customizeEvaluationContext(sec); this.evaluationCache.put(evalContext, sec); } // 把值获取returnexpr.getValue(sec);

最后一句 getValue
- org.springframework.expression.common.LiteralExpression#getValue(org.springframework.expression.EvaluationContext)
  刚才流程中我们可以看到 expr 是LiteralExpression
```
@OverridepublicStringgetValue(EvaluationContextcontext) { returnthis.literalValue; }
```
  直接返回字符串. 这个字符串就是刚才放进去的 el 表达式

往外跳找到方法 doResolveBeanClass

if (className != null) { // bean 属性值Objectevaluated = evaluateBeanDefinitionString(className, mbd); if (!className.equals(evaluated)) { // A dynamically resolved expression, supported as of 4.2...if (evaluatedinstanceofClass) { return (Class<?>) evaluated; } elseif (evaluatedinstanceofString) { className = (String) evaluated; freshResolve = true; } else { thrownewIllegalStateException("Invalid class name expression result: " + evaluated); } } if (freshResolve) { // When resolving against a temporary class loader, exit early in order// to avoid storing the resolved Class in the bean definition.if (dynamicLoader != null) { try { returndynamicLoader.loadClass(className); } catch (ClassNotFoundExceptionex) { if (logger.isTraceEnabled()) { logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex); } } } returnClassUtils.forName(className, dynamicLoader); } }

目前为止我们解析了第一句话 Object evaluated = evaluateBeanDefinitionString(className, mbd); 接下来往下走看一下具体的 class 返回对象

类型等于 class 直接返回
类型等于 String 的两种返回方式
1. ClassLoader.loadClass 返回
2. ClassUtils.forName 返回
  1. 底层方法为 java.lang.Class#forName(java.lang.String, boolean, java.lang.ClassLoader)

resolveBeanClass

回到doResolveBeanClass方法中.最后一行

// Resolve regularly, caching the result in the BeanDefinition...returnmbd.resolveBeanClass(beanClassLoader);

@NullablepublicClass<?> resolveBeanClass(@NullableClassLoaderclassLoader) throwsClassNotFoundException { // 获取beanClassNameStringclassName = getBeanClassName(); if (className == null) { returnnull; } // 加载类Class<?> resolvedClass = ClassUtils.forName(className, classLoader); this.beanClass = resolvedClass; // 返回returnresolvedClass; }

获取 beanClassName

@Override@NullablepublicStringgetBeanClassName() { ObjectbeanClassObject = this.beanClass; if (beanClassObjectinstanceofClass) { return ((Class<?>) beanClassObject).getName(); } else { return (String) beanClassObject; } }

回到createBeanInstance
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance

// 返回一个用来创建bean实例的回调接口// Supplier get 直接获取bean对象Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { returnobtainFromSupplier(instanceSupplier, beanName); }

obtainFromSupplier

protectedBeanWrapperobtainFromSupplier(Supplier<?> instanceSupplier, StringbeanName) { Objectinstance; // 获取当前的bean实例StringouterBean = this.currentlyCreatedBean.get(); // 设置当前处理的beanNamethis.currentlyCreatedBean.set(beanName); try { // 从 Supplier 中获取instance = instanceSupplier.get(); } finally { if (outerBean != null) { // 如果 currentlyCreatedBean 取不到设置this.currentlyCreatedBean.set(outerBean); } else { // 移除this.currentlyCreatedBean.remove(); } } if (instance == null) { // supplier 中获取不到, 将实例设置为 NullBeaninstance = newNullBean(); } // beanWrapper 包装BeanWrapperbw = newBeanWrapperImpl(instance); // beanWrapper 实例化后的操作initBeanWrapper(bw); returnbw; }

Supplier 代码如下

@FunctionalInterfacepublicinterfaceSupplier<T> { /** * Gets a result. * * @return a result */Tget(); }

initBeanWrapper

protectedvoidinitBeanWrapper(BeanWrapperbw) { // 设置转换服务bw.setConversionService(getConversionService()); // 注册自定义属性编辑器registerCustomEditors(bw); }

registerCustomEditors

protectedvoidregisterCustomEditors(PropertyEditorRegistryregistry) { PropertyEditorRegistrySupportregistrySupport = (registryinstanceofPropertyEditorRegistrySupport ? (PropertyEditorRegistrySupport) registry : null); if (registrySupport != null) { registrySupport.useConfigValueEditors(); } if (!this.propertyEditorRegistrars.isEmpty()) { for (PropertyEditorRegistrarregistrar : this.propertyEditorRegistrars) { try { // 属性编辑器,注册自定义属性编辑器registrar.registerCustomEditors(registry); } catch (BeanCreationExceptionex) { ThrowablerootCause = ex.getMostSpecificCause(); if (rootCauseinstanceofBeanCurrentlyInCreationException) { BeanCreationExceptionbce = (BeanCreationException) rootCause; StringbceBeanName = bce.getBeanName(); if (bceBeanName != null && isCurrentlyInCreation(bceBeanName)) { if (logger.isDebugEnabled()) { logger.debug("PropertyEditorRegistrar [" + registrar.getClass().getName() + "] failed because it tried to obtain currently created bean '" + ex.getBeanName() + "': " + ex.getMessage()); } onSuppressedException(ex); continue; } } throwex; } } } if (!this.customEditors.isEmpty()) { this.customEditors.forEach((requiredType, editorClass) -> registry.registerCustomEditor(requiredType, BeanUtils.instantiateClass(editorClass))); } }

最后调用
org.springframework.beans.support.ResourceEditorRegistrar#registerCustomEditors

registerCustomEditors

@OverridepublicvoidregisterCustomEditors(PropertyEditorRegistryregistry) { ResourceEditorbaseEditor = newResourceEditor(this.resourceLoader, this.propertyResolver); doRegisterEditor(registry, Resource.class, baseEditor); doRegisterEditor(registry, ContextResource.class, baseEditor); doRegisterEditor(registry, InputStream.class, newInputStreamEditor(baseEditor)); doRegisterEditor(registry, InputSource.class, newInputSourceEditor(baseEditor)); doRegisterEditor(registry, File.class, newFileEditor(baseEditor)); doRegisterEditor(registry, Path.class, newPathEditor(baseEditor)); doRegisterEditor(registry, Reader.class, newReaderEditor(baseEditor)); doRegisterEditor(registry, URL.class, newURLEditor(baseEditor)); ClassLoaderclassLoader = this.resourceLoader.getClassLoader(); doRegisterEditor(registry, URI.class, newURIEditor(classLoader)); doRegisterEditor(registry, Class.class, newClassEditor(classLoader)); doRegisterEditor(registry, Class[].class, newClassArrayEditor(classLoader)); if (this.resourceLoaderinstanceofResourcePatternResolver) { doRegisterEditor(registry, Resource[].class, newResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader, this.propertyResolver)); } }

doRegisterEditor

privatevoiddoRegisterEditor(PropertyEditorRegistryregistry, Class<?> requiredType, PropertyEditoreditor) { if (registryinstanceofPropertyEditorRegistrySupport) { // 属性编辑器覆盖默认的编辑器 ((PropertyEditorRegistrySupport) registry).overrideDefaultEditor(requiredType, editor); } else { // 注册自定义的属性编辑器registry.registerCustomEditor(requiredType, editor); } }

覆盖默认编辑器

publicvoidoverrideDefaultEditor(Class<?> requiredType, PropertyEditorpropertyEditor) { if (this.overriddenDefaultEditors == null) { this.overriddenDefaultEditors = newHashMap<>(); } this.overriddenDefaultEditors.put(requiredType, propertyEditor); }

registerCustomEditor

@OverridepublicvoidregisterCustomEditor(@NullableClass<?> requiredType, @NullableStringpropertyPath, PropertyEditorpropertyEditor) { if (requiredType == null && propertyPath == null) { thrownewIllegalArgumentException("Either requiredType or propertyPath is required"); } if (propertyPath != null) { if (this.customEditorsForPath == null) { this.customEditorsForPath = newLinkedHashMap<>(16); } this.customEditorsForPath.put(propertyPath, newCustomEditorHolder(propertyEditor, requiredType)); } else { if (this.customEditors == null) { this.customEditors = newLinkedHashMap<>(16); } // 放入 customEditors map对象中this.customEditors.put(requiredType, propertyEditor); this.customEditorCache = null; } }

到这里 createBeanInstance 流程已经完毕

回到doCreateBean 方法

// beanWrapper 是否存在if (instanceWrapper == null) { // 创建 bean 实例instanceWrapper = createBeanInstance(beanName, mbd, args); } // 获取 实例finalObjectbean = instanceWrapper.getWrappedInstance(); // beanWrapper中存储的实例.classClass<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; }

紧接着两行代码获取 bean 实例和 beanType

applyMergedBeanDefinitionPostProcessors

synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { // 后置方法执行 BeanPostProcessorapplyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwableex) { thrownewBeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex ); } mbd.postProcessed = true; } }

applyMergedBeanDefinitionPostProcessors 方法会执行所有的后置方法.

protectedvoidapplyMergedBeanDefinitionPostProcessors(RootBeanDefinitionmbd, Class<?> beanType, StringbeanName) { for (BeanPostProcessorbp : getBeanPostProcessors()) { if (bpinstanceofMergedBeanDefinitionPostProcessor) { MergedBeanDefinitionPostProcessorbdp = (MergedBeanDefinitionPostProcessor) bp; bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName); } } }

addSingletonFactory

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory
继续回到 doCreateBean

// Eagerly cache singletons to be able to resolve circular references// even when triggered by lifecycle interfaces like BeanFactoryAware.booleanearlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); // 单例对象暴露if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); }

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory
添加单例工厂

protectedvoidaddSingletonFactory(StringbeanName, ObjectFactory<?> singletonFactory) { Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { // 添加单例对象工厂this.singletonFactories.put(beanName, singletonFactory); // 删除单例BeanNamethis.earlySingletonObjects.remove(beanName); // 注册单例beanNamethis.registeredSingletons.add(beanName); } } }

getEarlyBeanReference

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference

@OverridepublicObjectgetEarlyBeanReference(Objectbean, StringbeanName) { // 尝试获取缓存ObjectcacheKey = getCacheKey(bean.getClass(), beanName); // 加入缓存this.earlyProxyReferences.put(cacheKey, bean); // 代理对象returnwrapIfNecessary(bean, beanName, cacheKey); }

wrapIfNecessary

protectedObjectwrapIfNecessary(Objectbean, StringbeanName, ObjectcacheKey) { // 这个bean是否处理过if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) { returnbean; } // 这个bean是否需要代理if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) { returnbean; } // 1.bean.class是否是Spring接口类型 2. 是否为 AutowireCapableBeanFactory 接口if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) { // 向代理集合中插入值this.advisedBeans.put(cacheKey, Boolean.FALSE); returnbean; } // Create proxy if we have advice.// 增强方法获取Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); // 增强方法不为空if (specificInterceptors != DO_NOT_PROXY) { // 向代理集合中插入值this.advisedBeans.put(cacheKey, Boolean.TRUE); // 创建代理Objectproxy = createProxy( bean.getClass(), beanName, specificInterceptors, newSingletonTargetSource(bean)); // 代理类型this.proxyTypes.put(cacheKey, proxy.getClass()); returnproxy; } this.advisedBeans.put(cacheKey, Boolean.FALSE); returnbean; }

回到下面代码中

if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // 添加单例工厂addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); }

上述方法就是将结果 bean 放入

populateBean

// Initialize the bean instance.ObjectexposedObject = bean; try { populateBean(beanName, mbd, instanceWrapper); exposedObject = initializeBean(beanName, exposedObject, mbd); }

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
设置属性值

概述一下方法

自动注入的两种实现
1. 根据类型
2. 根据名称

xml 中的属性标签设置

<beanclass="org.source.hot.spring.overview.ioc.bean.init.UserBean"> <propertyname="age"value="30"/> </bean>

{ if (bw == null) { if (mbd.hasPropertyValues()) { thrownewBeanCreationException( 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.if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessorbp : getBeanPostProcessors()) { if (bpinstanceofInstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessoribp = (InstantiationAwareBeanPostProcessor) bp; if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { return; } } } } PropertyValuespvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); // 获取自动注入的值intresolvedAutowireMode = mbd.getResolvedAutowireMode(); // 自动注入if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { MutablePropertyValuesnewPvs = newMutablePropertyValues(pvs); // Add property values based on autowire by name if applicable.if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { // 按照名称注入autowireByName(beanName, mbd, bw, newPvs); } // Add property values based on autowire by type if applicable.if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { // 按照类型注入autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } booleanhasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); booleanneedsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); PropertyDescriptor[] filteredPds = null; if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } for (BeanPostProcessorbp : getBeanPostProcessors()) { if (bpinstanceofInstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessoribp = (InstantiationAwareBeanPostProcessor) bp; PropertyValuespvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } // 以来检查checkDependencies(beanName, mbd, filteredPds, pvs); } if (pvs != null) { // 应用属性applyPropertyValues(beanName, mbd, bw, pvs); } }

pvs 属性如下

applyPropertyValues

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyPropertyValues
属性设置

protectedvoidapplyPropertyValues(StringbeanName, BeanDefinitionmbd, BeanWrapperbw, PropertyValuespvs) { if (pvs.isEmpty()) { return; } if (System.getSecurityManager() != null && bwinstanceofBeanWrapperImpl) { ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext()); } MutablePropertyValuesmpvs = null; // 没有解析的属性List<PropertyValue> original; if (pvsinstanceofMutablePropertyValues) { mpvs = (MutablePropertyValues) pvs; if (mpvs.isConverted()) { // Shortcut: use the pre-converted values as-is.try { bw.setPropertyValues(mpvs); return; } catch (BeansExceptionex) { thrownewBeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex); } } original = mpvs.getPropertyValueList(); } else { original = Arrays.asList(pvs.getPropertyValues()); } // 自定义转换器TypeConverterconverter = getCustomTypeConverter(); if (converter == null) { converter = bw; } // 创建BeanDefinitionValueResolverBeanDefinitionValueResolvervalueResolver = newBeanDefinitionValueResolver(this, beanName, mbd, converter); // Create a deep copy, resolving any references for values.// 解析后的对象集合List<PropertyValue> deepCopy = newArrayList<>(original.size()); booleanresolveNecessary = false; for (PropertyValuepv : original) { // 解析过的属性if (pv.isConverted()) { deepCopy.add(pv); } // 没有解析过的属性else { // 属性名称StringpropertyName = pv.getName(); // 属性值,直接读取到的ObjectoriginalValue = pv.getValue(); if (originalValue == AutowiredPropertyMarker.INSTANCE) { MethodwriteMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod(); if (writeMethod == null) { thrownewIllegalArgumentException("Autowire marker for property without write method: " + pv); } originalValue = newDependencyDescriptor(newMethodParameter(writeMethod, 0), true); } // 解析值ObjectresolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); ObjectconvertedValue = resolvedValue; /** * 1. isWritableProperty: 属性可写 * 2. isNestedOrIndexedProperty: 是否循环嵌套 */booleanconvertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); if (convertible) { // 转换器解析convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter); } // Possibly store converted value in merged bean definition,// in order to avoid re-conversion for every created bean instance.if (resolvedValue == originalValue) { if (convertible) { pv.setConvertedValue(convertedValue); } deepCopy.add(pv); } // 类型解析elseif (convertible && originalValueinstanceofTypedStringValue && !((TypedStringValue) originalValue).isDynamic() && !(convertedValueinstanceofCollection || ObjectUtils.isArray(convertedValue))) { pv.setConvertedValue(convertedValue); deepCopy.add(pv); } else { resolveNecessary = true; deepCopy.add(newPropertyValue(pv, convertedValue)); } } } if (mpvs != null && !resolveNecessary) { mpvs.setConverted(); } // Set our (possibly massaged) deep copy.try { bw.setPropertyValues(newMutablePropertyValues(deepCopy)); } catch (BeansExceptionex) { thrownewBeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex); } }

属性设置后跳出方法回到 doCreateBean

try { populateBean(beanName, mbd, instanceWrapper); exposedObject = initializeBean(beanName, exposedObject, mbd); }

initializeBean

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
我们可以看一下整个代码的流程
1. aware 接口的执行
2. BeanPostProcessor 前置方法执行
3. bean 实例化
4. BeanPostProcessor 后置方法执行
5. 返回 bean

protectedObjectinitializeBean(finalStringbeanName, finalObjectbean, @NullableRootBeanDefinitionmbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); returnnull; }, getAccessControlContext()); } else { // aware 接口执行invokeAwareMethods(beanName, bean); } ObjectwrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // BeanPostProcessor 前置方法执行wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 执行实例化函数invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwableex) { thrownewBeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex ); } if (mbd == null || !mbd.isSynthetic()) { // BeanPostProcessor 后置方法执行wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } returnwrappedBean; }

Aware 接口的执行

privatevoidinvokeAwareMethods(finalStringbeanName, finalObjectbean) { if (beaninstanceofAware) { if (beaninstanceofBeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); } if (beaninstanceofBeanClassLoaderAware) { ClassLoaderbcl = getBeanClassLoader(); if (bcl != null) { ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl); } } if (beaninstanceofBeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } } }j

前置方法执行

@OverridepublicObjectapplyBeanPostProcessorsBeforeInitialization(ObjectexistingBean, StringbeanName) throwsBeansException { Objectresult = existingBean; for (BeanPostProcessorprocessor : getBeanPostProcessors()) { Objectcurrent = processor.postProcessBeforeInitialization(result, beanName); if (current == null) { returnresult; } result = current; } returnresult; }

后置方法执行

@OverridepublicObjectapplyBeanPostProcessorsAfterInitialization(ObjectexistingBean, StringbeanName) throwsBeansException { Objectresult = existingBean; for (BeanPostProcessorprocessor : getBeanPostProcessors()) { // 执行 spring 容器中 BeanPostProcessorObjectcurrent = processor.postProcessAfterInitialization(result, beanName); if (current == null) { returnresult; } result = current; } returnresult; }

invokeInitMethods

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods
初始化方法重点看一下

protectedvoidinvokeInitMethods(StringbeanName, finalObjectbean, @NullableRootBeanDefinitionmbd) throwsThrowable { // 是否是 InitializingBeanbooleanisInitializingBean = (beaninstanceofInitializingBean); // 是否存在方法 "afterPropertiesSet"if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) { if (logger.isTraceEnabled()) { logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); } if (System.getSecurityManager() != null) { try { // 执行 afterPropertiesSetAccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { ((InitializingBean) bean).afterPropertiesSet(); returnnull; }, getAccessControlContext()); } catch (PrivilegedActionExceptionpae) { throwpae.getException(); } } else { ((InitializingBean) bean).afterPropertiesSet(); } } if (mbd != null && bean.getClass() != NullBean.class) { StringinitMethodName = mbd.getInitMethodName(); if (StringUtils.hasLength(initMethodName) && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) { // 自定义的 init methodinvokeCustomInitMethod(beanName, bean, mbd); } } }

我们现在的 bean 不是InitializingBean 会走自定义的init-mthod方法

做一下改造实体对象

publicvoidinitMethod() { this.name = "abc"; this.age = 10; }

<beanclass="org.source.hot.spring.overview.ioc.bean.init.UserBean"init-method="initMethod"> <propertyname="age"value="30"/> </bean>

观察 initMethodName 会变成标签属性init-method 的内容. 接下来就是通过反射执行方法

在执行方法前将 bean 的信息先做一次截图
如果按照我们代码中的编写方式 bean 的属性会被覆盖

invokeCustomInitMethod

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeCustomInitMethod
执行自定义的init-method 方法

protectedvoidinvokeCustomInitMethod(StringbeanName, finalObjectbean, RootBeanDefinitionmbd) throwsThrowable { // 获取 initMethod 名称StringinitMethodName = mbd.getInitMethodName(); Assert.state(initMethodName != null, "No init method set"); // 反射获取方法MethodinitMethod = (mbd.isNonPublicAccessAllowed() ? BeanUtils.findMethod(bean.getClass(), initMethodName) : ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName)); // 方法是否存在判断if (initMethod == null) { if (mbd.isEnforceInitMethod()) { thrownewBeanDefinitionValidationException("Could not find an init method named '" + initMethodName + "' on bean with name '" + beanName + "'"); } else { if (logger.isTraceEnabled()) { logger.trace("No default init method named '" + initMethodName + "' found on bean with name '" + beanName + "'"); } // Ignore non-existent default lifecycle methods.return; } } if (logger.isTraceEnabled()) { logger.trace("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'"); } // 尝试获取接口方法MethodmethodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod); if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { ReflectionUtils.makeAccessible(methodToInvoke); returnnull; }); try { // 反射调用AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> methodToInvoke.invoke(bean), getAccessControlContext()); } catch (PrivilegedActionExceptionpae) { InvocationTargetExceptionex = (InvocationTargetException) pae.getException(); throwex.getTargetException(); } } else { try { // 反射调用ReflectionUtils.makeAccessible(methodToInvoke); methodToInvoke.invoke(bean); } catch (InvocationTargetExceptionex) { throwex.getTargetException(); } } }

getInterfaceMethodIfPossible

org.springframework.util.ClassUtils#getInterfaceMethodIfPossible

publicstaticMethodgetInterfaceMethodIfPossible(Methodmethod) { // 是不是 public// 是不是 接口if (!Modifier.isPublic(method.getModifiers()) || method.getDeclaringClass().isInterface()) { returnmethod; } // 放入init-method 缓存returninterfaceMethodCache.computeIfAbsent(method, key -> { Class<?> current = key.getDeclaringClass(); while (current != null && current != Object.class) { // 当前类的 接口列表Class<?>[] ifcs = current.getInterfaces(); for (Class<?> ifc : ifcs) { try { // 从接口中获取方法returnifc.getMethod(key.getName(), key.getParameterTypes()); } catch (NoSuchMethodExceptionex) { // ignore } } current = current.getSuperclass(); } returnkey; }); }

跳出这个方法initializeBean 回到下面代码
```
try { populateBean(beanName, mbd, instanceWrapper); exposedObject = initializeBean(beanName, exposedObject, mbd); }
```
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
  其实到此 bean 已经创建完成可以直接返回了.

再往外层跳

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

if(mbd.isSingleton()){// 判断是否是单例sharedInstance=getSingleton(beanName,()->{try{returncreateBean(beanName,mbd,args);}catch(BeansExceptionex){// 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);throwex;}});bean=getObjectForBeanInstance(sharedInstance,name,beanName,mbd);}

单例对象的创建 bean 已经完成啦...

其他的两种创建，其本质还是 createBean 方法的调用.

// 原型模式创建elseif (mbd.isPrototype()) { // It's a prototype -> create a new instance.ObjectprototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { StringscopeName = mbd.getScope(); finalScopescope = this.scopes.get(scopeName); if (scope == null) { thrownewIllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { ObjectscopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { returncreateBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateExceptionex) { thrownewBeanCreationException(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); } }

再往外面跳一层回到 getBean 方法.
终于 getBean 方法底层调用分析结束.

Files

Spring-beanFactory.md

Latest commit

History

Spring-beanFactory.md

File metadata and controls

Spring BeanFactory

BeanFactory 概述

类图

方法列表

解析

用例

代码部分

分析

assertBeanFactoryActive

getBeanFactory

doGetBean

transformedBeanName

getSingleton

getObjectForBeanInstance

getObjectFromFactoryBean

beforeSingletonCreation

postProcessObjectFromFactoryBean

afterSingletonCreation

markBeanAsCreated

getMergedLocalBeanDefinition

getBeanDefinition

getMergedBeanDefinition

overrideFrom

checkMergedBeanDefinition

isDependent

registerDependentBean

getSingleton

createBean

resolveBeforeInstantiation

doCreateBean

createBeanInstance

resolveBeanClass

doResolveBeanClass

evaluateBeanDefinitionString

evaluate

BeanExpressionContext

parseExpression

resolveBeanClass

obtainFromSupplier

initBeanWrapper

registerCustomEditors

registerCustomEditors

doRegisterEditor

applyMergedBeanDefinitionPostProcessors

addSingletonFactory

getEarlyBeanReference

populateBean

applyPropertyValues

initializeBean

invokeInitMethods

invokeCustomInitMethod

getInterfaceMethodIfPossible