浅谈Spring IoC容器的依赖注入原理

// 这里是对 BeanFactory 接口的实现，比如getBean接口方法  //这些getBean接口方法最终是通过调用doGetBean来实现的  @Override  public Object getBean(String name) throws BeansException {    return doGetBean(name, null, null, false);  }  @Override  public <T> T getBean(String name, Class<T> requiredType) throws BeansException {    return doGetBean(name, requiredType, null, false);  }  @Override  public Object getBean(String name, Object... args) throws BeansException {    return doGetBean(name, null, args, false);  }  public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {    return doGetBean(name, requiredType, args, false);  }    //这里是实际取得Bean的地方,也就是触发依赖注入发生的地方  @SuppressWarnings("unchecked")  protected <T> T doGetBean(      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)      throws BeansException {    final String beanName = transformedBeanName(name);    Object bean;    // Eagerly check singleton cache for manually registered singletons.        //急切地检查单例人士缓存手动注册的单例        //先从缓存中取得Bean,处理那些已经被创建过的单例Bean,这种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 + "'");        }      }            //这里的getObjectForBeanInstance完成的是FactoryBean的相关处理，以取得FactoryBean的相关处理,以取得FactoryBean的生产结果,BeanFactory和FactoryBean的区别已在前面讲过,这个过程在后面还会详细地分析      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);    }    else {      // Fail if we're already creating this bean instance:      // We're assumably within a circular reference.      if (isPrototypeCurrentlyInCreation(beanName)) {        throw new BeanCurrentlyInCreationException(beanName);      }            // // 检查IoC容器中的BeanDefinition是否存在,若在当前工厂不存在则去顺着双亲BeanFactory链一直向上找      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) {        markBeanAsCreated(beanName);      }      try {                //根据Bean的名字取得BeanDefinition         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);        checkMergedBeanDefinition(mbd, beanName, args);        // Guarantee initialization of beans that the current bean depends on.                //递归获得当前Bean依赖的所有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);            getBean(dep);          }        }                //通过调用createBean方法创建Singleton bean实例        if (mbd.isSingleton()) {          sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {            @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);        }        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.        // 这里对创建的Bean进行类型检查,如果没有问题,就返回这个新创建的Bean,这个Bean已经是包含了依赖关系的Bean    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;  }

@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<?> resolvedClass = resolveBeanClass(mbd, beanName);    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {      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.            //如果Bean配置了PostProcessor,那么这里返回的是一个Proxy      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);    }    try {      Object beanInstance = doCreateBean(beanName, mbdToUse, args);      if (logger.isDebugEnabled()) {        logger.debug("Finished creating instance of bean '" + beanName + "'");      }      return beanInstance;    }    catch (BeanCreationException ex) {      // A previously detected exception with proper bean creation context already...      throw ex;    }    catch (ImplicitlyAppearedSingletonException ex) {      // An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...      throw ex;    }    catch (Throwable ex) {      throw new BeanCreationException(          mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);    }  }  //接着到doCreate中去看看Bean是怎样生成的  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {    // Instantiate the bean.        //用来持有创建出来的Bean对象    BeanWrapper instanceWrapper = null;        //如果是单例,则先把缓存中的同名Bean清除    if (mbd.isSingleton()) {      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);    }        //这里是创建Bean的地方,由createBeanInstance来完成    if (instanceWrapper == null) {            //根据指定bean使用对应的策略创建新的实例,如:工厂方法,构造函数自动注入,简单初始化      instanceWrapper = createBeanInstance(beanName, mbd, args);    }    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);    // Allow post-processors to modify the merged bean definition.    synchronized (mbd.postProcessingLock) {      if (!mbd.postProcessed) {        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);        mbd.postProcessed = true;      }    }    // Eagerly cache singletons to be able to resolve circular references    // even when triggered by lifecycle interfaces like BeanFactoryAware.        //是否需要提前曝光:单例&允许循环依赖&当前bean正在创建中,检测循环依赖    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");      }            //为避免后期循环依赖,可以在bean初始化完成前将创建实例的ObjectFactory加入工厂      addSingletonFactory(beanName, new ObjectFactory<Object>() {        @Override        public Object getObject() throws BeansException {                    //对bean再次依赖引用,主要应用SMartInstantialiationAware BeanPostProcessor,                    //其中我们熟知的AOP就是在这里将advice动态织入bean中,若无则直接返回bean,不做任何处理          return getEarlyBeanReference(beanName, mbd, bean);        }      });    }    // Initialize the bean instance.        //这里是对Bean的初始化,依赖注入往往在这里发生,这个exposedObject在初始化处理完后悔返回作为依赖注入完成后的Bean    Object exposedObject = bean;    try {            //对bean进行填充,将各个属性值注入,其中可能存在依赖于其他bean的属性,则会递归初始化依赖bean      populateBean(beanName, mbd, instanceWrapper);      if (exposedObject != null) {                //调用初始化方法,比如init-method        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) {      Object earlySingletonReference = getSingleton(beanName, false);            // earlySingletonReference 只有在检测到有循环依赖的情况下才会非空      if (earlySingletonReference != null) {        if (exposedObject == bean) {                    //如果exposedObject 没有在初始化方法中被改变,也就是没有被增强          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);            }          }                    //因为bean创建后其所依赖的bean一定是已经创建的,actualDependentBeans非空则表示当前bean创建后其依赖的bean却没有全部创建完,也就是说存在循环依赖          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 {            //根据scope注册bean      registerDisposableBeanIfNecessary(beanName, bean, mbd);    }    catch (BeanDefinitionValidationException ex) {      throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);    }    return exposedObject;  }

/**   * 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 a BeanWrapper for the new instance   */  protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, 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());    }    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();    if (instanceSupplier != null) {      return obtainFromSupplier(instanceSupplier, beanName);    }        //若工厂方法非空,则使用工厂方法策略对Bean进行实例化    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...         // 使用构造函数对Bean进行实例化    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.        //使用默认的构造函数对Bean进行实例化    return instantiateBean(beanName, mbd);  }  /**   * Instantiate the given bean using its default constructor.   * @param beanName the name of the bean   * @param mbd the bean definition for the bean   * @return a BeanWrapper for the new instance   */    //最常见的实例化过程instantiateBean  protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {         //使用默认的实例化策略对Bean进行实例化,默认的实例化策略是    //CglibSubclassingInstantiationStrategy,也就是使用CGLIB实例化Bean     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 {        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);    }  }

public class SimpleInstantiationStrategy implements InstantiationStrategy {@Override  public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {    // Don't override the class with CGLIB if no overrides.    if (bd.getMethodOverrides().isEmpty()) {            //这里取得指定的构造器或者生成对象的工厂方法来对Bean进行实例化      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 (Throwable ex) {            throw new BeanInstantiationException(clazz, "No default constructor found", ex);          }        }      }      //通过BeanUtils进行实例化，这个BeanUtils的实例化通过Constructor来实例化Bean,在BeanUtils中可以看到具体的调用ctor.newInstance(args)      return BeanUtils.instantiateClass(constructorToUse);    }    else {         // 使用CGLIB来实例化对象      return instantiateWithMethodInjection(bd, beanName, owner);    }  }}