IOC容器的依赖注入（一）

1、依赖注入发生的时间

当Spring IoC容器完成了Bean定义资源的定位、载入和解析注册以后，IoC容器中已经管理类Bean定义的相关数据，但是此时IoC容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况发生：

(1).用户第一次通过getBean方法向IoC容索要Bean时，IoC容器触发依赖注入。

(2).当用户在Bean定义资源中为<Bean>元素配置了lazy-init属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。

BeanFactory接口定义了Spring IoC容器的基本功能规范，是Spring IoC容器所应遵守的最底层和最基本的编程规范。BeanFactory接口中定义了几个getBean方法，就是用户向IoC容器索取管理的Bean的方法，我们通过分析其子类的具体实现，理解Spring IoC容器在用户索取Bean时如何完成依赖注入。

在BeanFactory中我们看到getBean（String…）函数，它的具体实现在AbstractBeanFactory中

2、AbstractBeanFactory通过getBean向IoC容器获取被管理的Bean

AbstractBeanFactory的getBean相关方法的源码如下：

    //获取IoC容器中指定名称的Bean  
   public Object getBean(String name) throws BeansException {  
       //doGetBean才是真正向IoC容器获取被管理Bean的过程  
       return doGetBean(name, null, null, false);  
   }
  
   //获取IoC容器中指定名称和类型的Bean  
   public <T> T getBean(String name, Class<T> requiredType) throws BeansException {  
       //doGetBean才是真正向IoC容器获取被管理Bean的过程  
       return doGetBean(name, requiredType, null, false);  
   } 
 
   //获取IoC容器中指定名称和参数的Bean  
   public Object getBean(String name, Object... args) throws BeansException {  
       //doGetBean才是真正向IoC容器获取被管理Bean的过程  
       return doGetBean(name, null, args, false);  
   }  

   //获取IoC容器中指定名称、类型和参数的Bean  
   public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {  
       //doGetBean才是真正向IoC容器获取被管理Bean的过程  
       return doGetBean(name, requiredType, args, false);  
   }  

