/**
* 根据beanName获取bean
*/
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
doGetBean
/**
* 获取bean
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//1.对beanName进行处理
final String beanName = transformedBeanName(name);
Object bean;
// 2.尝试从缓存中获取beanName对应的实例
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 + "'");
}
}
// 3.如果beanName的实例存在于缓存中
// 3.1 返回beanName对应的实例对象（主要用于FactoryBean的特殊处理，普通Bean会直接返回sharedInstance本身）
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 4.scope为prototype的循环依赖校验：如果beanName已经正在创建Bean实例中，
//而此时我们又要再一次创建beanName的实例，则代表出现了循环依赖，需要抛出异常。
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 5.获取parentBeanFactory
BeanFactory parentBeanFactory = getParentBeanFactory();
// 5.1 如果parentBeanFactory存在，并且beanName在当前BeanFactory不存在Bean定义，则尝试从parentBeanFactory中获取bean实例
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 5.2 将别名解析成真正的beanName
String nameToLookup = originalBeanName(name);
// 5.3 尝试在parentBeanFactory中获取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);
}
}
// 6.如果不是仅仅做类型检测，而是创建bean实例，这里要将beanName放到alreadyCreated缓存
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 7.根据beanName重新获取MergedBeanDefinition（步骤6将MergedBeanDefinition删除了，这边获取一个新的）
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 7.1 检查MergedBeanDefinition
checkMergedBeanDefinition(mbd, beanName, args);
// 8.拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
// 8.1 遍历当前bean依赖的bean名称集合
for (String dep : dependsOn) {
// 8.2 检查dep是否依赖于beanName，即检查是否存在循环依赖
if (isDependent(beanName, dep)) {
// 8.3 如果是循环依赖则抛异常
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 8.4 将dep和beanName的依赖关系注册到缓存中
registerDependentBean(dep, beanName);
try {
// 8.5 获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 9.针对不同的scope进行bean的创建
if (mbd.isSingleton()) {
// 9.1 scope为singleton的bean创建（传入了一个ObjectFactory，并且重写了getObject方法）
sharedInstance = getSingleton(beanName, () -> {
try {
// 9.1.1 创建Bean实例
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
// 9.1.2 返回beanName对应的实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// 9.2 scope为prototype的bean创建
Object prototypeInstance = null;
try {
// 9.2.1 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
beforePrototypeCreation(beanName);
// 9.2.2 创建Bean实例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 9.2.3 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
afterPrototypeCreation(beanName);
}
// 9.2.4 返回beanName对应的实例对象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 9.3 其他scope的bean创建，可能是request之类的
// 9.3.1 根据scopeName，从缓存拿到scope实例
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 {
// 9.3.2 其他scope的bean创建（传入了一个ObjectFactory，并且重写了getObject方法）
Object scopedInstance = scope.get(beanName, () -> {
// 9.3.3 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
beforePrototypeCreation(beanName);
try {
// 9.3.4 创建bean实例
return createBean(beanName, mbd, args);
}
finally {
// 9.3.5 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
afterPrototypeCreation(beanName);
}
});
// 9.3.6 返回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实例过程中出现异常，则将beanName从alreadyCreated缓存中移除
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 10.检查所需类型是否与实际的bean对象的类型匹配
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 10.1 类型不对，则尝试转换bean类型
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());
}
}
// 11.返回创建出来的bean实例对象
return (T) bean;
}
getSingleton
/**
* 根据beanName获取单例bean
*/
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
/**
* 获取一个单例bean
* allowEarlyReference 是否进行创建早期单例对象
*/
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//1.从单例对象缓存中获取beanName对应的单例对象
Object singletonObject = this.singletonObjects.get(beanName);
// 2.如果单例对象缓存中没有，并且该beanName对应的单例bean正在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 3.加锁进行操作
synchronized (this.singletonObjects) {
// 4.从早期单例对象缓存中获取单例对象（之所称成为早期单例对象，是因为earlySingletonObjects里
// 的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作）
singletonObject = this.earlySingletonObjects.get(beanName);
// 5.如果在早期单例对象缓存中也没有，并且允许创建早期单例对象引用
if (singletonObject == null && allowEarlyReference) {
// 6.从单例工厂缓存中获取beanName的单例工厂
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 7.如果存在单例对象工厂，则通过工厂创建一个单例对象
singletonObject = singletonFactory.getObject();
// 8.将通过单例对象工厂创建的单例对象，放到早期单例对象缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
// 9.移除该beanName对应的单例对象工厂，因为该单例工厂已经创建了一个实例对象，并且放到earlySingletonObjects缓存了，
// 因此，后续获取beanName的单例对象，可以通过earlySingletonObjects缓存拿到，不需要在用到该单例工厂
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject; //返回对象
}
/**
* 判断对象是否正在创建
*/
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
getObjectForBeanInstance(sharedInstance, name, beanName, null)
/**
* 获取bean实例
*/
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 判断name非空并且以FACTORY_BEAN_PREFIX开头
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
//若bean为NullBean 直接返回
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
//以FACTORY_BEAN_PREFIX开头，bean却不是FactoryBean 的直接抛出异常
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true; //设置isFactoryBean == true
}
return beanInstance; //返回FactoryBean实例
}
// 如果beanInstance不是FactoryBean（也就是普通bean），则直接返回beanInstance
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
//FactoryBean 但不是以FACTORY_BEAN_PREFIX开头的 需要获取FactoryBean对应的bean实例
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
object = getCachedObjectForFactoryBean(beanName); //从factoryBeanObjectCache获取bean
}
if (object == null) {
// 只有beanInstance是FactoryBean才能走到这边，因此直接强转
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {
//mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinition
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
//从FactoryBean获取对象实例
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
/**
* 从factoryBeanObjectCache获取bean
*/
@Nullable
protected Object getCachedObjectForFactoryBean(String beanName) {
return this.factoryBeanObjectCache.get(beanName);
}
/**
* 根据beanName获取RootBeanDefinition
*/
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
//1.检查beanName对应的MergedBeanDefinition是否存在于缓存中
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
return mbd;//2.如果存在于缓存中则直接返回
}
/*3.如果不存在于缓存中
* 3.1 getBeanDefinition(beanName)： 获取beanName对应的BeanDefinition，从beanDefinitionMap缓存中获取
* 3.2 getMergedBeanDefinition: 根据beanName和对应的BeanDefinition，获取MergedBeanDefinition
*/
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
/**
* 根据beanName和对应的BeanDefinition，获取MergedBeanDefinition
*/
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
/**
* 根据beanName和对应的BeanDefinition，获取MergedBeanDefinition
*/
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
//1.加锁再进行操作
synchronized (this.mergedBeanDefinitions) {
//用于存储bd的MergedBeanDefinition，也就是该方法的结果
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
if (containingBd == null) {
//2.检查beanName对应的MergedBeanDefinition是否存在于缓存中
//从mergedBeanDefinitions中获取
mbd = this.mergedBeanDefinitions.get(beanName);
}
// 3.如果beanName对应的MergedBeanDefinition不存在于缓存中
if (mbd == null || mbd.stale) {
previous = mbd;
mbd = null;
//4.如果bd的parentName为空，代表bd没有父定义，无需与父定义进行合并操作，也就是bd的MergedBeanDefinition就是bd本身（可能需要转成RootBeanDefinition）
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
// 4.1 如果bd的类型为RootBeanDefinition，则bd的MergedBeanDefinition就是bd本身，则直接克隆一个副本
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
// 4.2 否则，将bd作为参数，构建一个RootBeanDefinition。
// 正常使用下，BeanDefinition在被加载后是GenericBeanDefinition或ScannedGenericBeanDefinition
mbd = new RootBeanDefinition(bd);
}
}
else {
// 5.否则，bd存在父定义，需要与父定义合并
BeanDefinition pbd;
try {
// 5.1 获取父定义的beanName
String parentBeanName = transformedBeanName(bd.getParentName());
// 5.2 如果父定义的beanName与该bean的beanName不同
if (!beanName.equals(parentBeanName)) {
// 5.3 获取父定义的MergedBeanDefinition（因为父定义也可能有父定义，也就是bd的爷爷定义...）
pbd = getMergedBeanDefinition(parentBeanName); //回调，获取到最上级的类定义
}
else {
// 5.4 如果父定义的beanName与bd的beanName相同，则拿到父BeanFactory，
// 只有在存在父BeanFactory的情况下，才允许父定义beanName与自己相同，否则就是将自己设置为父定义
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
// 5.5 如果父BeanFactory是ConfigurableBeanFactory，则通过父BeanFactory获取父定义的MergedBeanDefinition
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
// 5.6 如果父BeanFactory不是ConfigurableBeanFactory，则抛异常
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without an AbstractBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// 5.7 使用父定义pbd构建一个新的RootBeanDefinition对象（深拷贝）
mbd = new RootBeanDefinition(pbd);
// 5.8 使用bd覆盖父定义
mbd.overrideFrom(bd);
}
// 6.如果没有配置scope，则设置成默认的singleton
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
}
// 7.如果containingBd不为空 && containingBd不为singleton && mbd为singleton，则将mdb的scope设置为containingBd的scope
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// 8.将beanName与mbd放到mergedBeanDefinitions缓存，以便之后可以直接使用
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
if (previous != null) { //即mbd != null && mbd.stale为true
copyRelevantMergedBeanDefinitionCaches(previous, mbd); //copyRelevantMergedBeanDefinitionCaches处理mbd
}
// 9.返回MergedBeanDefinition
return mbd;
}
}
markBeanAsCreated
/**
* 将beanName放入带创建的缓存中
*/
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) { //如果已包含，跳过此步骤
synchronized (this.mergedBeanDefinitions) { //加锁
if (!this.alreadyCreated.contains(beanName)) { //二次校验
// 给beanName对应的RootBeanDefinition状态stale设置为true
clearMergedBeanDefinition(beanName);
// 将beanName添加到alreadyCreated缓存中，代表该beanName的bean实例已经创建（或即将创建）
this.alreadyCreated.add(beanName);
}
}
}
}
isDependent(beanName, dep)
/**
* 检查dep是否依赖于beanName，即检查是否存在循环依赖
*/
protected boolean isDependent(String beanName, String dependentBeanName) {
synchronized (this.dependentBeanMap) {
return isDependent(beanName, dependentBeanName, null);
}
}
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
// 已经检查过的直接跳过
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
// 1.将别名解析为真正的名称
String canonicalName = canonicalName(beanName);
// 2.拿到依赖canonicalName的beanName集合
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
// 3.如果dependentBeans为空，则两者必然还未确定依赖关系，返回false
if (dependentBeans == null) {
return false;
}
// 4.如果dependentBeans包含dependentBeanName，则表示两者已确定依赖关系，返回true
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
// 5.循环检查，即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的（即隔层依赖）
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
// 6.已经检查过的添加到alreadySeen，避免重复检查
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
registerDependentBean(dep, beanName)
public void registerDependentBean(String beanName, String dependentBeanName) {
// 解析别名
String canonicalName = canonicalName(beanName);
synchronized (this.dependentBeanMap) {
// 拿到依赖canonicalName的beanName集合
Set<String> dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
// 将dependentBeanName添加到dependentBeans缓存中，若添加失败标识已存在直接返回
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
synchronized (this.dependenciesForBeanMap) {
// 拿到依赖dependentBeanName的beanName集合
Set<String> dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
// 将canonicalName添加到dependenciesForBean缓存中
dependenciesForBean.add(canonicalName);
}
}
getSingleton
/**
* 创建单例对象
*/
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null"); //非空校验
//加锁，避免重复创建单例对象
synchronized (this.singletonObjects) {
// 2.首先检查beanName对应的bean实例是否在缓存中存在，如果已经存在，则直接返回
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 3.beanName对应的bean实例不存在于缓存中，则进行Bean的创建
if (this.singletonsCurrentlyInDestruction) {
//4.当bean工厂的单例处于destruction状态时，不允许进行单例bean创建，抛出异常
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 + "'");
}
// 5.创建单例前的操作
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 6.执行singletonFactory的getObject方法获取bean实例
singletonObject = singletonFactory.getObject();
// 标记为新的单例对象
newSingleton = true;
}
catch (IllegalStateException ex) {
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;
}
// 7.创建单例后的操作
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 8.如果是新的单例对象，将beanName和对应的bean实例添加到缓存中（singletonObjects、registeredSingletons）
addSingleton(beanName, singletonObject);
}
}
// 9.返回单例对象
return singletonObject;
}
}
beforeSingletonCreation(beanName)与afterSingletonCreation(beanName)
/**
* inCreationCheckExclusions存在beanName 则 添加beanName到singletonsCurrentlyInCreation
* 不满足条件或操作失败就抛出异常
*/
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
/**
* inCreationCheckExclusions存在beanName 则 从singletonsCurrentlyInCreation中移除
* 不满足条件或操作失败就抛出异常
*/
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
addSingleton
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 1.添加到单例对象缓存
this.singletonObjects.put(beanName, singletonObject);
// 2.将单例工厂缓存移除（已经不需要）
this.singletonFactories.remove(beanName);
// 3.将早期单例对象缓存移除（已经不需要）
this.earlySingletonObjects.remove(beanName);
// 4.添加到已经注册的单例对象缓存
this.registeredSingletons.add(beanName);
}
}