乐趣区

Spring-获取单例流程二

jiezi

读完这篇文章你将会收获到

  • Spring 中 prototype 类型的 bean 如何做循环依赖检测
  • Spring 中 singleton 类型的 bean 如何做循环依赖检测

前言

继上一篇文章 Spring 获取单例流程(一) 我们这次继续往下分析一下后面的流程

上一篇文章中我们说到，首先我们根据 name 找到其对应的 beanName、然后去缓存中看是否已经创建了 / 创建中这个对应的 bean，如果在缓存中找到了这个 bean、那么我们需要对这个 bean 可能进行一些处理，比如说用户想要的是一个普通的 bean、但是在 Spring 缓存中找到的是一个 factoryBean、这个时候就要调用 fatoryBean 的 getObject 方法以及对应的一些前置方法以及回调等。

那么如果我们在缓存中找不到这个 bean 那么流程又是怎么样？这个就是这篇文章要跟大家一起分享的

源码分析

if (sharedInstance != null && args == null) {
   // 这里被我删除了一些 spring  的 log
   // 处理一下 factory bean 的情况、包括从 factory beans 的缓存中获取、或者重新调用 factory bean 的 get bean 方法 包括一些回调
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
   // 从 上面的 getSingleton 拿不到对象的 bean、说明这个 bean 的 scope 要么不是 singleton 要这个 bean 是 singleton 但是没有初始化一句
     //  因为 Spring 只解决单例模式下得循环依赖，在原型模式下如果存在循环依赖则会抛出异常
   // 这里的循环依赖检查使用的 是 threadLocal 因为 prototype 类型的只是
   if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);
   }

    // 如果容器中没有找到，则从父类容器中加载
   BeanFactory parentBeanFactory = getParentBeanFactory();
   // parentBeanFactory 不为空且 beanDefinitionMap 中不存该 name 的 BeanDefinition
   if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
      // Not found -> check parent.
      // 这里只是找出他的真正的 beanName、并没有去掉 factory bean 的前缀
      String nameToLookup = originalBeanName(name);
      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);
      }
   }
  .......
  .......
  ........
}

第一步 就是判断这个是否是一个 prototype 类型的 bean，如果是并且正在创建中、那么就抛出一个循环依赖的异常

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
  // prototypesCurrentlyInCreation 是一个 threadLocal
   Object curVal = this.prototypesCurrentlyInCreation.get();
   return (curVal != null &&
         (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}

每一个 prototype 的 bean 创建的时候都会调用下面这个方法

protected void beforePrototypeCreation(String beanName) {Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal == null) {this.prototypesCurrentlyInCreation.set(beanName);
   } else if (curVal instanceof String) {Set<String> beanNameSet = new HashSet<>(2);
      beanNameSet.add((String) curVal);
      beanNameSet.add(beanName);
      this.prototypesCurrentlyInCreation.set(beanNameSet);
   } else {Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.add(beanName);
   }
}

curVal 要么是一个 String 要么是一个 Set , 而在创建 prototype bean 完成之后

protected void afterPrototypeCreation(String beanName) {Object curVal = this.prototypesCurrentlyInCreation.get();
        if (curVal instanceof String) {this.prototypesCurrentlyInCreation.remove();
        } else if (curVal instanceof Set) {Set<String> beanNameSet = (Set<String>) curVal;
            beanNameSet.remove(beanName);
            if (beanNameSet.isEmpty()) {this.prototypesCurrentlyInCreation.remove();
            }
        }
    }

可以看到 Spring 使用 ThreadLocal 去做一个循环依赖的检测、我们在 Spring 资源加载的源码分析里面也提及到了、也是使用 ThreadLocal 进行一个资源的循环引用的检测 Spring 容器的初始化

第二步 则是判断当前的 beanFactory 是否有父容器(父 beanFactory) , 如果有并且 beanName 的 beanDefinition 不存在当前的 beanFactory 中，那么则尝试在父容器中去获取这个 bean

我们继续往下看下面的代码

// 如果不是仅仅做类型检查则是创建 bean，标记这个 bean 已经创建了或者将要被创建
if (!typeCheckOnly) {markBeanAsCreated(beanName);
}

