类图
类图中只保留了getBean调用流程的主要类
- 通过
xml配置的bean关系会返回一个ApplicationContext的接口，AbstractApplicationContext抽象类实现了ApplicationContext接口并且写getBean方法 AbstractApplicationContext中有一个getBeanFactory抽象方法，在getBean方法中都会调用getBeanFactory得到bean工厂，调用对应的getBean方法
AbstractRefreshableApplicationContext是AbstractApplicationContext的一个子类，实现了getBeanFactory方法返回一个ConfigurableListableBeanFactory类型的工厂
DefaultListableBeanFactory是ConfigurableListableBeanFactory的默认实现，同时也是AbstractBeanFactory的子类AbstractBeanFactory正真处理getBean的类，都会交给doGetBean去获取
类调用流程总结
当调用了ApplicationContext的getBean方法，AbstractApplicationContext通过getBeanFactory获取到了ConfigurableListableBeanFactory默认实现 DefaultListableBeanFactory工厂，通过DefaultListableBeanFactory （默认实现了俩种getBean方法，最终也会调用AbstractBeanFactory的doGetBean）最终会由 AbstractBeanFactory的doGetBean处理
doGetBean流程
doGetBean大致流程图如下，通过代码进行对细节得分析，由于doGetBean代码比较多这里会采用分段得方式进行一段一段的分析
- 进入方法后就会调用
transformedBeanName方法对名称进行转化，对于FactoryBean会去掉&符号，后统一获取原始的bean名称（别名情况） - 解析到原始bean名称后会进入
getSingleton方法获取单例bean对象- 首先会从完全初始化的缓存（一级缓存）中检查是否有bean
- 完全初始化的缓存（一级缓存）中没有bean，就会去未完全初始化的缓存中（二级缓存）获取bean
- 未完全初始化的缓存中（二级缓存）没有bean，就会加锁再次进行双重检查，再次对一级、二级缓存中检查是否有bean
- 双重检查后没有bean，就会检查bean工厂缓存中是否有（三级缓存）
- 三级缓存中如果有，就会对进行bean迁移，从三级缓存中迁移至二级缓存，没有说bean可能是原型作用域或者父工厂的bean
- 单例中获取到bean就会调用
getObjectForBeanInstance方法获取bean的实例对象，getObjectForBeanInstance方法在后面会进行单独分析
//转化bean名称，如果过是FactoryBean实例去掉前缀，包括别名转为实际bean名称
String beanName = transformedBeanName(name);
Object bean;
// 从缓存中获取单例作用域的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);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从完全初始化的缓存中获取（一级缓存）
Object singletonObject = this.singletonObjects.get(beanName);
// 获取不到并且Bean正在创建，就去未完全初始化的的缓存中获取
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 从未完全初始化的缓存中获取（二级缓存）
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
// 双重检索，再次检查Bean是否创建，
synchronized (this.singletonObjects) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
// 双重检索不存在，Bean工厂中获取（三级缓存）
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// Bean实例创建完成，但未完成初始化移动到未完全初始化的的缓存（二级缓存）
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
- 单例缓存中没有获取bean，说明bean不是单例作用域，会进入后面的逻辑，
isPrototypeCurrentlyInCreation方法会检查原型作用域的bean是否存在相互依赖的问题（相互依赖会出现无限递归问题），比如beanA依赖于beanB，beanB依赖beanA且都是prototype的作用域，获取beanA发现依赖beanB，这时会触发getBean()去创建beanB，同理beanB也许触发getBean创建A，这样就会出现无限递归问题 getParentBeanFactory方法是获取bean的父工厂，比如获取的对象是在父工厂中，通过子的上下文去获取，就会执行这个方法
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
// 判断bean是否在定义（比如xml文件通过id定义的bean）
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 转换为原始的bean名称，BeanFactory实例带"&"前缀
String nameToLookup = originalBeanName(name);
// 从父工厂中获取bean
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
typeCheckOnly根据参数传入，如果为false就会将bean标记为已创建，，从而触发与创建相关的生命周期事件
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) {
// 双重检索检查bean已被标记为已创建
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.
// 清除合并后的bean定义缓存，如果bean的定义发生了变化，比如xml文件被修改或者配置类被重新加载，确保使用用最新bean定义创建实例
clearMergedBeanDefinition(beanName);
this.alreadyCreated.add(beanName);
}
}
}
}
getMergedLocalBeanDefinition获取bean合并后的定义- mbd用于存放父元素bean的定义，bd等于当前bean的定义，previous之前bean的定义
- 如果没有定义的父元素就会生成新的或者转换为
RootBeanDefinition - 定义了父元素就会递归的获取父元素的bean定义或者父工厂bean的定义，获取父元素bean的定义后通过
overrideFrom方法将当前bean的数据覆盖到父元素中达到bean的合并
checkMergedBeanDefinition方法检查bean定义是否为abstract，因为abstract是不需要实例化的
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
// 普通bean的定义，不依赖其他bean定义的bean
RootBeanDefinition mbd = null;
// 之前bean的定义
RootBeanDefinition previous = null;
// Check with full lock now in order to enforce the same merged instance.
if (containingBd == null) {
// 获取合并后的bean定义
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null || mbd.stale) {
previous = mbd;
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
// 如果是RootBeanDefinition类型，转为RootBeanDefinition
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
// 否则新生成一个RootBeanDefinition
mbd = new RootBeanDefinition(bd);
}
}
else {
// Child bean definition: needs to be merged with parent.
BeanDefinition pbd;
try {
// 解析原始bean定义（bd）的父原始名
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
// 递归获取父元素bean的定义,可能父元素bean的定义还有父元素
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
// 获取bean的父工厂
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
// 通过父工厂获取bean的定义
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without a ConfigurableBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// 创建父元素的bena定义
mbd = new RootBeanDefinition(pbd);
// 将子类中配置的数据覆盖父类达到合并
mbd.overrideFrom(bd);
}
// 如果没有设置作用域，默认为单例
// 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.
//一个bean中包含了一个非单例的bean，则它本身就不能够是单例的，下面的代码就是矫正它的作用is域；
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)
//缓存合并之后的BeanDefinition； 为了支持metadata的更改，它之后可能仍然会重新合并
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
if (previous != null) {
// 将之前bean的定义一些信息复制到新的bean定义中
copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;
}
}
getDependsOn方法获取到bean依赖的bean，对依赖的bean进行创建registerDependentBean注册bean与bean的依赖关系dependentBeanMap存放bean和依赖于bean的名称映射（谁依赖我），注意这key是相反的，也就是依赖与我的bean名称是key，bean是value，比如beanA依赖beanB，数据结构为key=beanB，value=beanAdependenciesForBeanMap存放bean和bean依赖的名称映射（我依赖谁），比如beanA依赖beanB，数据结构为key=beanA，value=beanB
isDependent方法用于检查循环依赖问题，看这个方法之前应该先看registerDependentBean方法，直接看可能对if (dependentBeans.contains(dependentBeanName))这里判定循环依赖有点懵alreadySeen存放校验没有出现循环依赖的bean名称，如果包含beanName表示已经校验过了，直接返回false- 获取bean的依赖，为空说明没有依赖就不存在循环依赖问题，直接返回
false - 为什么说没有看
registerDependentBean方法if (dependentBeans.contains(dependentBeanName))这里可能有些懵呢，没有看registerDependentBean方法是不知道dependentBeanMap的K,V是相反的，通过dependentBeans.contains(dependentBeanName)直观看到依赖的bean包含传入名称就可以判断是循环依赖了吗，不需要看依赖的bean是否依赖当前bean吗？所以建议先看registerDependentBean方法，这里就举例beanA依赖于beanB，beanB依赖于beanA进行分析- 加载beanA时候发现依赖于beanB，这时候就会先加载beanB，在循环依赖判断是肯定会返回
false，因为i还没有执行registerDependentBean方法没有将依赖注册进去，dependentBeans为空就返回false - beanB加载完成后，调用
registerDependentBean方法将依赖注册，dependentBeans这是的key就是beanA，value就是beanB - 加载beanA时进入循环依赖判断，
dependentBeans获取到不为空，就会判断dependentBeans是否包含dependentBeanName，value这是beanB传入的依赖名称也是beanB就判定为是循环依赖了
- 加载beanA时候发现依赖于beanB，这时候就会先加载beanB，在循环依赖判断是肯定会返回
- 循环处理依赖说明可能存在多个循环依赖，使用递归的方式进行判断，比如beanA依赖beanB、beanB依赖beanC、beanC依赖beanA这样的
- 调用
getBean创建依赖的对象
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 检查bean是否被另一个bean依赖，避免循环依赖问题
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 缓存bean的依赖
registerDependentBean(dep, beanName);
try {
// 创建依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
public void registerDependentBean(String beanName, String dependentBeanName) {
String canonicalName = canonicalName(beanName);
// 存放bean和依赖于bean名称（谁依赖我），beanA依赖beanB，数据结构为key=beanB，value=beanA
synchronized (this.dependentBeanMap) {
// 如果key不存在执行Function中方法体（new LinkedHashSet<>(8)），存在返回set
Set<String> dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
// 添加的内容存在返回false，不存在返回true
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
// 存放bean和bean依赖的名称（我依赖谁），beanA依赖beanB，数据结构为key=beanA，value=beanB
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
// alreadySeen包含说明已经已经检查过了，没有出现循环依赖
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
// 解析为带别名的bean名称
String canonicalName = canonicalName(beanName);
// 获取bean依赖的bean名称
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
// 等于null说明没有依赖的bean
if (dependentBeans == null) {
return false;
}
/**
* bean的依赖集合中包含依赖bean，说明是循环依赖，这里可能有个疑问，比如beanA依赖beanB，依赖集合包含beanB就能说明循环依赖了吗？不需要判断beanB是否依赖beanA？这里就用beanA、beanB互相依赖举例
* 1.加载到beanA进行判断以来循环，明显会返回false，在下一个方法（registerDependentBean）就会看到，会将依赖的bean加载到dependentBeanMap缓存中去
* 2.dependentBeanMap中key、value是反着的（谁依赖我），比如beanA依赖beanB，key就是beanB，value是beanA
* 3.加载完依赖缓存后，会调用getBean来创建beanB，同样进入此方法判断循环依赖，获取到的beanB依赖集合中发现有beanA，就说明依赖循环了
*/
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
// 走到这里说明bean没有产生循环依赖，还依赖另一个bean
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
alreadySeen.add(beanName);
// 递归判断循环依赖
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
- 创建单例作用域的bean，创建bean会在下一章分析，这里只分析获取bean的流程
- 抛出异常后说明bean创建失败，会进行bean销毁，包含一些依赖的信息等等，看代码的备注分析
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
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.
// 销毁bean
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
public void destroySingleton(String beanName) {
// Remove a registered singleton of the given name, if any.
// 从缓存中删除bean
removeSingleton(beanName);
// Destroy the corresponding DisposableBean instance.
DisposableBean disposableBean;
synchronized (this.disposableBeans) {
disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
}
destroyBean(beanName, disposableBean);
}
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
// Trigger destruction of dependent beans first...
Set<String> dependencies;
synchronized (this.dependentBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
dependencies = this.dependentBeanMap.remove(beanName);
}
/**
* 销毁依赖于当前bean的bean（谁依赖我）
* 1.beanA依赖beanB，在beanB创建的时候出错会进行销毁，在销毁beanB之前会将beanA进行销毁
* 2.beanA依赖beanB，在beanB创建成功，beanA创建出错是，并不会销毁beanB只会销毁beanA
* 那为什么要将依赖于bean的所有bean销毁呢？
* 那beanA依赖beanB进行分析，要是beanB创建失败了，就算beanA创建成功了也是不完整的，所有联同依赖bean的所有也一并销毁
*/
if (dependencies != null) {
if (logger.isTraceEnabled()) {
logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
}
for (String dependentBeanName : dependencies) {
destroySingleton(dependentBeanName);
}
}
// 销毁bean
if (bean != null) {
try {
bean.destroy();
}
catch (Throwable ex) {
if (logger.isWarnEnabled()) {
logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
}
}
}
// 销毁包含的bean
Set<String> containedBeans;
synchronized (this.containedBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
containedBeans = this.containedBeanMap.remove(beanName);
}
if (containedBeans != null) {
for (String containedBeanName : containedBeans) {
destroySingleton(containedBeanName);
}
}
// 清除依赖于当前bean的bean关系（谁依赖我，我要销毁了，别在依赖我了），确保依赖于当前bean的其他bean关系中不包含已经销毁的bean
synchronized (this.dependentBeanMap) {
for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, Set<String>> entry = it.next();
Set<String> dependenciesToClean = entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
// 清除bean的依赖信息
this.dependenciesForBeanMap.remove(beanName);
}
- 创建原型作用域的bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 将当前bean添加到"正在创建的原型bean缓存中"
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 将当前bean移除"正在创建的原型bean缓存中"
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
- 创建其他作用域的bean
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
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, () -> {
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);
}
}
getObjectForBeanInstance方法是用于获取bean对象实例，只要是针对FactoryBean这样的创建方式，如果是普通bean直接返回bean本身- 如果是
FactoryBean方式创建的最终会调用实现类的getObject方法，FactoryBean是一个接口里面的getObject方法用于返回bean对象
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 判断名称是否指向FactoryBean的引用，指向FactoryBean的引用是获取FactoryBean，而不是获取由FactoryBean创建的实例对象
if (BeanFactoryUtils.isFactoryDereference(name)) {
// 是否空bean类型
if (beanInstance instanceof NullBean) {
return beanInstance;
}
// FactoryBean本身又不是FactoryBean类型，抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// 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.
// 普通bean直接返回
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
// 走到这里确定为FactoryBean
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
// 从FactoryBean缓存中获取对象
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
// 判断bean的定义是否是合成的
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 从FactoryBean获取对象
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 单例bean且已被创建
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
// 从FactoryBean缓存中获取bean
Object object = 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)
/**
* 再次检查缓存中是否有bean，为什么还要再次进行缓存检查
* 可能是避免重复去创建bean，可能已经有其他线程创建完成放入缓存中
*/
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
// bean是否需要进行后处理
if (shouldPostProcess) {
// 如果是正在创建的bean就返回
if (isSingletonCurrentlyInCreation(beanName)) {
// Temporarily return non-post-processed object, not storing it yet..
return object;
}
beforeSingletonCreation(beanName);
try {
// 对FactoryBean的后处理，这里的默认方法只是简单的返回传入的对象没做任何处理，可以通过子类扩展该方法进一步处理
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
afterSingletonCreation(beanName);
}
}
// bean已创建将其添加到factoryBeanObjectCache缓存
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
Object object;
try {
// 启用了JVM安全策略，比如需要权限才能访问文件等等
if (System.getSecurityManager() != null) {
// 获取执行的特权和其他的信息，比如安全上下文，代码来源，类加载器
AccessControlContext acc = getAccessControlContext();
try {
// 在安全环境下执行getObject()
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
// 调用实现类的getObject方法获取对象
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
// 获取到的对象为空，初始化一个空bean
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
- 下面是返回前的类型检查，检查bean的实际类型和传入的类型是否一致，如果不一致会进行转化
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 类型转换
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
全流程代码
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// 转化bean名称，如果过是FactoryBean实例去掉前缀，包括别名转为实际bean名称
String beanName = transformedBeanName(name);
Object bean;
// 从缓存中获取单例作用域的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);
}
else {
/**
* 检查prototype作用域的bean是否正在创建中，避免出现无限递归为问题
* 比如beanA依赖于beanB且都是prototype的作用域，获取beanA发现依赖beanB，这时会触发getBean()去创建beanB，同理beanB也许触发getBean创建A，这样就会出现无限递归问题
*/
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
// 判断bean是否在定义（比如xml文件通过id定义的bean）
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 转换为原始的bean名称，BeanFactory实例带"&"前缀
String nameToLookup = originalBeanName(name);
// 从父工厂中获取bean
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 如果为false表示需要创建bean实例，就会将bean标记为已创建，，从而触发与创建相关的生命周期事件
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 获取合并后的bean定义
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查bean是否为abstract,abstract是不需要实例化将抛出BeanIsAbstractException异常
checkMergedBeanDefinition(mbd, beanName, args);
// 获取依赖得bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 检查bean是否被另一个bean依赖，避免循环依赖问题
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 缓存bean的依赖
registerDependentBean(dep, beanName);
try {
// 创建依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 创建单例bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
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.
// 销毁bean
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 创建原型bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 将当前bean添加到"正在创建的原型bean缓存中"
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 将当前bean移除"正在创建的原型bean缓存中"
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 创建其他作用域的bean
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
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, () -> {
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) {
// 清除"已经创建过的bean"的缓存
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 检查bean的实际类型和传入的类型是否一致,isInstance检查bean是否是requiredType的实例，如果是那就不需要在转换了
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 类型转换
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
总结
- 首先通过三级缓存获取单例bean
- 获取不到说明是其他作用域bean或者bean在父工厂中，就会通过父工厂获取
- 父工厂没有获取到说明是其他作用域的bean，会对其他作用域的bean及其依赖的bean进行一个创建，如果有依赖bean会进行循环依赖的检查
- 最后做类型检查以及类型转换返回bean
扫一扫
1914
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
