Spring bean源码讲解

Spring bean的加载

Spring的bean加载

• Spring的容器架构
  Spring容器架构看之前帖子
• Spring的bean的流程
  

finishBeanFactoryInitialization()，注释上面写着 **Instantiate all remaining (non-lazy-init) singletons**，意味着非延迟加载的类，将在这一步实例化，完成类的加载。

**而我们使用到 ****context.getBean("beanName")**方法，如果对应的 **bean** 是非延迟加载的，那么直接就能拿出来进行使用，而延迟加载的 **bean** 就需要上面的步骤进行类的加载，加载完之后才能进行使用。Spring只是暴露了简单的接口给调用者。

加载流程：

• 从开始的getbean入口进行分析

  ApplicationContext context = new ClassPathXmlApplicationContext("配置文件xml");
     context.getBean("bean名字");
  

• 1、先获取bean，调用AbstractBeanFactory的doGetBean
  doGetBean有四个参数：

  name：bean的名称
  requiredType： 返回的类型
  args： 传递的构造参数
  typeCheckOnly： 检查类型

  protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
      //获取beanName，这边有三种形式，一个是原始的beanName，一个是加了&的，一个是别名
      final String beanName = transformedBeanName(name);
      Object bean;
  
      // Eagerly check singleton cache for manually registered singletons.
      // 是否已经创建了
      Object sharedInstance = getSingleton(beanName);
      //已经创建了，且没有构造参数，进入这个方法，如果有构造参数，往else走，也就是说不从获取bean，而直接创建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，直接返回，是FactoryBean，返回他的getObject
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
      }
  
      else {
          // Fail if we're already creating this bean instance:
          // We're assumably within a circular reference.
          // 没创建过bean或者是多例的情况或者有参数的情况
          // 创建过Prototype的bean，会循环引用，抛出异常，单例才尝试解决循环依赖的问题
          if (isPrototypeCurrentlyInCreation(beanName)) {
              throw new BeanCurrentlyInCreationException(beanName);
          }
  
          // Check if bean definition exists in this factory.
          BeanFactory parentBeanFactory = getParentBeanFactory();
          // 父容器存在，本地没有当前beanName，从父容器取
          if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
              // Not found -> check parent.
              // 处理后，如果是加&，就补上&
              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);
              }
          }
  
          if (!typeCheckOnly) {
              // typeCheckOnly为false，将beanName放入alreadyCreated中
              markBeanAsCreated(beanName);
          }
  
          try {
              // 获取BeanDefinition
              final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
              // 抽象类检查
              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) {
                      // 检查是否循环依赖，a依赖b，b依赖a。包括传递的依赖，比如a依赖b，b依赖c，c依赖a
                      if (isDependent(beanName, dep)) {
                          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                  "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                      }
                      // 注册依赖关系
                      registerDependentBean(dep, beanName);
                      try {
                          // 初始化依赖的bean
                          getBean(dep);
                      }
                      catch (NoSuchBeanDefinitionException ex) {
                          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                  "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                      }
                  }
              }
  
              // Create bean instance.
              // 如果是单例
              if (mbd.isSingleton()) {
                  sharedInstance = getSingleton(beanName, () -> {
                      try {
                          // 创建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.
                          destroySingleton(beanName);
                          throw ex;
                      }
                  });
                  // 如果是普通bean，直接返回，是FactoryBean，返回他的getObject
                  bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
              }
  
              else if (mbd.isPrototype()) {
                  // It's a prototype -> create a new instance.
                  Object prototypeInstance = null;
                  try {
                      // 加入prototypesCurrentlyInCreation，说明正在创建
                      beforePrototypeCreation(beanName);
                      //创建bean
                      prototypeInstance = createBean(beanName, mbd, args);
                  }
                  finally {
                      // 移除prototypesCurrentlyInCreation，说明已经创建结束
                      afterPrototypeCreation(beanName);
                  }
                  // 如果是普通bean，直接返回，是FactoryBean，返回他的getObject
                  bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
              }
  
              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, () -> {
                          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