上节提到了在AbstractApplicationContext 调用refresh方法里，初始化所有BeanDefinitions后，遍历所有BeanDefinitionNames后，循环调用BeanFactory的getBean(name)方法，实例化所有容器 Bean对象(非lasy-init)。
GetBean做了什么？循环引用如何处理的？
既然是BeanFactory的getBean方法，详细看下BeanFactory相关的类图:
- DefaultListableBeanFactory: ListableBeanFactory和BeanDefinitionRegistry接口的默认实现，也是一个功能完善的BeanFactory,可以作为一个独立的BeanFactory使用，也可作为自定义BeanFactory的父类。
- ConfigurableListableBeanFactory接口：提供分析和修改BeanDefinition，以及预初始化singletons接口。
- ListableBeanFactory接口: BeanFactory接口的扩展接口，定义了各种Map<String,Object> getbeans* 的接口。
- BeanFactory接口:BeanFactory作为最原始同时也最重要的Ioc容器,它主要的功能是为依赖注入 （DI） 提供支持，也是访问bean容器的客户端视角。BeanFactory包含了一系列bean definitions,每一个Bean definitions都有一个字符串的唯一标识。BeanFactory通过Bean definition 返回singleton的(独立的-prototype，request,session)等不同scope的bean实例。
- AutowireCapableBeanFactory接口：定义了BeanFactory能够使用Autowiring的相关接口。
- **ConfigurableBeanFactory接口:**提供配置BeanFactory的相关接口。
- HierachicalBeanFactory接口：接口被bean factoris 实现,实现分层级的bean Factory。
- SingletonBeanRegistry 接口： 为所有的singleton的bean提供统一的管理机制。
- AbstractAutowireCapableBeanFactory : 实现了通过RootBeanDefinition创建bean的默认实现，提供bean创建，property populatin，autowring,handles runtime bean references,resolves managed collections，调用初始化方法等实现。
- AbstractBeanFactory：BeanFactory接口的基础实现抽象类。
- FactoryBeanRegistrySupport: FactoryBean实例的管理，以及DefaultSingletonBeanRegistry的管理。
- DefaultSingletonBeanRegistry： 实现SingletonBeanRegistry接口。
- SimpleAliasRegistry : 实现 AliasRegistry接口。
- AliasRegistry接口：别名相关的所有功能。
调用GetBean时，调用时序图如下：
我们先从AbstractBeanFactory的 doGetBean(final String name,final Class
参数意义如下:
- name:需要得到bean的名称
- requireType:需要得到bean的类型
- args：创建bean实例时用的更为详细的参数（只在创建bean 实例时起作用）
- typeCheckOnly:表明这个instance只是为了类型的检查，而不是真正创建一个bean
调用流程如下:
getBean主流程图
源码如下:
/**
* Return an instance, which may be shared or independent, of the specified bean.
* @param name the name of the bean to retrieve
* @param requiredType the required type of the bean to retrieve
* @param args arguments to use when creating a bean instance using explicit arguments
* (only applied when creating a new instance as opposed to retrieving an existing one)
* @param typeCheckOnly whether the instance is obtained for a type check,
* not for actual use
* @return an instance of the bean
* @throws BeansException if the bean could not be created
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//处理name,去除开头&,若是别名则转换成标准beanName
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 取缓存的Bean,在此处解决了循环引用的问题
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 完成FactoryBean的处理
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 如果我们已经正在创建这个bean实例，则因为循环引用的问题抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 检查bean definition是否在当前beanFactory中，若不在，委派到父类 or 父类的父类
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
// 标记bean为已创建，放入alreadyCreated Set<String>
markBeanAsCreated(beanName);
}
try {
// 通过beanName得到BeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 得到目标bean所有依赖的beanNames
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 将依赖bean注册到目标bean上，保证在目标bean destroy前被destroy
registerDependentBean(dep, beanName);
// 创建 dependent的bean实例
getBean(dep);
}
}
// Create bean instance.
// 创建单例模式的bean
if (mbd.isSingleton()) {
// 使用匿名的内部类，创建一个Bean实例 在 DefaultSingletonBeanRegisty.java中
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
// getSingleton中会调用getObject()
@Override
public Object getObject() throws BeansException {
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.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 创建prototype模式的bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 创建其他scope的bean
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
由于大部分业务bean都是singleton的，所以doGetBean方法直接就去看beanFactory的 singletonObjects里有没有目标bean。我们可以详细看下<getBean主流程图> 里第一个子流程
sharedInstance = getSingleton(beanName) ---> 调用：
DefaultSingletonBeanRegistry.java 里的getSingleton(beanName,allowEarlyReference=true) 方法。
流程图:
源码如下:
/**
* Return the (raw) singleton object registered under the given name.
* <p>Checks already instantiated singletons and also allows for an early
* reference to a currently created singleton (resolving a circular reference).
* @param beanName the name of the bean to look for
* @param allowEarlyReference whether early references should be created or not
* @return the registered singleton object, or {@code null} if none found
*/
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
若通过BeanName得到singletonObjects里的bean,判断是一个标准bean ，而不是FactoryBean，或者调用方就需要一个FactoryBean的引用，就直接返回。
若是取到的sharedInstance为空，那么后续会走双亲委派模型 去搜索父BeanFactory里是否有当前BeanName的BeanDefinition，若有，让父BeanFactory去初始化Bean。
双亲委派模型，典型的使用就是JVM的类加载机制了，其优点主要是:
(1) 保证全局一个Bean只被一个BeanFactory加载，避免了重复加载的问题。
(2) 模型使得Bean随着BeanFactory具备了一种带优先级的层次关系，越基础的Bean，越会被上层的BeanFactory加载。
确定了当前bean属于当前的BeanFactory后，加载此Bean的所有depends-on的beans。 当depends-on的beans全被加载完毕后，判断当前bean的scope是哪种？
spring中的bean的scope有如下几种 singleton(ioc容器里唯一)，prototype(每次创建新实例),request(一次http request唯一),session,globalSession,application,websocket 。
代码中的处理逻辑，做了三个分支, isSingleton,isPrototype，以及其他。
当bean的scope为Singleton时，会调用父类DefaultSingletonBeanRegistry里的
getSingleton(beanName,ObjectFactory<?>)方法，调用方式如下:
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//createBean其他scope都会调用，而此处getSingleton保证了所有singleton的逻辑
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
DefaultSingletonBeanRegistry.java -----getSingleton(beanName,ObjectFactory<?>)
流程图如下:
源码如下:
/**
* 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);
// 若singletonObjects(Cache of singleton objects)没有beanName,bean没被创建过
if (singletonObject == null) {
// 标识是否正在 destroy singletons
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 + "'");
}
// 判断是否正在创建，若正在（singletonsCurrentlyInCreation.contains），抛出异常，若不在加入 singletonsCurrentlyInCreation Set<String> 里
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
// 在此调用上层方法,createBean() 也是创建对象的方法
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;
}
// 创建结束,移除singletonsCurrentlyInCreation里的beanName
afterSingletonCreation(beanName);
}
// 创建成功
if (newSingleton) {
// 将bean放入singletonObjects里，从singletonFactories里移除beanName,
// 从earlySingletonObjects(解决循环依赖，提前引用)中移除,
// 添加beanName 到registerdSingletons里
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
调用singletonFactory.getObject() ，即是调用AbstractAutowireCapableBeanFactory的createBean方法。
AbstractAutowireCapableBeanFactory.java---------createBean()
流程图如下:
源码如下：
/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 确保目标bean的class已经被解析并set到beanDefinition里，返回class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
// dynamically resolved Class 不能存储到shared mergedBeanDefinitions 里，所以deep copy
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
// 核心创建bean 方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
上述代码调用了 AbstractAutowireCapableBeanFactory的doCreateBean方法:
流程图如下：
源码如下:
/**
* Actually create the specified bean. Pre-creation processing has already happened
* at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
* <p>Differentiates between default bean instantiation, use of a
* factory method, and autowiring a constructor.
* @param beanName the name of the bean
* @param mbd the merged bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a new instance of the bean
* @throws BeanCreationException if the bean could not be created
* @see #instantiateBean
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
// Instantiate the bean.
// beanWrapper 是 low-level 的javaBeans 的结构，可以操作一些bean的属性
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建制定bean新的实例，选用合适的构造方法调用
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 尽早拿到引用，防止循环引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 给Bean的属性赋值，属性的依赖在此注入
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 初始化bean对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
// 若bean是singleton 并且正在创建
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
// 正在实例化的bean 和目标bean是一个
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
BeanWrapper接口提供一系列对Bean中属性 set get 以及 converter等功能。
可以看到instanceWrapper是由AbstractAutowiredCapableBeanFactory 的createBeanInstance方法创建，
流程图如下:
/**
* Create a new instance for the specified bean, using an appropriate instantiation strategy:
* factory method, constructor autowiring, or simple instantiation.
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return BeanWrapper for the new instance
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
* @see #instantiateBean
*/
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// Make sure bean class is actually resolved at this point.
Class<?> beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// Need to determine the constructor...
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
从上述代码中，可以看到有三种初始化BeanWrapper的方式，
(1) instantiateUsingFactoryMethod ---- 当BeanDefinition有工厂方法时
(2) autowireConstructor ------ 当BeanDefinition有构造函数 或者 args 不为空 等
(3) instantiateBean ------ 无参时默认构造函数
三者都调用了 beanFactory.getInstantiationStrategy.instantiate()
默认实现使用了Cglib ：
/**
* Create a new instance of a dynamically generated subclass implementing the
* required lookups.
* @param ctor constructor to use. If this is {@code null}, use the
* no-arg constructor (no parameterization, or Setter Injection)
* @param args arguments to use for the constructor.
* Ignored if the {@code ctor} parameter is {@code null}.
* @return new instance of the dynamically generated subclass
*/
public Object instantiate(Constructor<?> ctor, Object... args) {
Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
if (ctor == null) {
instance = BeanUtils.instantiateClass(subclass);
}
else {
try {
Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
instance = enhancedSubclassConstructor.newInstance(args);
}
catch (Exception ex) {
throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
"Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
}
}
// SPR-10785: set callbacks directly on the instance instead of in the
// enhanced class (via the Enhancer) in order to avoid memory leaks.
Factory factory = (Factory) instance;
factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
return instance;
}
至此，getBean()的所有过程已详尽描述。
getBean的创建流程，可以从整个调用过程中里的一些关键变量的角度来看这个问题:
AbstractBeanFactory----此层面定义的变量用来控制整个BeanFactory:
List
Map<String,RootBeanDefinition> mergedBeanDefinitions: bean名称与RBD对应的map
**Set
ThreadLocal 正在创建的bean的名称
DefaultSingletonBeanRegistry:
**Map<String,Object> singletonObjects:**ConcurrentHashMap,所有singleton对象，beanName->bean instance
**Map<String,ObjectFactory<?>> singletonFactories:**singleton工厂对象，beanName->ObjectFactory
Map<String,Object> earlySingletonObjects : 早期的singleton对象。
Set
Set
Set
Map<String,Object> disposableBeans : beanName -> disposable bean 实例
Map<String,Set
Map<String,Set
Map<String,Set
1.在AbstractBeanFactory---doGetBean里 getSingleton(beanName)里会先看singletonObjects是否有这个Bean,若没有，再看singletonsCurrentlyInCreation里有没有这个Bean。若有,再看earlySingletonObjects里是否有这个Bean，若有直接返回，若没有，再看singletonFactories是否有这个BeanName,若有则创建这个bean,并将其放入 earlySingletonObjects里。
从此过程可以看出 一个Bean 从 ObjectFactory ---> earlySingletonObject -> 完整的Bean的。
下一遍会详细说明Spring 中的循环引用是如何处理的？
