DefaultListableBeanFactory 类继承分析一

 DefaultListableBeanFactory 类继承

 

 SimpleAliasRegistry

 

SimpleAliasRegistry 是AliasRegistry的实现。

 

主要通过一个map（ConcurrentHashMap）保存alias=>name的映射。并且具有传递性，如

N0=>N1

N1=>N2

 

所以N2的alias有N0 N1。 所以retrieveAliases，还有个hasAlias是递归实现的。

 

 DefaultSingletonBeanRegistry

 

 

主要也是注册 和获取singleton对象。

 

下面三个比较重要的属性：

 

除了存储singleton对象，还有就是为了解决单例的循环依赖问题。

 

等会再来详细看看spring 如何解决循环依赖问题。

 

我们先来看看 接口的具体的方法实现。

 

①　containsSingleton

 

 

②　getSingletonNames

 

③　getSingletonCount

 

 

④　getSingletonMutex

 

前面 四个方法实现都很简单。下面看下剩下的两个方法。

 

⑤　registerSingleton

 

 

该方法假设 注册的singleton 对象已经完全 初始化玩成，不会执行afterPropertiesSet和destroy方法。如果想要调用回调，最好注册Bean definition。

 

该方法实现内部调用了addSingleton:

 

 

 

剩下的方法getSingleton 也不是很发杂，有三个getsingleton

 

其中一个调用另一个，所以其实只两个：

 

这个完全按照 最开始的三个属性一个一个拿到。

/**
 * Return the (raw) singleton object registered under the given name,
 * creating and registering a new one if none registered yet.
 * @param beanName the name of the bean
 * @param singletonFactory the ObjectFactory to lazily create the singleton
 * with, if necessary
 * @return the registered singleton object
 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(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);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// 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) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}

这个方法很长 ，主要逻辑：

1）通过 Objectfactory创建对象

2）调用 addSington方法 ，这个方法前面已经分析过 很典型的方法。

FactoryBeanRegistrySupport

getTypeForFactoryBean 方法就是根据传入的factorybean调用它的getObjectType
getObjectFromFactoryBean 获取factorybean getObject，只不过自己做了个缓存。factoryBeanObjectCache属性是一个map缓存。 removeSingleton重写父类方法，添加了一个删除factoryBeanObjectCache缓存操作，然后调用父类方法。
postProcessObjectFromFactoryBean 是一个后处理方法，用于取得object后调用，默认直接返回，没有操作。
这章就写到这里。
下一章我们接着分析AbstractBeanFactory，该类代码较长，具体的循环依赖的解决也在该类。