在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry类中有几个集合类型的成员变量，用来做缓存用的需要特别留意，源码如下：
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
......
//singletonObjects：单例池
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
//singletonFactories：三级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
//earlySingletonObjects：二级缓存
private final Map<String, Object> earlySingletonObjects = new HashMap(16);
//将当前正在创建的bean添加到这个Set集合中（保存正在实例化的bean的BeanName）
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16));
......
}
/*
上面的代码中：
singletonObjects：保存BeanName和bean的实例（此时对象已经完成了属性注入）单例池
earlySingletonObjects：保存对象BeanName和对象的早期实例（ObjectFactory#getObject得到的对象）（此时对象还没注入属性），此时可以作为对象填充依赖。（二级缓存）
singletonsCurrentlyInCreation：保存对象的BeanName，在创建对象之前就会把对象的beanName保存起来。表示这个对象正在创建中。
singletonFactories：保存对象的BeanName和创建bean的工厂（beanName -> 使用ObjectFactory创建出的bean代理对象）
ObjectFactory：这个接口类似于FactoryBean，但是后者的实现通常在容器中被定义为一个SPI实例。同时这个类的实现通常意味着此类作为API提供给其他的bean（通过注入的方式）。这是原注释中的说法。
*/
ObjectFactory和FactoryBean的区别：
通过接口内容来看，两者都是属于工厂模式用来创建对象使用的。
而区别在于
FactoryBean在BeanFacotry的实现中有着特殊的处理，如果一个对象实现了FactoryBean 那么通过它get出来的对象实际是
factoryBean.getObject() 得到的对象，如果想得到FactoryBean必须通过在 ‘&’ + beanName 的方式获取
而ObjectFactory则只是一个普通的对象工厂接口。
在查看AbstractBeanFacotry的doGetBean(…) 部分的源码时，可以看到spring对ObjectFactory的应用之一就是，将创建对象
的步骤封装到ObjectFactory中 交给自定义的Scope来选择是否需要创建对象来灵活的实现scope。
通过这方面简单的对比可以得到：
FactoryBean的着重于自定义创建对象过程，由BeanFactory通过FactoryBean来获取目标对象，而如果是isSingleton返回true的话spring会利用单例缓存来缓存通过FactoryBean创建的对象。
而ObjectFactory就是一个普通的工厂对象接口，对于spring在doGetBean处的使用时，在于创建对象的过程由框架通过ObjectFactory定义，而创建的时机交给拓展接口Scope，除此之外ObjectFactory就是一个普通的接口。
此外在将给依赖注入列表注册一个ObjectFactory类型的对象，在注入过程中会调用objectFactory.getObject()来创建目标对象注入进去。
（如beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());）
简单来说就是通过FactoryBean你可以控制对象如何创建，而ObjectFactory借助Scope接口自定义scope你可以控制对象的创建时机。
示例可参考博客：https://blog.csdn.net/m0_38043362/article/details/80284577
通过Spring获取userService对象：
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = applicationContext.getBean("userService", UserService.class);
UserService userService = (UserService)applicationContext.getBean("userService");
使用上述的代码获取bean时
UserService userService = applicationContext.getBean(“userService”, UserService.class);方式：
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name, requiredType);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
UserService userService = (UserService) applicationContext.getBean(“userService”);方式：
@Override
public Object getBean(String name) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name);
}
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
不管是获取bean实例还是创建bean实例，都会去执行getBean方法，在getBean方法中调用了doGetBean方法。
下面看doGetBean源码：（doGetBean以及getBean都在AbstractBeanFactory中）
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
/*
通过 name 获取 beanName。这里不使用 name 直接作为 beanName 有两个原因：
1、name 可能会以 & 字符开头，表明调用者想获取 FactoryBean 本身，而非 FactoryBean实现类所创建的 bean。在 BeanFactory 中，FactoryBean 的实现类和其他的 bean 存储方式是一致的，即 <beanName, bean>，beanName 中是没有 & 这个字符的。所以我们需要将 name 的首字符 & 移除，这样才能从缓存里取 到 FactoryBean 创建的实例。
2、还是别名的问题，转换需要
&beanName
*/
/*例如：
获取id为userService的bean时，name为userService，beanName也为userService
如果是通过FactoryBean的方式获取bean时，name为&userService，beanName为userService
*/
String beanName = transformedBeanName(name);
Object beanInstance;
// 从单例池中获取一个bean，如果没有，返回null（下面有这个方法的详解）
Object sharedInstance = getSingleton(beanName);
//单例池中存在这个bean时，通过beanName直接获取这个bean即可
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实例来获取代理对象（name为bean对应的id值）
/*--------------------------------------------------------------------------
如果 sharedInstance 是普通的单例 bean，下面的方法会直接返回。但如果
sharedInstance 是 FactoryBean 类型的，则需调用 getObject 工厂方法获取真正的
bean实例。如果用户想获取 FactoryBean 本身，这里也不会做特别的处理，直接返回
即可。毕竟 FactoryBean 的实现类本身也是一种 bean，只不过具有一点特殊的功能而已。
---------------------------------------------------------------------------*/
/*sharedInstance是普通的单例bean，直接返回（从getObject方法中获取）；如果是FactoryBean 类型的，通过getObject方法生成真正的bean。如果获取的是FactoryBean本身，那么这个本身也和普通bean的处理方式相同*/
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
//没有bean就创建bean
else {
//如果当前要创建的bean是多例的，那么就会抛异常。
/*在spring中，创建多例bean是采用设计模式中的原型模式，也就是对一个bean的深拷贝克隆，但是当前连一个被克隆的“模板”实例都没有，怎么创建多例bean*/
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//获取父容器（一般不使用父容器）
BeanFactory parentBeanFactory = getParentBeanFactory();
//若存在父容器,且当前的容器不存在当前的beanDefinition,那么beanDefinition是存在于父容器中
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
//获取bean的原始名称。
String nameToLookup = originalBeanName(name);
//若为AbstractBeanFactory类型，委托父类处理
if (parentBeanFactory instanceof AbstractBeanFactory) {
//由AbstractBeanFactory类去创建并获取bean
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {// 如果是使用显示参数且T类型未知，就委托给构造函数的getBean()处理
/*
在dogetBean方法中的注释中提到：
使用显式参数创建 bean 实例时使用的参数（仅在创建新实例而不是检索现有实例时应用）
所以是在调用getBean方法时，使用显式参数是无效的。
*/
//在父容器中创建bean的实例
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// 没有args且T类型已知，委托给下面这样的getBean()来创建bean实例
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {//没有args且T类型未知，委托给下面的getBean()来创建bean实例
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
//给要创建的bean添加标记是在实例化前完成的，而且在bean完成初始化后，就要删除这个标记
//将创建好的bean添加到alreadyCreated set集合当中，表示他已经实例化过一次
markBeanAsCreated(beanName);
}
//开始实例化所有的非懒加载的bean
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
//从容器中获取beanName相应的GenericBeanDefinition对象，并将其转换为RootBeanDefinition对象
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查RootBeanDefinition是不是抽象的BeanDefinition（抽象的BeanDefinition是不能实例化的）
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 先初始化依赖的所有 Bean，这个很好理解。
// 这里的依赖指的是 bean标签中depends-on 属性 定义的依赖
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
/*
检查depends-on是否有循环的依赖，这里的循环依赖与平时所说的循环依赖不同。
假设当前A类的bean创建时需要B类的bean，而B类的bean在创建时又需要A类的bean，而此时A类的bean还没有实例化，所以B类也不能实例化。A类的依赖不能完成实例化导致的A类也就不能实例化两个类的bean连实例化都不能完成，所以这样就会出现问题。
我们平时说的循环依赖是发生在属性填充阶段，在属性填充阶段bean已经完成了实例化（放在三级缓存中），只是没有填充属性和初始化，但是只要有了这个bean的实例，就可以解决这个循环依赖的问题。
*/
//beanName是当前正在创建的bean,dep是正在创建的bean的依赖的bean的名称
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//注册依赖的bean。保存的是依赖beanName之间的映射关系：依赖beanName -> beanName的集合
registerDependentBean(dep, beanName);
try {
//创建depends-on中的bean实例，并完成填充属性和初始化的操作。
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//判断当前bean是否是单例
if (mbd.isSingleton()) {
//将bean创建好后直接放入到单例池中（重要，下面有getSingleton方法的详解）
//注意：这个getSingleton方法与上面的getSingleton(String beanName)是重载关系，并不是同一个方法
sharedInstance = getSingleton(beanName, () -> {
try {
/*createBean：实例化bean，并完成填充属性和初始化的操作（通过ObjectFactory 调用getObject方法返回bean的代理对象）（重要方法，下面有这个方法的详解）*/
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
//如果没有bean可以创建或者是创建bean出现错误，就抛出异常并销毁bean
destroySingleton(beanName);
throw ex;
}
});
/*如果是FactoryBean类型（beanName是以&开头的），获取FactoryBean本身；如果是普通bean，直接获取普通bean*/
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//当前的bean是多例时
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);//根据beanName创建原生的实例对象
prototypeInstance = createBean(beanName, mbd, args);//创建多例bean
}
finally {
afterPrototypeCreation(beanName);
}
//bean实例化
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
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);
}
});
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
beanCreation.end();
}
}
return adaptBeanInstance(name, beanInstance, requiredType);
}
getSingleton方法（在DefaultSingletonBeanRegistry中）
//
@Override
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
同样也是在DefaultSingletonBeanRegistry中
//在doGetBean方法中一开始获取bean时使用
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//从一级缓存（单例池）中获取
Object singletonObject = this.singletonObjects.get(beanName);
//isSingletonCurrentlyInCreation(beanName)：判断当前的bean是否在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
//如果二级缓存中也不存在bean且允许发生循环依赖（allowEarlyReference默认就是true，在注册 bean时就已经设置好了）
if (singletonObject == null && allowEarlyReference) {
//从三级缓存中获取提前暴露的bean
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//提前aop后加入到二级缓存中
//aop操作是在三级缓存singletonFactories中调用getObject方法来完成的。
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
//删掉三级缓存中暴露的bean
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
getObjectForBeanInstance（还是在AbstractBeanFactory中）
//如果是通过FactoryBean创建的bean，
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// 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.
/*
判断当前引用是否为工厂类引用，其实就是判断beanName是否以 & 为前缀，如果是就是工厂类引用。
public static boolean isFactoryDereference(String name) {
return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
}
*/
/*这个方法就是：如果当前是一个普通的bean实例，就直接返回这个实例；如果是工厂类的实例（beanName以&开头的，返回这个工厂类实例，不是这个工厂生产出的实例）
此处由getBean方法得知name，可能是普通bean的，也有可能是FactoryBean本身的。如果传入的 beanName是以&开头的就是获取工厂类bean本身。
*/
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
//getBean中使用了当前方法，传进的mbd为null。
if (mbd == null) {
//从缓存factoryBeanObjectCache中获取实例（factoryBeanObjectCache是FactoryBeanRegistrySupport类中的ConcurrentHashMap类型）
object = getCachedObjectForFactoryBean(beanName);
}
//如果在factoryBeanObjectCache仍然获取不到FactoryBean创建的bean
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)) {
//如果BeanFactory中有这个bean，从mergedBeanDefinitions这个缓存中获取FactoryBean创建的实例对象
//mergedBeanDefinitions中存放的是合成的bean，有父bean就获取父bean，没有父bean就返回bean本身
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//从FactoryBean中获取bean实例
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
这个还是要说一下bean继承（父bean和子bean）：
在上篇中的最后的那个preInstantiateSingletons方法中，调用getBean方法前有一句代码：
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
获取合成的bean（有父bean就获取父bean，没有父bean就获取bean本身）。
这里涉及到的就是 中的 parent 属性。
我们要知道bean的继承和类的继承不是一回事，但是这个思想还是有相似之处的。子bean会继承父bean 的所有配置，也可以覆盖一些配置，当然子bean也可以新增额外的配置。
具体的参考博客：https://blog.csdn.net/nuomizhende45/article/details/81158383中的bean继承的部分。
createBean（重点，创建bean实例）
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
//mbd是正在使用的bean
RootBeanDefinition mbdToUse = mbd;
// 确保 BeanDefinition 中的 Class 被加载
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
/*准备方法覆写，这里又涉及到一个概念：MethodOverrides，它来自于 bean 定义中的 <lookup-method /> 和 <replaced-method />*/
/*
<lookup-method />：一个单例bean通过调用此标签中的方法来获取一个多例bean时，那么获取到的这个bean始终是最新创建的bean
<replaced-method />：替换当前bean的类中的方法。
<replaced-method name="要被替换的目标方法" replacer="替换者：替换的bean的id"></replaced-method>
使用此标签时一定要实现接口MethodReplacer：
public class MyBeanReplacer implements MethodReplacer{
@Override
public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
System.out.println("我替换了原来的方法");
return null;
}
}
MyBeanReplacer就是替换者（要将它生成bean）
参考博客：https://blog.csdn.net/zhaozhirongfree1111/article/details/80394376
*/
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 让 InstantiationAwareBeanPostProcessor 在这一步有机会返回代理。
/*如果实现了InstantiationAwareBeanPostProcessor接口，bean是调用了此接口中的
postProcessAfterInitialization方法后返回的实例，如果在这个方法中设置的返回
值为null，跳过下面的if语句，否则进入到这个if语句，直接返回这个bean实例。*/
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 + "'");
}
/*如果没有实现InstantiationAwareBeanPostProcessor接口，或者是调用
postProcessAfterInitialization方法后返回的为null
*/
return beanInstance;
}
doCreateBean（重点）
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// BeanWrapper实例就是用来持有（存放）创建出来的bean对象的（使用了设计模式中的装饰者模式）
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//从factoryBean实例缓存中通过beanName获取bean的装饰器，然后将缓存中的bean装饰器删除
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
//如果没有单例bean就创建
if (instanceWrapper == null) {
//根据执行的bean使用对应的策略来创建新的实例，如：工厂方法构造函数主动注入、简单初始化
//将创建出的bean存放到bean装饰器中
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//在实例包装器中获取bean实例
Object bean = instanceWrapper.getWrappedInstance();
//获取bean的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
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.
//--------------------------------------------------------------------------
/*
earlySingletonExposure：是否要提前使用这个实例
此时的bean刚实例化完成，并没有生成完整的bean，所以此时的bean是正处于创建中的，即
isSingletonCurrentlyInCreation(beanName)为true，allowCircularReferences初始化为true
同时mbd为单例。
所以要将实例化后的bean装入到singletonFactory（三级缓存中）
isSingletonCurrentlyInCreation(beanName)：判断当前bean是否是在创建中
*/
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//将实例化的bean添加到三级缓存中（将实例化后的bean封装成ObjectFactory）（下面有这个方法的详解）
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
//() -> getEarlyBeanReference(beanName, mbd, bean)：exposedObject
}
//-------------------------------------------------------------------------
// Initialize the bean instance.
//对实例化后的bean进行初始化
Object exposedObject = bean;
try {
//填充属性（DI）（下面有这个方法的详解）
populateBean(beanName, mbd, instanceWrapper);//这里可能会发生循环依赖
//初始化和BeanPostProcessor 正常aop
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
//此时并没有添加到单例池中，所以要在三级缓存中获取未初始化的bean
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
//如果最终的对象是bean对象（没有进行aop，初始化后的对象就是实例化对象），直接将其赋值给exposedObject并返回
if (exposedObject == bean) {
//将实例对象转化成代理对象（earlySingletonReference是三级缓存中创建出的代理对象）
exposedObject = earlySingletonReference;
}
//如果exposedObject不是bean，说明在初始化中进行了aop操作，要添加aop需要的依赖的bean后才能返回
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(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 " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
//将其注册为可销毁的bean（bean的类中实现了DisposableBean接口，一次性bean，用完就销毁）
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;//返回的是代理对象
}
createBeanInstance（创建bean实例）
//创建bean实例
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
//确保此时实际解析了 bean 类。
Class<?> beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
//从beanDefinition中获取bean实例的提供者的实例，如果在这个提供者中能直接获取到bean就返回
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//使用工厂模式创建bean
/*
示例：
<bean id="messageService" class="com.xxx.service.MessageServiceFactory"
factory-method="createInstance"/>
*/
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
/*如果创建的是多例bean，那么在第一次创建这个bean（不是bean实例）之后，就会记录这个bean是否被创建过（resolved），同时记录是否是采用构造注入（autowireNecessary）。这样我们可以从第一次创建知道，采用无参构造函数，还是构造函数依赖注入 来完成实例化*/
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);
}
}
// Candidate constructors for autowiring?
/*
如果用户配置了构造器“<constructor-arg>”，那么就会根据，这个构造器去实例化bean。如果没有配置，就选择bean类中的默认的构造器。
*/
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
//此处是选择默认构造器，同时这个bean类中的默认构造器是有参构造器时，进行实例化bean，
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
//默认构造器是无参构造时去实例化bean
return instantiateBean(beanName, mbd);
}
instantiateBean（AbatractAutowireCapableBeanFactory中）
//无参构造函数构造实例
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
//实例化bean
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
instantiate（在SimpleInstantiationStrategy中）
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (bd.getMethodOverrides().isEmpty()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
//获取一个解析过的构造器或者是工厂方法
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
@Override
public Constructor<?> run() throws Exception {
return clazz.getDeclaredConstructor((Class[]) null);
}
});
}
else {
//获取一个无参构造
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Exception ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
//通过无参构造实例化这个类
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
instantiateClass（在BeanUtils中）
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
//设置这个构造器可访问（前提是这个构造器必须是public的）
ReflectionUtils.makeAccessible(ctor);
//实例化当前类
return ctor.newInstance(args);
}
catch (InstantiationException ex) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
}
catch (IllegalAccessException ex) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
}
catch (IllegalArgumentException ex) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
}
catch (InvocationTargetException ex) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
}
}
addSingletonFactory（在doCreateBean中使用）
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);//从三级缓存中添加bean
this.earlySingletonObjects.remove(beanName);//删除这个在二级缓存中的bean
//将单例bean注册到一个缓存中（set集合）
this.registeredSingletons.add(beanName);
}
}
}
populateBean（填充属性，在 AbstractAutowireCapableBeanFactory：AbstractBeanFactory的子类）
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
//当前bean的属性和属性值就封装在PropertyValues中（pvs类型就是MutablePropertyValues的）
PropertyValues pvs = mbd.getPropertyValues();
//传进来的bw不会为null的
if (bw == null) {
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
//是否继续去填充属性
boolean continueWithPropertyPopulation = true;
//当前的bean不是合成的，同时当前容器中存在InstantiationAwareBeanPostProcessor的bean实例
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
/*此处就是调用实现InstantiationAwareBeanPostProcessor接口后的 postProcessAfterInstantiation方法*/
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
/*如果实现postProcessAfterInstantiation方法的返回值为false，就将 continueWithPropertyPopulation设置为false,表示不填充属性
*/
continueWithPropertyPopulation = false;
break;
}
}
}
}
//continueWithPropertyPopulation为false时，不填充属性，此方法返回
if (!continueWithPropertyPopulation) {
return;
}
/*自动装配的方式填充属性*/
/*bean标签中是否设置了byname或bytype属性。如果设置byname，就按byname的方式装配；如果是设置了 byType属性，就按byType属性装配*/
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
//按byname装配
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
//按bytype属性装配
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
//这个一般都为true，因为spring在普通bean初始化前就创建很多的后置处理器的bean
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
//既然hasInstAwareBpps为true，那么这段代码就执行
if (hasInstAwareBpps || needsDepCheck) {
/*从给定的 BeanWrapper 中提取一组过滤的 PropertyDescriptors，排除在忽略的依赖接口上定义的忽略的依赖类型或属性。*/
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
/*此处就是调用实现InstantiationAwareBeanPostProcessor接口后的 postProcessPropertyValues方法*/
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
//如果调用postProcessPropertyValues方法后返回的值为null，直接返回
if (pvs == null) {
return;
}
}
}
}
//调试时这个为false
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
//添加正常注入的属性值（不是nyname或bytype的）
applyPropertyValues(beanName, mbd, bw, pvs);
}
autowireByName
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
//单例池如果包含propertyName的bean，就将其获取
if (containsBean(propertyName)) {
Object bean = getBean(propertyName);
//将这个bean的beanName填充到当前bean的属性中
pvs.add(propertyName, bean);
//将propertyName的bean注册到容器中（首先将propertyName的值，也就是这个bean的名称规范化）
registerDependentBean(propertyName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
autowireByType
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//类型转换器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
if (Object.class != pd.getPropertyType()) {
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
for (String autowiredBeanName : autowiredBeanNames) {
registerDependentBean(autowiredBeanName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
applyPropertyValues
//填充property标签中的值
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
//pvs为空时，说明没有属性值去填充，直接返回
if (pvs == null || pvs.isEmpty()) {
return;
}
//MutablePropertyValues：可变的属性值，PropertyValues接口的默认实现。允许对属性进行简单操作
MutablePropertyValues mpvs = null;
//存放PropertyValue对象集合，每个PropertyValue中存放着当前bean中的一个属性信息
List<PropertyValue> original;
//如果有安全管理器 且 bw是BeanWrapperImpl的实例（调试时没有安全管理器）
if (System.getSecurityManager() != null) {
if (bw instanceof BeanWrapperImpl) {
//设置bw的安全上下文为工厂的访问控制上下文
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
}
//从上面得知，pvs就是MutablePropertyValues的
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
//返回此持有者是否仅包含转换后的值 (true)、或是否仍需要转换值 (false)。（调试时为false）
if (mpvs.isConverted()) {
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
//获取mpvs的PropertyValue对象列表
original = mpvs.getPropertyValueList();
}
else {
original = Arrays.asList(pvs.getPropertyValues());
}
//获取一个自定义的类型转化器。调试时没有自定义的类型转化器，所以为null
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
//设置类型转化器为bean的包装器（BeanWrapperImpl）
converter = bw;
}
/*
BeanDefinitionValueResolver：
用于 bean 工厂实现的帮助类，将 bean 定义对象中包含的值解析为应用于目标 bean 实例的实际值。
*/
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
//创建一个用于存放转化后属性值的集合
List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
boolean resolveNecessary = false;
//从original集合中遍历当前bean的每一个属性对应的PropertyValue
for (PropertyValue pv : original) {
//如果值已经被转换，直接添加到list集合deepCopy中（这里仍为false）
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
//获取当前属性名
String propertyName = pv.getName();
//获取当前属性的原始值
/*如果是ref属性填充，originalValue就是RunTimeBeanReference型；如果是value属性填充，就是 TypedStringValue类型*/
Object originalValue = pv.getValue();
//对bean的属性的原始值进行解析（如果是一个非普通属性（bean类型），解析出的属性值为bean实例）
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
/*
isWritableProperty：判断属性是否可写
isNestedOrIndexedProperty：检查给定的属性路径是否指示索引或嵌套属性。
*/
//调试后convertible为true
boolean convertible = 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) {
//将转换后的值设置到当前PropertyValue中
if (convertible) {
pv.setConvertedValue(convertedValue);
}
//添加到deepCopy集合中
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
//设置所有解析后的属性值
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
resolveValueIfNecessary
public Object resolveValueIfNecessary(Object argName, Object value) {
// We must check each value to see whether it requires a runtime reference
// to another bean to be resolved.
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
//这里就是对bean标签中ref属性的填充（没有这样的bean就创建这个bean）
return resolveReference(argName, ref);
}
else if (value instanceof RuntimeBeanNameReference) {
String refName = ((RuntimeBeanNameReference) value).getBeanName();
refName = String.valueOf(doEvaluate(refName));
if (!this.beanFactory.containsBean(refName)) {
throw new BeanDefinitionStoreException(
"Invalid bean name '" + refName + "' in bean reference for " + argName);
}
return refName;
}
else if (value instanceof BeanDefinitionHolder) {
// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
}
else if (value instanceof BeanDefinition) {
// Resolve plain BeanDefinition, without contained name: use dummy name.
BeanDefinition bd = (BeanDefinition) value;
String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
ObjectUtils.getIdentityHexString(bd);
return resolveInnerBean(argName, innerBeanName, bd);
}
else if (value instanceof ManagedArray) {
// May need to resolve contained runtime references.
ManagedArray array = (ManagedArray) value;
Class<?> elementType = array.resolvedElementType;
if (elementType == null) {
String elementTypeName = array.getElementTypeName();
if (StringUtils.hasText(elementTypeName)) {
try {
elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
array.resolvedElementType = elementType;
}
catch (Throwable ex) {
// Improve the message by showing the context.
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error resolving array type for " + argName, ex);
}
}
else {
elementType = Object.class;
}
}
return resolveManagedArray(argName, (List<?>) value, elementType);
}
else if (value instanceof ManagedList) {
// May need to resolve contained runtime references.
return resolveManagedList(argName, (List<?>) value);
}
else if (value instanceof ManagedSet) {
// May need to resolve contained runtime references.
return resolveManagedSet(argName, (Set<?>) value);
}
else if (value instanceof ManagedMap) {
// May need to resolve contained runtime references.
return resolveManagedMap(argName, (Map<?, ?>) value);
}
else if (value instanceof ManagedProperties) {
Properties original = (Properties) value;
Properties copy = new Properties();
for (Map.Entry<Object, Object> propEntry : original.entrySet()) {
Object propKey = propEntry.getKey();
Object propValue = propEntry.getValue();
if (propKey instanceof TypedStringValue) {
propKey = evaluate((TypedStringValue) propKey);
}
if (propValue instanceof TypedStringValue) {
propValue = evaluate((TypedStringValue) propValue);
}
copy.put(propKey, propValue);
}
return copy;
}
else if (value instanceof TypedStringValue) {
//用于处理bean标签中使用value属性填充的值
TypedStringValue typedStringValue = (TypedStringValue) value;
Object valueObject = evaluate(typedStringValue);
try {
Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
if (resolvedTargetType != null) {
return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
}
else {
return valueObject;
}
}
catch (Throwable ex) {
// Improve the message by showing the context.
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error converting typed String value for " + argName, ex);
}
}
else {
return evaluate(value);
}
}
resolveReference（在BeanDefinitionValueResolver中）
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
try {
String refName = ref.getBeanName();
refName = String.valueOf(doEvaluate(refName));
//ref.isToParent()判断这个引用是否是当前容器的父容器的引用（没有父容器就是false）
if (ref.isToParent()) {
if (this.beanFactory.getParentBeanFactory() == null) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Can't resolve reference to bean '" + refName +
"' in parent factory: no parent factory available");
}
return this.beanFactory.getParentBeanFactory().getBean(refName);
}
else {
//将ref中的bean创建实例，放到单例池中
Object bean = this.beanFactory.getBean(refName);
/*将refName对应的bean作为当前beanName的bean的依赖bean，添加到一个依赖集合 dependentBeanMap中。ConcurrentHashMap类型，在DefaultSingletonBeanRegistry中
在这个属性中存放的是 依赖的beanName->被依赖的beanName的集合*/
this.beanFactory.registerDependentBean(refName, this.beanName);
return bean;
}
}
catch (BeansException ex) {
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
}
}
initializeBean（初始化，在AbstractAutowireCapableBeanFactory中）
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
//如果当前bean实现了xxxAware接口，那么就在此处调用xxxAware接口实现的方法
//存在安全管理器时，进入，上面调试时，没有设置安全管理器，所以先不看这段
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
//调用Aware实现的方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;//此时的bean就是填充属性后的bean
if (mbd == null || !mbd.isSynthetic()) {
/*如果容器中实现了BeanPostProcessor接口，那么就会调用这个接口实现的 postProcessBeforeInitialization方法*/
/*在这个方法中会调用一个叫做InitDestroyAnnotationBeanPostProcessor的处理器，这个处理器中的postProcessBeforeInitialization方法中就会执行@PostConstruct注解的方法*/
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
/*在这个方法中，如果当前bean实现了InitializingBean接口，那么就会先调用实现InitializingBean接口时实现的afterPropertiesSet方法。然后再调用bean标签中init-method属性的方法（当然如果设置了这个属性）
*/
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
/*如果容器中实现了BeanPostProcessor接口，那么就会调用这个接口实现的 postProcessAfterInitialization方法*/
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
getSingleton(String beanName, ObjectFactory<?> singletonFactory)
//bean初始化完成后，将bean的代理对象放入到单例池中
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//从单例池中获取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//如果当前单例bean正在销毁中，那么这个bean就无效，抛出异常
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<>();
}
try {
//获取初始化后的bean
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;
}
//同上面的beforeSingletonCreation方法，这两个方法主要是判断bean是否在创建中，如果不是就抛异常
afterSingletonCreation(beanName);
}
if (newSingleton) {
//向单例池中添加bean
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
addSingleton
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
//添加到单例池中
this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
//删掉三级、二级缓存中的bean
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
//根据beanName注册单例bean，说明这个名字的单例bean已经存在
this.registeredSingletons.add(beanName);
}
}
599
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