protected <T> T doGetBean(final String name, final Class<T> requiredType, 
                      final Object[] args, boolean typeCheckOnly) throws BeansException {

        //根据指定的名称获取被管理Bean的名称，剥离指定名称中对容器的相关依赖，
        //如果指定的是别名，将别名转换为规范的Bean名称
		final String beanName = transformedBeanName(name);
		Object bean;

		//先从缓存中取是否已经有被创建过的单态类型的Bean，
        //对于单态模式的Bean整个IoC容器中只创建一次，不需要重复创建
		Object sharedInstance = getSingleton(beanName);

        //IoC容器创建单态模式Bean实例对象
		if (sharedInstance != null && args == null) {

            //获取给定Bean的实例对象，主要是完成FactoryBean的相关处理
            //注意：BeanFactory是管理容器中Bean的工厂，
            //而FactoryBean是创建创建对象的工厂Bean，两者之间有区别
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		} else {

			//缓存没有正在创建的单态模式Bean
            //缓存中已经有已经创建的原型模式Bean，但是由于循环引用的问题导致实例化对象失败
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			//对IoC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否能在当前的
            //BeanFactory中获取的所需要的Bean，如果不能则委托当前容器的父级容器去查找，
            //如果还是找不到则沿着容器的继承体系向父级容器查找 
			BeanFactory parentBeanFactory = getParentBeanFactory();

            //当前容器的父级容器存在，且当前容器中不存在指定名称的Bean
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				
                //解析指定Bean名称的原始名称
				String nameToLookup = originalBeanName(name);
				if (args != null) {

					//委派父级容器根据指定名称和显式的参数查找
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				} else {

					//委派父级容器根据指定名称和类型查找
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

            //创建的Bean是否需要进行类型验证，一般不需要
			if (!typeCheckOnly) {
                //向容器标记指定的Bean已经被创建
				markBeanAsCreated(beanName);
			}

			try {
                //根据指定Bean名称获取其父级的Bean定义，
                //主要解决Bean继承时子类合并父类公共属性问题
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				//获取当前Bean所有依赖Bean的名称 
				String[] dependsOn = mbd.getDependsOn();
                //如果当前Bean有依赖Bean
				if (dependsOn != null) {
					for (String dependsOnBean : dependsOn) {
                        //递归调用getBean方法，获取当前Bean的依赖Bean
						getBean(dependsOnBean);
                        //把被依赖Bean注册给当前依赖的Bean
						registerDependentBean(dependsOnBean, beanName);
					}
				}

				//创建单态模式Bean的实例对象 
				if (mbd.isSingleton()) {
                    //这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						public Object getObject() throws BeansException {
							try {
                                //创建一个指定Bean实例对象，如果有父级继承，
                                //则合并子类和父类的定义
								return createBean(beanName, mbd, args);
							}
							catch (BeansException ex) {
								//显式地从容器单态模式Bean缓存中清除实例对象
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
                    //获取给定Bean的实例对象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				
                 } else if (mbd.isPrototype()) {

					//原型模式(Prototype)是每次都会创建一个新的对象
					Object prototypeInstance = null;
					try {
                        //回调beforePrototypeCreation方法，默认的功能是注册当前创建的原型对象
						beforePrototypeCreation(beanName);
                        //创建指定Bean对象实例
						prototypeInstance = createBean(beanName, mbd, args);
					} finally {
                           //回调afterPrototypeCreation方法，
                           //默认的功能告诉IoC容器指定Bean的原型对象不再创建了
						afterPrototypeCreation(beanName);
					}
                    //获取给定Bean的实例对象
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
                //要创建的Bean既不是单态模式，也不是原型模式，则根据Bean定义资源中配置的生命周
                //期范围，选择实例化Bean的合适方法，这种在Web应用程序中比较常用，如：request、
                //session、application等生命周期
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
                    //Bean定义资源中没有配置生命周期范围，则Bean定义不合法
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
					}
					try {
                        //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例 
						Object scopedInstance = scope.get(beanName, 
                            new ObjectFactory<Object>() {
							    public Object getObject() throws BeansException {
								    beforePrototypeCreation(beanName);
								    try {
									    return createBean(beanName, mbd, args);
								    }
								    finally {
									    afterPrototypeCreation(beanName);
								    }
							    }
						    });
                        //获取给定Bean的实例对象
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					} 
				}
			}
		}

		//对创建的Bean实例对象进行类型检查
		if (requiredType != null && bean != null && 
                                    !requiredType.isAssignableFrom(bean.getClass())) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
			catch (TypeMismatchException ex) {
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

通过上面对向IoC容器获取Bean方法的分析，我们可以看到在Spring中，如果Bean定义的单态模式(Singleton)，则容器在创建之前先从缓存中查找，以确保整个容器中只存在一个实例对象。如果Bean定义的是原型模式(Prototype)，则容器每次都会创建一个新的实例对象。除此之外，Bean定义还可以扩展为指定其生命周期范围。

上面的源码只是定义了根据Bean定义的模式，采取的不同创建Bean实例对象的策略，具体的Bean实例对象的创建过程由实现了ObejctFactory接口的匿名内部类的createBean方法完成源码如下：

ObejctFactory使用委派模式，具体的Bean实例创建过程交由其实现类AbstractAutowireCapableBeanFactory完成，我们继续分析AbstractAutowireCapableBeanFactory的createBean方法的源码，理解其创建Bean实例的具体实现过程。

3、AbstractAutowireCapableBeanFactory创建Bean实例对象

AbstractAutowireCapableBeanFactory类实现了AbstractBeanFactory的createBean方法，创建容器指定的Bean实例对象，同时还对创建的Bean实例对象进行初始化处理。其创建Bean实例对象的方法源码如下：

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final     
                             Object[] args) throws BeanCreationException {

		 
		//判断需要创建的Bean是否可以实例化，即是否可以通过当前的类加载器加载
		resolveBeanClass(mbd, beanName);

		//校验和准备Bean中的方法覆盖
		try {
			mbd.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			 
		}

		try {
			 //给BeanPostProcessors一个返回代理而不是目标bean实例的机会。             
			Object bean = resolveBeforeInstantiation(beanName, mbd);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			 
		}
        //创建Bean的入口 
		Object beanInstance = doCreateBean(beanName, mbd, args);
		 
		return beanInstance;
	}

终上代码主要处理的是bean的BeanPostProcessors，改操作是bean在实例化的时候，对bean进行额外的封装，主要是给bean配置一个代理。这块将在后面bean的生命周期中进行讲解。

//真正创建Bean的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {

		 //封装被创建的Bean对象.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
            //单态模式的Bean，先从容器中缓存中获取同名Bean
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
            //创建实例对象 
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = (instanceWrapper != null 
                                ? instanceWrapper.getWrappedInstance() : null);

         //获取实例化对象的类型
		Class<?> beanType = (instanceWrapper != null 
                                ? instanceWrapper.getWrappedClass() : null);

		//调用PostProcessor后置处理器
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				mbd.postProcessed = true;
			}
		}

		 
        //向容器中的三级缓存（singletonFactories）单态模式的Bean对象单例对象工厂的cache,
        //添加bean，以防循环引用  
		boolean earlySingletonExposure = (
                        mbd.isSingleton() 
                    && this.allowCircularReferences 
                    && isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
            //这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		
        //Bean对象的初始化，依赖注入在此触发  
        //这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean 
		Object exposedObject = bean;

		try {
            //将Bean实例对象封装，并且Bean定义中配置的属性值赋值给实例对象
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
                //初始化Bean对象
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		} catch (Throwable ex) {}

		if (earlySingletonExposure) {
             //获取指定名称的已注册的单态模式Bean对象
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {

                //根据名称获取的已注册的Bean和正在实例化的Bean是同一个
                //当前实例化的Bean初始化完成 
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				} else if (!this.allowRawInjectionDespiteWrapping 
                    && hasDependentBean(beanName)) {

					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans =
                             new LinkedHashSet<String>(dependentBeans.length);
                    //获取当前Bean所依赖的其他Bean
					for (String dependentBean : dependentBeans) {
                        //对依赖Bean进行类型检查
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
				}
			}
		}

		// Register bean as disposable.
        //注册完成依赖注入的Bean
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			
		}

		return exposedObject;
	}

 