try {

   //  从容器中获取 beanName 相应的 GenericBeanDefinition，并将其转换为 RootBeanDefinition
   final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
   //  检查给定的合并的 BeanDefinition
   checkMergedBeanDefinition(mbd, beanName, args);

   // Guarantee initialization of beans that the current bean depends on.
   // 处理所依赖的 bean
   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 + "'");
         }
         // 注册
         registerDependentBean(dep, beanName);
         try {
            // 看看我依赖的大佬好了没
            getBean(dep);
         } catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "'"+ beanName +"' depends on missing bean '"+ dep +"'", ex);
         }
      }
   }
  ......
  ......

第三步 则是从 BeanDefinitionRegistry 中获取注册的 BeanDefinition 继而获取这个 bean 所要依赖的其他 bean，遍历其所依赖的 bean、判断是否循环依赖了

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;}

   String canonicalName = canonicalName(beanName);
   // 找出依赖这个 beanName 的集合
   Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);

   // 没有人依赖这个 beanName
   if (dependentBeans == null) {return false;}

   // 哦嚯、beanName 依赖的 bean、也依赖着 beanName、完蛋
   if (dependentBeans.contains(dependentBeanName)) {return true;}

   // 看看依赖 beanName 的 其他依赖、有没有被 dependentBeanName 依赖
   // A 想依赖 F、BCDE 依赖着 A、那么我们现在来到这一步、已经确定了 F 不依赖 A、那么我们要看看 F 是否依赖 BCDE、如果依赖、那么就是循环依赖了
   for (String transitiveDependency : dependentBeans) {if (alreadySeen == null) {alreadySeen = new HashSet<>();
      }
      alreadySeen.add(beanName);
      if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {return true;}
   }
   return false;
}

每一个 bean 创建之前都会注册其依赖关系、主要由两个 Map 组成、一个是 key 为被依赖者，value 为依赖者集合，另一个则是 key 为依赖者，value 为被依赖者集合，比如说 beanA 依赖着 beanB 和 beanC

key 为被依赖者 value 为依赖者集合
beanB ---> beanA
beanC ---> beanA
key 为依赖者，value 为被依赖者集合
beanA ---> beanB,beanC

第四步 则是去注册依赖关系，也就是往上面的两个 Map 中存放数据

public void registerDependentBean(String beanName, String dependentBeanName) {String canonicalName = canonicalName(beanName);
        // 在这个里面加上 这个依赖我的人
        synchronized (this.dependentBeanMap) {
            Set<String> dependentBeans =
                    this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));

            if (!dependentBeans.add(dependentBeanName)) {return;}
        }

        // 在这里将我依赖的 那个大佬放进去我依赖的列表中
        synchronized (this.dependenciesForBeanMap) {
            Set<String> dependenciesForBean =
                    this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
            dependenciesForBean.add(canonicalName);
        }
    }

最后的 getBean 则回到我们最初的起点

getBean(dep);

今天我们就先分析到这里、后续的话我们在后面的文章继续探讨。今天我们大致分析了

总结

  • 根据参数中的 name 找出对应的 beanName、无论这个 name 是别名或者是一个 factoryBean 的 beanName

  • 查看缓存中是否包含这个 beanName 对象

    • 先从一级缓存 singletonObjects 中看看有没有
    • 然后从二级缓存 earlySingletonObjects
    • 都没有的话再从三级缓存 singletonFactories 中看看有没有

  • 如果缓存中有 bean、那么我们还是需要处理一下这个 bean

    • 如果 Spring 缓存中返回的 bean 是 factoryBean、而用户也想要的是一个 beanFactory (参数 name 中的前缀是 & )、那么我们直接返回
    • 如果 Spring 缓存中返回的 bean 是普通的 bean、而用户也想要的是一个普通的 bean、那么就直接返回
    • 如果 Spring 缓存中返回的 bean 是一个 factoryBean、而用户想要的是一个普通的 bean、那么我们就要从 factoryBean 中获取这个 bean
    • 而从 factoryBean 中获取这个 bean 的过程中、需要调用到前置处理、后置处理和我们常用的接口回调 BeanPostProcessor
  • 如果缓存中没有 bean、则判断是否是 prototype 类型并且循环依赖
  • 如果没有则尝试能否在父容器中找到该 bean
  • 如果父容器也没有则获取该 beanName 对应的 beanDefinition 找出其依赖的 beanName
  • 判断该 beanName 与 依赖的 beanName 是否循环依赖、没有则注册其依赖关系并调用 getBean 方法去创建依赖的 beanName

退出移动版