Spring bean的实例化和IOC依赖注入详解
前言
我们知道，IOC是Spring的核心。它来负责控制对象的生命周期和对象间的关系。
举个例子，我们如何来找对象的呢？常见的情况是，在路上要到处去看哪个MM既漂亮身材又好，符合我们的口味。就打听她们的电话号码，制造关联想办法认识她们，然后...这里省略N步，最后谈恋爱结婚。
IOC在这里就像婚介所，里面有很多适婚男女的资料，如果你有需求，直接告诉它你需要个什么样的女朋友就好了。它会给我们提供一个MM，直接谈恋爱结婚，完美！
下面就来看Spring是如何生成并管理这些对象的呢？
1、方法入口
org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons（）方法是今天的主角，一切从它开始。
publicvoidpreInstantiateSingletons()throwsBeansException{
//beanDefinitionNames就是上一节初始化完成后的所有BeanDefinition的beanName
ListbeanNames=newArrayList(this.beanDefinitionNames);
for(StringbeanName:beanNames){
RootBeanDefinitionbd=getMergedLocalBeanDefinition(beanName);
if(!bd.isAbstract()&&bd.isSingleton()&&!bd.isLazyInit()){
//getBean是主力中的主力，负责实例化Bean和IOC依赖注入
getBean(beanName);
}
}
}
2、Bean的实例化
在入口方法getBean中，首先调用了doCreateBean方法。第一步就是通过反射实例化一个Bean。
protectedObjectdoCreateBean(finalStringbeanName,finalRootBeanDefinitionmbd,finalObject[]args){
//Instantiatethebean.
BeanWrapperinstanceWrapper=null;
if(mbd.isSingleton()){
instanceWrapper=this.factoryBeanInstanceCache.remove(beanName);
}
if(instanceWrapper==null){
//createBeanInstance就是实例化Bean的过程，无非就是一些判断加反射，最后调用ctor.newInstance(args);
instanceWrapper=createBeanInstance(beanName,mbd,args);
}
}
3、Annotation的支持
在Bean实例化完成之后，会进入一段后置处理器的代码。从代码上看，过滤实现了MergedBeanDefinitionPostProcessor接口的类，调用其postProcessMergedBeanDefinition（）方法。都是谁实现了MergedBeanDefinitionPostProcessor接口呢？我们重点看三个
- AutowiredAnnotationBeanPostProcessor
- CommonAnnotationBeanPostProcessor
- RequiredAnnotationBeanPostProcessor
记不记得在Spring源码分析（一）Spring的初始化和XML这一章节中，我们说Spring对annotation-config标签的支持，注册了一些特殊的Bean，正好就包含上面这三个。下面来看它们偷偷做了什么呢？
从方法名字来看，它们做了相同一件事，加载注解元数据。方法内部又做了相同的两件事
ReflectionUtils.doWithLocalFields(targetClass,newReflectionUtils.FieldCallback() ReflectionUtils.doWithLocalMethods(targetClass,newReflectionUtils.MethodCallback()
看方法的参数，targetClass就是Bean的Class对象。接下来就可以获取它的字段和方法，判断是否包含了相应的注解，最后转成InjectionMetadata对象，下面以一段伪代码展示处理过程。
publicstaticvoidmain(String[]args)throwsClassNotFoundException{
Classclazz=Class.forName("com.viewscenes.netsupervisor.entity.User");
Field[]fields=clazz.getFields();
Method[]methods=clazz.getMethods();
for(inti=0;i
InjectionMetadata对象有两个重要的属性：targetClass，injectedElements，在注解式的依赖注入的时候重点就靠它们。
publicInjectionMetadata(ClasstargetClass,Collectionelements){
//targetClass是Bean的Class对象
this.targetClass=targetClass;
//injectedElements是一个InjectedElement对象的集合
this.injectedElements=elements;
}
//member是成员本身，字段或者方法
//pd是JDK中的内省机制对象，后面的注入属性值要用到
protectedInjectedElement(Membermember,PropertyDescriptorpd){
this.member=member;
this.isField=(memberinstanceofField);
this.pd=pd;
}
说了这么多，最后再看下源码里面是什么样的，以Autowired为例。
ReflectionUtils.doWithLocalFields(targetClass,newReflectionUtils.FieldCallback(){
@Override
publicvoiddoWith(Fieldfield)throwsIllegalArgumentException,IllegalAccessException{
AnnotationAttributesann=findAutowiredAnnotation(field);
if(ann!=null){
if(Modifier.isStatic(field.getModifiers())){
if(logger.isWarnEnabled()){
logger.warn("Autowiredannotationisnotsupportedonstaticfields:"+field);
}
return;
}
booleanrequired=determineRequiredStatus(ann);
currElements.add(newAutowiredFieldElement(field,required));
}
}
});
ReflectionUtils.doWithLocalMethods(targetClass,newReflectionUtils.MethodCallback(){
@Override
publicvoiddoWith(Methodmethod)throwsIllegalArgumentException,IllegalAccessException{
MethodbridgedMethod=BridgeMethodResolver.findBridgedMethod(method);
if(!BridgeMethodResolver.isVisibilityBridgeMethodPair(method,bridgedMethod)){
return;
}
AnnotationAttributesann=findAutowiredAnnotation(bridgedMethod);
if(ann!=null&&method.equals(ClassUtils.getMostSpecificMethod(method,clazz))){
if(Modifier.isStatic(method.getModifiers())){
if(logger.isWarnEnabled()){
logger.warn("Autowiredannotationisnotsupportedonstaticmethods:"+method);
}
return;
}
if(method.getParameterTypes().length==0){
if(logger.isWarnEnabled()){
logger.warn("Autowiredannotationshouldbeusedonmethodswithparameters:"+method);
}
}
booleanrequired=determineRequiredStatus(ann);
PropertyDescriptorpd=BeanUtils.findPropertyForMethod(bridgedMethod,clazz);
currElements.add(newAutowiredMethodElement(method,required,pd));
}
}
});
4、依赖注入
前面完成了在doCreateBean（）方法Bean的实例化，接下来就是依赖注入。
Bean的依赖注入有两种方式，一种是配置文件，一种是注解式。
4.1、注解式的注入过程
在上面第3小节，Spring已经过滤了Bean实例上包含@Autowired、@Resource等注解的Field和Method，并返回了包含Class对象、内省对象、成员的InjectionMetadata对象。还是以@Autowired为例，这次调用到AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues（）。
首先拿到InjectionMetadata对象，再判断里面的InjectedElement集合是否为空，也就是说判断在Bean的字段和方法上是否包含@Autowired。然后调用InjectedElement.inject()。InjectedElement有两个子类AutowiredFieldElement、AutowiredMethodElement，很显然一个是处理Field，一个是处理Method。
4.1.1AutowiredFieldElement
如果Autowired注解在字段上，它的配置是这样。
publicclassUser{
@Autowired
Rolerole;
}
protectedvoidinject(Objectbean,StringbeanName,PropertyValuespvs)throwsThrowable{
//以User类中的@AutowiredRolerole为例，这里的field就是
//publiccom.viewscenes.netsupervisor.entity.Rolecom.viewscenes.netsupervisor.entity.User.role
Fieldfield=(Field)this.member;
Objectvalue;
DependencyDescriptordesc=newDependencyDescriptor(field,this.required);
desc.setContainingClass(bean.getClass());
SetautowiredBeanNames=newLinkedHashSet(1);
TypeConvertertypeConverter=beanFactory.getTypeConverter();
try{
//这里的beanName因为Bean，所以会重新进入populateBean方法，先完成Role对象的注入
//value==com.viewscenes.netsupervisor.entity.Role@7228c85c
value=beanFactory.resolveDependency(desc,beanName,autowiredBeanNames,typeConverter);
}
catch(BeansExceptionex){
thrownewUnsatisfiedDependencyException(null,beanName,newInjectionPoint(field),ex);
}
if(value!=null){
//设置可访问，直接赋值
ReflectionUtils.makeAccessible(field);
field.set(bean,value);
}
}
4.1.2AutowiredFieldElement
如果Autowired注解在方法上，就得这样写。
publicclassUser{
@Autowired
publicvoidsetRole(Rolerole){}
}
它的inject方法和上面类似，不过最后是method.invoke。感兴趣的小伙伴可以去翻翻源码。
ReflectionUtils.makeAccessible(method);
method.invoke(bean,arguments);
4.2、配置文件的注入过程
先来看一个配置文件，我们在User类中注入了id，name，age和Role的实例。
在Spring源码分析（一）Spring的初始化和XML这一章节的4.2小节，bean标签的解析，我们看到在反射得到Bean的Class对象后，会设置它的property属性，也就是调用了parsePropertyElements()方法。在BeanDefinition对象里有个MutablePropertyValues属性。
MutablePropertyValues:
//propertyValueList就是有几个property节点
ListpropertyValueList:
PropertyValue:
name//对应配置文件中的name==id
value//对应配置文件中的value==1001
PropertyValue:
name//对应配置文件中的name==name
value//对应配置文件中的value==网机动车
上图就是BeanDefinition对象里面MutablePropertyValues属性的结构。既然已经拿到了property的名称和值，注入就比较简单了。从内省对象PropertyDescriptor中拿到writeMethod对象，设置可访问，invoke即可。PropertyDescriptor有两个对象readMethodRef、writeMethodRef其实对应的就是getset方法。
publicvoidsetValue(finalObjectobject,ObjectvalueToApply)throwsException{
//pd是内省对象PropertyDescriptor
finalMethodwriteMethod=this.pd.getWriteMethod());
writeMethod.setAccessible(true);
finalObjectvalue=valueToApply;
//以id为例writeMethod==publicvoidcom.viewscenes.netsupervisor.entity.User.setId(java.lang.String)
writeMethod.invoke(getWrappedInstance(),value);
}
5、initializeBean
在Bean实例化和IOC依赖注入后，Spring留出了扩展，可以让我们对Bean做一些初始化的工作。
5.1、Aware
Aware是一个空的接口，什么也没有。不过有很多xxxAware继承自它，下面来看源码。如果有需要，我们的Bean可以实现下面的接口拿到我们想要的。
//在实例化和IOC依赖注入完成后调用
privatevoidinvokeAwareMethods(finalStringbeanName,finalObjectbean){
if(beaninstanceofAware){
//让我们的Bean可以拿到自身在容器中的beanName
if(beaninstanceofBeanNameAware){
((BeanNameAware)bean).setBeanName(beanName);
}
//可以拿到ClassLoader对象
if(beaninstanceofBeanClassLoaderAware){
((BeanClassLoaderAware)bean).setBeanClassLoader(getBeanClassLoader());
}
//可以拿到BeanFactory对象
if(beaninstanceofBeanFactoryAware){
((BeanFactoryAware)bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
if(beaninstanceofEnvironmentAware){
((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
}
if(beaninstanceofEmbeddedValueResolverAware){
((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if(beaninstanceofResourceLoaderAware){
((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
}
if(beaninstanceofApplicationEventPublisherAware){
((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
}
if(beaninstanceofMessageSourceAware){
((MessageSourceAware)bean).setMessageSource(this.applicationContext);
}
if(beaninstanceofApplicationContextAware){
((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
}
......未完
}
}
做法如下：
publicclassAwareTest1implementsBeanNameAware,BeanClassLoaderAware,BeanFactoryAware{
publicvoidsetBeanName(Stringname){
System.out.println("BeanNameAware:"+name);
}
publicvoidsetBeanFactory(BeanFactorybeanFactory)throwsBeansException{
System.out.println("BeanFactoryAware:"+beanFactory);
}
publicvoidsetBeanClassLoader(ClassLoaderclassLoader){
System.out.println("BeanClassLoaderAware:"+classLoader);
}
}
//输出结果
BeanNameAware:awareTest1
BeanClassLoaderAware:WebappClassLoader
context:/springmvc_dubbo_producer
delegate:false
repositories:
/WEB-INF/classes/
---------->ParentClassloader:
java.net.URLClassLoader@2626b418
BeanFactoryAware:org.springframework.beans.factory.support.DefaultListableBeanFactory@5b4686b4:definingbeans...未完
5.2、初始化
Bean的初始化方法有三种方式，按照先后顺序是，@PostConstruct、afterPropertiesSet、init-method
5.2.1@PostConstruct
这个注解隐藏的比较深，它是在CommonAnnotationBeanPostProcessor的父类InitDestroyAnnotationBeanPostProcessor调用到的。这个注解的初始化方法不支持带参数，会直接抛异常。
if(method.getParameterTypes().length!=0){
thrownewIllegalStateException("Lifecyclemethodannotationrequiresano-argmethod:"+method);
}
publicvoidinvoke(Objecttarget)throwsThrowable{
ReflectionUtils.makeAccessible(this.method);
this.method.invoke(target,(Object[])null);
}
5.2.2afterPropertiesSet
这个要实现InitializingBean接口。这个也不能有参数，因为它接口方法就没有定义参数。
booleanisInitializingBean=(beaninstanceofInitializingBean);
if(isInitializingBean&&(mbd==null||!mbd.isExternallyManagedInitMethod("afterPropertiesSet"))){
if(logger.isDebugEnabled()){
logger.debug("InvokingafterPropertiesSet()onbeanwithname'"+beanName+"'");
}
((InitializingBean)bean).afterPropertiesSet();
}
5.2.3init-method
ReflectionUtils.makeAccessible(initMethod);
initMethod.invoke(bean);
6、注册
registerDisposableBeanIfNecessary()完成Bean的缓存注册工作，把Bean注册到Map中。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。