通过对方法源码的分析，我们看到具体的依赖注入实现在以下两个方法中：

(1).createBeanInstance：生成Bean所包含的java对象实例。

(2).populateBean ：对Bean属性的依赖注入进行处理。

下面继续分析这两个方法的代码实现。

4、createBeanInstance方法创建Bean的java实例对象：

在createBeanInstance方法中，根据指定的初始化策略，使用静态工厂、工厂方法或者容器的自动装配特性生成java实例对象，创建对象的源码如下：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		
        //检查确认Bean是可实例化的 
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

         

		if (mbd.getFactoryMethodName() != null)  {
            //调用工厂方法实例化
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		//使用容器的自动装配方法进行实例化 
		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) {
                //配置了自动装配属性，使用容器的自动装配实例化  
                //容器的自动装配是根据参数类型匹配Bean的构造方法
				return autowireConstructor(beanName, mbd, null, null);
			} else {
                 //使用默认的无参构造方法实例化
				return instantiateBean(beanName, mbd);
			}
		}

		//使用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);
		}

		//使用默认的无参构造方法实例化 
		return instantiateBean(beanName, mbd);
	}

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			final BeanFactory parent = this;

             //获取系统的安全管理接口，JDK标准的安全管理API

			if (System.getSecurityManager() != null) {
                //这里是一个匿名内置类，根据实例化策略创建实例对象
				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
					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);
		}
	}

经过对上面的代码分析，我们可以看出，对使用工厂方法和自动装配特性的Bean的实例化相当比较清楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作，但是对于我们最常使用的默认无参构造方法就需要使用相应的初始化策略(JDK的反射机制或者CGLIB)来进行初始化了，在方法getInstantiationStrategy().instantiate中就具体实现类使用初始策略实例化对象。

5、SimpleInstantiationStrategy类使用默认的无参构造方法创建Bean实例化对象

在使用默认的无参构造方法创建Bean的实例化对象时，方法getInstantiationStrategy().instantiate调用了SimpleInstantiationStrategy类中的实例化Bean的方法，其源码如下：

 //使用初始化策略实例化Bean对象
public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
		 //如果Bean定义中没有方法覆盖，则就不需要CGLIB父类类的方法  
		if (beanDefinition.getMethodOverrides().isEmpty()) {
			Constructor<?> constructorToUse;
			synchronized (beanDefinition.constructorArgumentLock) {
                //获取对象的构造方法或工厂方法
				constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
                //如果没有构造方法且没有工厂方法
				if (constructorToUse == null) {
                    //使用JDK的反射机制，判断要实例化的Bean是否是接口
					final Class<?> clazz = beanDefinition.getBeanClass();
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
                            //这里是一个匿名内置类，使用反射机制获取Bean的构造方法 
							constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
								public Constructor<?> run() throws Exception {
									return clazz.getDeclaredConstructor((Class[]) null);
								}
							});
						}
						else {
							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
						}
						beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Exception ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
            //使用BeanUtils实例化，通过反射机制调用”构造方法.newInstance(arg)”来进行实例化
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			//使用CGLIB来实例化对象
			return instantiateWithMethodInjection(beanDefinition, beanName, owner);
		}
	}

通过上面的代码分析，我们看到了如果Bean有方法被覆盖了，则使用JDK的反射机制进行实例化，否则，使用CGLIB进行实例化。

instantiateWithMethodInjection方法调用SimpleInstantiationStrategy的子类CglibSubclassingInstantiationStrategy使用CGLIB来进行初始化，其源码如下：

 //使用CGLIB进行Bean对象实例化
public Object instantiate(Constructor<?> ctor, Object[] args) {
            //CGLIB中的类 
			Enhancer enhancer = new Enhancer();
            //将Bean本身作为其基类
			enhancer.setSuperclass(this.beanDefinition.getBeanClass());
			enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
			enhancer.setCallbackFilter(new CallbackFilterImpl());
			enhancer.setCallbacks(new Callback[] {
					NoOp.INSTANCE,
					new LookupOverrideMethodInterceptor(),
					new ReplaceOverrideMethodInterceptor()
			});
            //使用CGLIB的create方法生成实例对象
			return (ctor != null ? enhancer.create(ctor.getParameterTypes(), args) : enhancer.create());
		}

CGLIB是一个常用的字节码生成器的类库，它提供了一系列API实现java字节码的生成和转换功能。我们在学习JDK的动态代理时都知道，JDK的动态代理只能针对接口，如果一个类没有实现任何接口，要对其进行动态代理只能使用CGLIB。