IOC容器的依赖注入

依赖注入的过程是用户第一次向IOC容器索要Bean时触发的，例外--在BeanDefinition通过lazy-init完成对Bean的 预初始化。在IOC容器接口BeanFactory中，有一个getBean的接口定义，这个接口的实现就是触发依赖注入发生的地方。DefaultListableBeanFactory的基类AbstractBeanFactory的getBean

public Object getBean(String name) throws BeanException{
return doGetBean(name,null,null,false);
public <T> T getBean(String name,calss<T> requiredType)throws BeansExceptio {
return doGetBean(name,requiredType,null,false);}
<span style="font-size:24px;"></span><pre name="code" class="java">public Object getBean(String name,Object... args) throws BeanException{
return doGetBean(name,null,args,false);
public <T> T getBean(String name,calss<T> requiredType,Object[] args)throws BeansException{
return doGetBean(name,requiredType,args,false);}

//这里是实际取得Bean的地方，也是触发依赖注入的地方
protected <T> T doGetBean(final String name,final Class<T> requiredType,final Object[] args,boolean typeCheckOnly)

throws BeanException{

final String beanName=transformedBeanName(name);
Object bean;
...
}}

AbstractAutowireCapableBeanFactory中实现了createBean，createBean不但生成了需要的Bean，还对Bean的初始化进行了处理。

protected Object createBean(final String beanName,final RootBeanDefinition mbd,final Object[] args) throws BeanCreateException{
AccessControlContext acc=AccessController.getContext();
return AccessController.doPrivileged(new PrivilegedAction<Object>(){
public Object run(){
if(logger.idDebugEnabled()){
logger.debug("beanName"+beanName);}
//判断需要创建的Bean是否可实例化，是否可通过类加载器载入
resolveBeanClass(mbd,beanName);
try{mbd.prepareMethodOverrides();}catch(BeanDefinitionValidationException ex){
throw new BeanDefinitionValidationStoreException(mbd.getResourceDescription(),beanName,"Validation of method overrides failed",ex);}
//如果配置了PostProcessor，返回一个proxy
try{Object bean=resolveBeforeInstantiation(beanName,mdb);
if(bean!=null){return bean;}
}catch(Throwable ex){
throw new BeanCreationException(mdb.getResourceDescription(),beanName,"BeanPostProcessor before instantiation of bean failed",ex);
//创建Bean的调用
Object beanInstance=doCreateBean(beanName,mdb,args);return beanInstance;}},acc});
//doCreateBean中Bean是怎样生成的
protect ObjectdoCreateBean(final String beanName,final RootBeanDefinition mdb,final Object[] args){
//BeanWrapper用来持有创建出来的Bean对象的
BeanWrapper instanceWrapper=null;
//如果是Singleton，先把缓存中的同名Bean清除
if(mdb.isSingleton()){
instanceWrapper=this.factoryBeanInstanceCache.remove(beanName);}
//创建Bean，由createBean完成
if(instanceWrapper==null){
instanceWrapper=createBeanInstance(beanName,mdb,args);
}
final Object bean=(instanceWrapper!=null?instanceWrapper.getWrapperInstance():null);
Class beanType=<span style="font-size:24px;"></span><pre name="code" class="java">(instanceWrapper!=null?instanceWrapper.getWrapperClass():null);
synchronized(mdb.postProcessingLock){
if(!mdb.postProcessed){applyMergedBeanDefinitionPostProcessors(mdb,beanType,beanName);
mdb.postProcessed=true;}
}
boolean earlySingletonExposure=(mdb.isSingleton()&&this.allowCircularReferences&&isSingletonCurrentlyIncreation(beanName)) 
if(earlySingletonExposure){
if(logger.isDebugEnabled){}
addSingletonFactory(beanName,new ObjectFactory(){
public Object getObject() throws BeansException{
return getEarlyBeanReference(beanName,mdb,bean);}});
}

//对Bean的初始化，依赖注入在这里发生，exposedObject在初始化处理后会返回作为依赖注入完成后的Bean
Object exposedObject=bean；
try{
populateBean(beanName,mdb,instanceWrapper);
exposedObject=initalizeBean(beanName,exposedObject,mdb);}catch(Throwable ex){
...}
...
}
//createBeanInstance生成Bean所包含的java对象，可以通过工厂方法生成，也可通过容器的autowire生成。
protected BeanWrapper createBeanInstance(String beanName,RootBeanDefinition mdb,Object[] args){
//确认需要创建的Bean实例的类可以实例化
Class beanClass=resolveBeanClass(mdb,beanName);
//使用工厂方法对Bean实例化
if(mdb.getFactoryMethodName()!=null){
return instantiateUsingFactoryMethod(neamName,mdb,args);
}
if(mdb.resolveConstructorOrFactoryMethod()！=null){
if(mdb.constructorArgumentResolved){return autowireConstructor(beanName,mdb,null,args);}else{
return instantiateBean(beanName,mdb);}
}

使用构造函数对Bean实例化
Constructor[] cons=deteminConstructorsFromBeanPostProcessors(beanClass,beanName);
if(cons!=null){
return autowireConstructor(beanName,mdb,cons,args);}
return instantiateBean(beanName,mdb);
}
//populateBean，BeanWraper完成Bean的属性值注入，
}