一、基于XML的依赖注入
1.1 依赖注入发生的时间
当Spring IOC容器完成了Bean定义资源的定位、载入和解析注册以后，IOC容器中已经管理了 Bean定义的相关数据，但是此时IOC容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况发生：
用户第一次调用getBean()方法时，IOC容器触发依赖注入。
当用户在配置文件中将<bean>元素配置了lazy-init=false属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。
BeanFactory接口中定义了几个getBean()方法，就是用户向IOC容器索取管理的Bean 的方法，我们通过分析其子类的具体实现，理解Spring IOC容器在用户索取Bean时如何完成依赖注入。在BeanFactory中我们可以看到getBean(String…)方法，这些方法的具体实现在AbstractBeanFactory中。
1.2 寻找获取 Bean 的入口
AbstractBeanFactory的 getBean()相关方法的源码：
//获取IOC容器中指定名称的Bean
@Override
publicObjectgetBean(String name)throwsBeansException{
//doGetBean才是真正向IOC容器获取被管理Bean的够哦成
returndoGetBean(name,null,null,false);
}
//通过name和指定类型从IOC容器获取Bean
@Override
public<T>TgetBean(String name,Class<T> requiredType)throwsBeansException{
returndoGetBean(name, requiredType,null,false);
}
//通过name和参数从IOC容器获取Bean
@Override
publicObjectgetBean(String name,Object... args)throwsBeansException{
returndoGetBean(name,null, args,false);
}
//通过name、类型和参数从IOC容器获取Bean
public<T>TgetBean(String name,@NullableClass<T> requiredType,@NullableObject... args)
throwsBeansException{
returndoGetBean(name, requiredType, args,false);
}
//从IOC容器中获取Bean,此方法触发依赖注入
@SuppressWarnings("unchecked")
protected<T>TdoGetBean(finalString name,@NullablefinalClass<T> requiredType,
@NullablefinalObject[] args,boolean typeCheckOnly)throwsBeansException{
//根据指定的名称获取被管理的Bean的名称
//如果指定的是别名，将别名转换为规范的Bean名称
finalString beanName =transformedBeanName(name);
Object bean;
//直接尝试从缓存获取是否已经有被创建过的单例的Bean
Object sharedInstance =getSingleton(beanName);
if(sharedInstance !=null&& args ==null){
if(logger.isTraceEnabled()){
//如果单例模式的Bean被创建，则直接返回
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的相关处理
bean =getObjectForBeanInstance(sharedInstance, name, beanName,null);
}
else{
//缓存中没有单例模式的Bean,缓存中已经有原型模式的Bean,
//但是由于循环引用导致实例化对象失败
if(isPrototypeCurrentlyInCreation(beanName)){
thrownewBeanCurrentlyInCreationException(beanName);
}
//对IOC容器中是否存在指定名称的BeanDefinition进行检查，首先
//检查是否能在当前的BeanFactory中获取所需要的Bean，
//如果不能再委托当前容器的父容器去查找，如果还是找不到则沿着继承关系向父容器查找
BeanFactory parentBeanFactory =getParentBeanFactory();
//当前容器的父容器存在，且当前容器中不存在指定名称的Bean
if(parentBeanFactory !=null&&!containsBeanDefinition(beanName)){
// Not found -> check parent.
//解析指定Bean名称的原始名称
String nameToLookup =originalBeanName(name);
if(parentBeanFactory instanceofAbstractBeanFactory){
return((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
//递归到beanFactory中寻找
elseif(args !=null){
//委派父容器根据指定名称和显式的参数查找
return(T) parentBeanFactory.getBean(nameToLookup, args);
}
elseif(requiredType !=null){
//委派父容器根据指定名称和类型查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else{
//委派父容器根据指定名称查找
return(T) parentBeanFactory.getBean(nameToLookup);
}
}
//创建的Bean是否需要进行类型验证
if(!typeCheckOnly){
//向容器标记指定的Bean已经被创建
markBeanAsCreated(beanName);
}
try{
//根据指定Bean名称获取其父级Bean定义，主要解决Bean继承时子类和父类公共属性问题
finalRootBeanDefinition mbd =getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
//获取当前bean所有依赖Bean的名称
String[] dependsOn = mbd.getDependsOn();
//如果当前Bean有依赖
if(dependsOn !=null){
for(String dep : dependsOn){
if(isDependent(beanName, dep)){
thrownewBeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '"+ beanName +"' and '"+ dep +"'");
}
//把能依赖Bean注册给当前依赖的Bean
registerDependentBean(dep, beanName);
try{
//把被依赖Bean注册给当前依赖的Bean
getBean(dep);
}
catch(NoSuchBeanDefinitionException ex){
thrownewBeanCreationException(mbd.getResourceDescription(), beanName,
"'"+ beanName +"' depends on missing bean '"+ dep +"'", ex);
}
}
}
//创建单例模式的Bean的实例对象
if(mbd.isSingleton()){
//使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
sharedInstance =getSingleton(beanName,()->{
try{
//创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义
returncreateBean(beanName, mbd, args);
}
catch(BeansException ex){
//从单例模式的Bean缓存中清除实例对象
destroySingleton(beanName);
throw ex;
}
});
//获取给定Bean的实例对象
bean =getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//IOC容器创建原型模式的Bean实例对象
elseif(mbd.isPrototype()){
//原型模式每次都会创建一个新的对象
Object prototypeInstance =null;
try{
//回调方法，默认的功能是注册当前创建的原型对象
beforePrototypeCreation(beanName);
//创建指定Bean的对象实例
prototypeInstance =createBean(beanName, mbd, args);
}
finally{
//回调方法，默认功能是：告诉IOC容器不再创建指定Bean的原型对象
afterPrototypeCreation(beanName);
}
//获取指定Bean的实例对象
bean =getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else{
//创建的Bean既不是单例模式也不是原型模式，创建其他生命周期的Bean
//比如request、session等生命周期
String scopeName = mbd.getScope();
finalScope scope =this.scopes.get(scopeName);
//如果Bean定义资源中没有配置生命周期范围，则Bean定义不合法
if(scope ==null){
thrownewIllegalStateException("No Scope registered for scope name '"+ scopeName +"'");
}
try{
//调用匿名内部类，获取一个指定生命周期范围的实例
Object scopedInstance = scope.get(beanName,()->{
beforePrototypeCreation(beanName);
try{
returncreateBean(beanName, mbd, args);
}
finally{
afterPrototypeCreation(beanName);
}
});
//获取指定Bean的实例对象
bean =getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch(IllegalStateException ex){
thrownewBeanCreationException(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;
}
}
// 对创建的Bean实例对象进行类型检查
if(requiredType !=null&&!requiredType.isInstance(bean)){
try{
T convertedBean =getTypeConverter().convertIfNecessary(bean, requiredType);
if(convertedBean ==null){
thrownewBeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch(TypeMismatchException ex){
if(logger.isTraceEnabled()){
logger.trace("Failed to convert bean '"+ name +"' to required type '"+
ClassUtils.getQualifiedName(requiredType)+"'", ex);
}
thrownewBeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return(T) bean;
}通过上面对向IOC容器获取Bean方法的分析，我们可以看到在Spring中，如果Bean定义的单例模式(Singleton)，则容器在创建之前先从缓存中查找，以确保整个容器中只存在一个实例对象。如果 Bean定义的是原型模式(Prototype)，则容器每次都会创建一个新的实例对象。
上面的源码只是定义了根据 Bean 定义的模式，采取的不同创建Bean实例对象的策略，具体的Bean实例 对象的创 建过程 由实现了ObjectFactory接口的匿名内部类的createBean()方法完成，ObjectFactory使用委派模式，具体的Bean实例创建过程交由其实现类 AbstractAutowireCapableBeanFactory 完成，我们继续分析AbstractAutowireCapableBeanFactory的 createBean()方法的源码，理解其创建Bean实例的具体实现过程。
1.3 开始实例化
AbstractAutowireCapableBeanFactory 类实现了ObjectFactory接口，创建容器指定的Bean实例对象，同时还对创建的Bean实例对象进行初始化处理。其创建Bean实例对象的方法源码：
//创建Bean实例对象
@Override
protectedObjectcreateBean(String beanName,RootBeanDefinition mbd,@NullableObject[] args)
throwsBeanCreationException{
if(logger.isTraceEnabled()){
logger.trace("Creating instance of bean '"+ beanName +"'");
}
RootBeanDefinition mbdToUse = mbd;
// 判断需要创建的Bean是否可以实例化，即是否可以通过当前的类加载器加载
Class<?> resolvedClass =resolveBeanClass(mbd, beanName);
if(resolvedClass !=null&&!mbd.hasBeanClass()&& mbd.getBeanClassName()!=null){
mbdToUse =newRootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//验证及准备覆盖的方法
try{
mbdToUse.prepareMethodOverrides();
}
catch(BeanDefinitionValidationException ex){
thrownewBeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName,"Validation of method overrides failed", ex);
}
try{
// 如果Bean配置了初始化前后的处理器，则返回一个需要创建Bean的代理对象
Object bean =resolveBeforeInstantiation(beanName, mbdToUse);
if(bean !=null){
return bean;
}
}
catch(Throwable ex){
thrownewBeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try{
//创建bean的入口
Object beanInstance =doCreateBean(beanName, mbdToUse, args);
if(logger.isTraceEnabled()){
logger.trace("Finished creating instance of bean '"+ beanName +"'");
}
return beanInstance;
}
catch(BeanCreationException|ImplicitlyAppearedSingletonException ex){
throw ex;
}
catch(Throwable ex){
thrownewBeanCreationException(
mbdToUse.getResourceDescription(), beanName,"Unexpected exception during bean creation", ex);
}
}
//真正创建Bean的方法
protectedObjectdoCreateBean(finalString beanName,finalRootBeanDefinition mbd,final@NullableObject[] args)
throwsBeanCreationException{
//封装被创建的Bean对象
BeanWrapper instanceWrapper =null;
if(mbd.isSingleton()){
instanceWrapper =this.factoryBeanInstanceCache.remove(beanName);
}
if(instanceWrapper ==null){
//根据指定bean使用对应的策略创建新的实例，如：工厂方法、构造函数自动注入，简单初始化
instanceWrapper =createBeanInstance(beanName, mbd, args);
}
finalObject bean = instanceWrapper.getWrappedInstance();
//获取实例化对象的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if(beanType !=NullBean.class){
mbd.resolvedTargetType = beanType;
}
//调用PostProcessor后置处理器
synchronized(mbd.postProcessingLock){
if(!mbd.postProcessed){
try{
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch(Throwable ex){
thrownewBeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed =true;
}
}
// 向容器中缓存单例模式的Bean对象，以防止循环引用
boolean earlySingletonExposure =(mbd.isSingleton()&&this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if(earlySingletonExposure){
if(logger.isTraceEnabled()){
logger.trace("Eagerly caching bean '"+ beanName +
"' to allow for resolving potential circular references");
}
//为避免后期循环依赖，尽早持有对象的引用
addSingletonFactory(beanName,()->getEarlyBeanReference(beanName, mbd, bean));
}
//Bean对象的初始化，依赖注入在此触发，这个对象在初始化完成之后返回依赖注入完成后的Bean
Object exposedObject = bean;
try{
//将Bean实例对象封装，并且将Bean定义中配置的属性值赋给实例对象
populateBean(beanName, mbd, instanceWrapper);
//初始化Bean对象,Bean实例对象的依赖注入完成之后，为Bean实例对象
//应用BeanPostProcessor后置处理器
exposedObject =initializeBean(beanName, exposedObject, mbd);
}
catch(Throwable ex){
if(ex instanceofBeanCreationException&& beanName.equals(((BeanCreationException) ex).getBeanName())){
throw(BeanCreationException) ex;
}
else{
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Initialization of bean failed", ex);
}
}
if(earlySingletonExposure){
//获取指定名称的已注册的单例模式的Bean对象
Object earlySingletonReference =getSingleton(beanName,false);
if(earlySingletonReference !=null){
//根据名称获取已注册的Bean和正在实例化的Bean是同一个
if(exposedObject == bean){
//当前实例化的Bean初始化完成
exposedObject = earlySingletonReference;
}
//当前Bean依赖其他Bean,并且当发生循环引用时不允许创建新的实例对象
elseif(!this.allowRawInjectionDespiteWrapping &&hasDependentBean(beanName)){
String[] dependentBeans =getDependentBeans(beanName);
Set<String> actualDependentBeans =newLinkedHashSet<>(dependentBeans.length);
//获取当前Bean所依赖的其他Bean
for(String dependentBean : dependentBeans){
//对依赖Bean进行类型检查
if(!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)){
actualDependentBeans.add(dependentBean);
}
}
if(!actualDependentBeans.isEmpty()){
thrownewBeanCurrentlyInCreationException(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.");
}
}
}
}
// 注册完成依赖注入的Bean
try{
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch(BeanDefinitionValidationException ex){
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Invalid destruction signature", ex);
}
return exposedObject;
}通过上面的源码注释，我们看到具体的依赖注入实现其实就在以下两个方法中：
createBeanInstance()方法，生成Bean所包含的java对象实例。
populateBean()方法，对Bean属性的依赖注入进行处理。
下面继续分析这两个方法的代码实现。
1.4 选择 Bean 实例化策略
在createBeanInstance()方法中，根据指定的初始化策略，使用简单工厂、工厂方法或者容器的自动装配特性生成Java实例对象，创建对象的源码：
//创建Bean的实例对象
protectedBeanWrappercreateBeanInstance(String beanName,RootBeanDefinition mbd,@NullableObject[] args){
// 确认Bean是可实例化的
Class<?> beanClass =resolveBeanClass(mbd, beanName);
// 使用工厂方法对Bean进行实例化
if(beanClass !=null&&!Modifier.isPublic(beanClass.getModifiers())&&!mbd.isNonPublicAccessAllowed()){
thrownewBeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: "+ beanClass.getName());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if(instanceSupplier !=null){
returnobtainFromSupplier(instanceSupplier, beanName);
}
//调用工厂方法进行实例化
if(mbd.getFactoryMethodName()!=null){
returninstantiateUsingFactoryMethod(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的构造方法
returnautowireConstructor(beanName, mbd,null,null);
}
else{
//使用默认构造函数构造
returninstantiateBean(beanName, mbd);
}
}
// 使用Bean的构造方法进行实例化
Constructor<?>[] ctors =determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if(ctors !=null|| mbd.getResolvedAutowireMode()== AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues()||!ObjectUtils.isEmpty(args)){
//使用容器的自动装配特性，调用匹配的构造方法进行实例化
returnautowireConstructor(beanName, mbd, ctors, args);
}
ctors = mbd.getPreferredConstructors();
if(ctors !=null){
returnautowireConstructor(beanName, mbd, ctors,null);
}
//使用默认构造函数构造
returninstantiateBean(beanName, mbd);
}
//使用默认的无参构造方法实例化Bean对象
protectedBeanWrapperinstantiateBean(finalString beanName,finalRootBeanDefinition mbd){
try{
Object beanInstance;
finalBeanFactory parent =this;
//获取系统的安全管理接口、JDK标准的安全管理API
if(System.getSecurityManager()!=null){
//这是一个匿名内部类，根据实例化策略创建实例对象
beanInstance =AccessController.doPrivileged((PrivilegedAction<Object>)()->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else{
//将实例化的对象封装起来
beanInstance =getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw =newBeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch(Throwable ex){
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Instantiation of bean failed", ex);
}
}可以看出，对使用工厂方法和自动装配特性的Bean的实例化相当比较清楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作，但是对于我们最常使用的默认无参构造方法就需要使用相应的初始化策略(JDK 的反射机制或者 CGLib)来进行初始化了，在方法getInstantiationStrategy().instantiate()中就具体实现类使用初始策略实例化对象。
1.5 执行 Bean 实例化
在使用默认的无参构造方法创建Bean的实例化对象时，方法getInstantiationStrategy().instantiate()调用了SimpleInstantiationStrategy类中的实例化Bean的方法，其源码：
//使用初始化策略实例化Bean对象
@Override
publicObjectinstantiate(RootBeanDefinition bd,@NullableString beanName,BeanFactory owner){
//如果Bean定义中没有方法覆盖，就不需要CGLIB父类的方法
if(!bd.hasMethodOverrides()){
Constructor<?> constructorToUse;
synchronized(bd.constructorArgumentLock){
//获取对象的构造方法和工厂方法
constructorToUse =(Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
//如果没有构造方法且没有工厂方法
if(constructorToUse ==null){
//使用JDK的反射机制，判断要实例化的Bean是否有接口
finalClass<?> clazz = bd.getBeanClass();
if(clazz.isInterface()){
thrownewBeanInstantiationException(clazz,"Specified class is an interface");
}
try{
if(System.getSecurityManager()!=null){
//通过匿名内部类使用反射机制获取Bean的构造方法
constructorToUse =AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else{
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch(Throwable ex){
thrownewBeanInstantiationException(clazz,"No default constructor found", ex);
}
}
}
//使用BeanUtils进行实例化，通过反射机制调用构造方法.newInstance来进行实例化
returnBeanUtils.instantiateClass(constructorToUse);
}
else{
// Must generate CGLIB subclass.
//使用CGLIB来实例化对象
returninstantiateWithMethodInjection(bd, beanName, owner);
}
}我们看到了如果Bean有方法被覆盖了，则使用JDK的反射机制进行实例化。否则，使用CGLib进行实例化。
instantiateWithMethodInjection()方法用SimpleInstantiationStrategy的子类 CGLibSubclassingInstantiationStrategy使用CGLib来进行初始化，其源码：
//使用CGLIB进行Bean对象的实例化
publicObjectinstantiate(@NullableConstructor<?> ctor,Object... args){
//创建代理子类
Class<?> subclass =createEnhancedSubclass(this.beanDefinition);
Object instance;
if(ctor ==null){
instance =BeanUtils.instantiateClass(subclass);
}
else{
try{
Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
instance = enhancedSubclassConstructor.newInstance(args);
}
catch(Exception ex){
thrownewBeanInstantiationException(this.beanDefinition.getBeanClass(),
"Failed to invoke constructor for CGLIB enhanced subclass ["+ subclass.getName()+"]", ex);
}
}
Factory factory =(Factory) instance;
factory.setCallbacks(newCallback[]{NoOp.INSTANCE,
newLookupOverrideMethodInterceptor(this.beanDefinition,this.owner),
newReplaceOverrideMethodInterceptor(this.beanDefinition,this.owner)});
return instance;
}
privateClass<?>createEnhancedSubclass(RootBeanDefinition beanDefinition){
//CGLIB中的类
Enhancer enhancer =newEnhancer();
//将Bean本身作为基类
enhancer.setSuperclass(beanDefinition.getBeanClass());
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
if(this.owner instanceofConfigurableBeanFactory){
ClassLoader cl =((ConfigurableBeanFactory)this.owner).getBeanClassLoader();
enhancer.setStrategy(newClassLoaderAwareGeneratorStrategy(cl));
}
enhancer.setCallbackFilter(newMethodOverrideCallbackFilter(beanDefinition));
enhancer.setCallbackTypes(CALLBACK_TYPES);
//使用CGLIB的createClass方法生成实例对象
return enhancer.createClass();
}
}CGLib 是一个常用的字节码生成器的类库，它提供了一系列API实现Java字节码的生成和转换功能。JDK的动态代理只能针对接口，如果一个类没有实现任何接口，要对其进行动态代理只能使用CGLIB。
1.6 准备依赖注入
我们已经了解到Bean的依赖注入主要分为两个步骤，首先调用createBeanInstance()方法生成Bean所包含的Java对象实例。然后，调用populateBean()方法，对Bean属性的依赖注入进行处理。
上面我们已经分析了容器初始化生成Bean所包含的Java实例对象的过程，现在我们继续分析生成对象后，Spring IOC容器是如何将 Bean 的属性依赖关系注入Bean实例对象中并设置好的，回到AbstractAutowireCapableBeanFactor 的populateBean()方法，对属性依赖注入的代码：
//将Bean属性设置到生成的实例对象上
@SuppressWarnings("deprecation")
protectedvoidpopulateBean(String beanName,RootBeanDefinition mbd,@NullableBeanWrapper bw){
if(bw ==null){
if(mbd.hasPropertyValues()){
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Cannot apply property values to null instance");
}
else{
return;
}
}
if(!mbd.isSynthetic()&&hasInstantiationAwareBeanPostProcessors()){
for(BeanPostProcessor bp :getBeanPostProcessors()){
if(bp instanceofInstantiationAwareBeanPostProcessor){
InstantiationAwareBeanPostProcessor ibp =(InstantiationAwareBeanPostProcessor) bp;
if(!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)){
return;
}
}
}
}
//获取容器在解析Bean定义资源时为BeanDefinition设置的属性值
PropertyValues pvs =(mbd.hasPropertyValues()? mbd.getPropertyValues():null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if(resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE){
MutablePropertyValues newPvs =newMutablePropertyValues(pvs);
if(resolvedAutowireMode == AUTOWIRE_BY_NAME){
autowireByName(beanName, mbd, bw, newPvs);
}
if(resolvedAutowireMode == AUTOWIRE_BY_TYPE){
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps =hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck =(mbd.getDependencyCheck()!=AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds =null;
if(hasInstAwareBpps){
if(pvs ==null){
pvs = mbd.getPropertyValues();
}
for(BeanPostProcessor bp :getBeanPostProcessors()){
if(bp instanceofInstantiationAwareBeanPostProcessor){
InstantiationAwareBeanPostProcessor ibp =(InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if(pvsToUse ==null){
if(filteredPds ==null){
filteredPds =filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if(pvsToUse ==null){
return;
}
}
pvs = pvsToUse;
}
}
}
if(needsDepCheck){
if(filteredPds ==null){
filteredPds =filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if(pvs !=null){
//对属性进行注入
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
//解析并注入依赖属性的过程
protectedvoidapplyPropertyValues(String beanName,BeanDefinition mbd,BeanWrapper bw,PropertyValues pvs){
if(pvs.isEmpty()){
return;
}
if(System.getSecurityManager()!=null&& bw instanceofBeanWrapperImpl){
//设置安全上下文，JDK安全机制
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
//封装属性值
MutablePropertyValues mpvs =null;
List<PropertyValue> original;
if(pvs instanceofMutablePropertyValues){
mpvs =(MutablePropertyValues) pvs;
//属性值已经转换
if(mpvs.isConverted()){
// Shortcut: use the pre-converted values as-is.
try{
//为实例化对象设置属性值
bw.setPropertyValues(mpvs);
return;
}
catch(BeansException ex){
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Error setting property values", ex);
}
}
//获取属性值对象的原始类型值
original = mpvs.getPropertyValueList();
}
else{
original =Arrays.asList(pvs.getPropertyValues());
}
//获取用户自定义的类型转换
TypeConverter converter =getCustomTypeConverter();
if(converter ==null){
converter = bw;
}
//创建一个Bean定义属性值解析器，将Bean定义中的属性值解析为Bean实例对象的实际值
BeanDefinitionValueResolver valueResolver =newBeanDefinitionValueResolver(this, beanName, mbd, converter);
//为属性的解析值创建一个副本，将副本的数据注入实例对象
List<PropertyValue> deepCopy =newArrayList<>(original.size());
boolean resolveNecessary =false;
for(PropertyValue pv : original){
//属性值不需要转换
if(pv.isConverted()){
deepCopy.add(pv);
}
//属性值需要转换
else{
String propertyName = pv.getName();
//原始的属性值，即转换之前的属性值
Object originalValue = pv.getValue();
//转换属性值，例如将引用转换为IOC容器中实例化对象引用
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
//转换后的属性值
Object convertedValue = resolvedValue;
//属性值是否可以转换
boolean convertible = bw.isWritableProperty(propertyName)&&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if(convertible){
//使用用户自定义的类型转换器转换属性值
convertedValue =convertForProperty(resolvedValue, propertyName, bw, converter);
}
//存储转换后的属性值，避免每次属性注入时的转换工作
if(resolvedValue == originalValue){
if(convertible){
//设置属性转换之后的值
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
//属性是可转换的，且属性原始值是字符串类，属性的原始类型值不是动态生成的
//字符串，属性的原始值不是集合或者数组类型的
elseif(convertible && originalValue instanceofTypedStringValue&&
!((TypedStringValue) originalValue).isDynamic()&&
!(convertedValue instanceofCollection||ObjectUtils.isArray(convertedValue))){
pv.setConvertedValue(convertedValue);
//重新封装属性值
deepCopy.add(pv);
}
else{
resolveNecessary =true;
deepCopy.add(newPropertyValue(pv, convertedValue));
}
}
}
if(mpvs !=null&&!resolveNecessary){
//标记属性值已经转换过
mpvs.setConverted();
}
//进行属性的依赖注入
try{
bw.setPropertyValues(newMutablePropertyValues(deepCopy));
}
catch(BeansException ex){
thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Error setting property values", ex);
}
}可以看出，对属性的注入过程分以下两种情况：
属性值类型不需要强制转换时，不需要解析属性值，直接准备进行依赖注入。
属性值需要进行类型强制转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。
对属性值的解析是在BeanDefinitionValueResolver类中的resolveValueIfNecessary()方法中进行的，对属性值的依赖注入是通过bw.setPropertyValues()方法实现的，在分析属性值的依赖注入之前，我们先分析一下对属性值的解析过程。
1.7 解析属性注入规则
当容器在对属性进行依赖注入时，如果发现属性值需要进行类型转换，如属性值是容器中另一个 Bean实例对象的引用，则容器首先需要根据属性值解析出所引用的对象，然后才能将该引用对象注入到目标实例对象的属性上去，对属性进行解析的由 resolveValueIfNecessary()方法实现，其源码：
//解析属性值，对注入类型进行转换
@Nullable
publicObjectresolveValueIfNecessary(Object argName,@NullableObject value){
//对应用类型的属性进行解析
if(value instanceofRuntimeBeanReference){
RuntimeBeanReference ref =(RuntimeBeanReference) value;
//调用引用类型属性的解析方法
returnresolveReference(argName, ref);
}
//对引用容器中另一个Bean名称的属性进行解析
elseif(value instanceofRuntimeBeanNameReference){
String refName =((RuntimeBeanNameReference) value).getBeanName();
refName =String.valueOf(doEvaluate(refName));
//从容器中获取指定名称的Bean
if(!this.beanFactory.containsBean(refName)){
thrownewBeanDefinitionStoreException(
"Invalid bean name '"+ refName +"' in bean reference for "+ argName);
}
return refName;
}
//对Bean类型属性的解析，主要是指Bean的内部类
elseif(value instanceofBeanDefinitionHolder){
// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
BeanDefinitionHolder bdHolder =(BeanDefinitionHolder) value;
returnresolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
}
elseif(value instanceofBeanDefinition){
// Resolve plain BeanDefinition, without contained name: use dummy name.
BeanDefinition bd =(BeanDefinition) value;
String innerBeanName ="(inner bean)"+BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
ObjectUtils.getIdentityHexString(bd);
returnresolveInnerBean(argName, innerBeanName, bd);
}
//对集合数组类型的属性进行解析
elseif(value instanceofManagedArray){
ManagedArray array =(ManagedArray) value;
//获取数组的类型
Class<?> elementType = array.resolvedElementType;
if(elementType ==null){
//获取数组元素的类型
String elementTypeName = array.getElementTypeName();
if(StringUtils.hasText(elementTypeName)){
try{
//使用反射机制创建指定类型的对象
elementType =ClassUtils.forName(elementTypeName,this.beanFactory.getBeanClassLoader());
array.resolvedElementType = elementType;
}
catch(Throwable ex){
// Improve the message by showing the context.
thrownewBeanCreationException(
this.beanDefinition.getResourceDescription(),this.beanName,
"Error resolving array type for "+ argName, ex);
}
}
//没有获取到数组的类型，也没有获取到数组元素的类型则直接设置类型为Object
else{
elementType =Object.class;
}
}
//创建指定类型的数组
returnresolveManagedArray(argName,(List<?>) value, elementType);
}
//解析list类型的属性值
elseif(value instanceofManagedList){
returnresolveManagedList(argName,(List<?>) value);
}
//解析set类型的属性值
elseif(value instanceofManagedSet){
returnresolveManagedSet(argName,(Set<?>) value);
}
//解析map类型的属性值
elseif(value instanceofManagedMap){
returnresolveManagedMap(argName,(Map<?,?>) value);
}
//解析props类型的属性值
elseif(value instanceofManagedProperties){
Properties original =(Properties) value;
//创建一个副本，作为解析后的返回值
Properties copy =newProperties();
original.forEach((propKey, propValue)->{
if(propKey instanceofTypedStringValue){
propKey =evaluate((TypedStringValue) propKey);
}
if(propValue instanceofTypedStringValue){
propValue =evaluate((TypedStringValue) propValue);
}
if(propKey ==null|| propValue ==null){
thrownewBeanCreationException(
this.beanDefinition.getResourceDescription(),this.beanName,
"Error converting Properties key/value pair for "+ argName +": resolved to null");
}
copy.put(propKey, propValue);
});
return copy;
}
//解析字符串类型的属性值
elseif(value instanceofTypedStringValue){
// Convert value to target type here.
TypedStringValue typedStringValue =(TypedStringValue) value;
Object valueObject =evaluate(typedStringValue);
try{
//获取属性的目标类型
Class<?> resolvedTargetType =resolveTargetType(typedStringValue);
if(resolvedTargetType !=null){
//对目标类型的属性进行解析，递归调用
returnthis.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
}
//没有获取到属性的目标对象，则按object类型返回
else{
return valueObject;
}
}
catch(Throwable ex){
// Improve the message by showing the context.
thrownewBeanCreationException(
this.beanDefinition.getResourceDescription(),this.beanName,
"Error converting typed String value for "+ argName, ex);
}
}
elseif(value instanceofNullBean){
returnnull;
}
else{
returnevaluate(value);
}
}
//解析引用类型的属性值
@Nullable
privateObjectresolveReference(Object argName,RuntimeBeanReference ref){
try{
Object bean;
//获取引用的Bean名称
String refName = ref.getBeanName();
refName =String.valueOf(doEvaluate(refName));
//如果引用的对象在父容器中，则从父类容器中获取指定的引用对象
if(ref.isToParent()){
if(this.beanFactory.getParentBeanFactory()==null){
thrownewBeanCreationException(
this.beanDefinition.getResourceDescription(),this.beanName,
"Can't resolve reference to bean '"+ refName +
"' in parent factory: no parent factory available");
}
bean =this.beanFactory.getParentBeanFactory().getBean(refName);
}
//从当前的容器中获取指定的引用Bean对象，如果指定的Bean没有实例化，
//则会递归触发引用Bean的初始化和依赖注入
else{
bean =this.beanFactory.getBean(refName);
this.beanFactory.registerDependentBean(refName,this.beanName);
}
if(bean instanceofNullBean){
bean =null;
}
return bean;
}
catch(BeansException ex){
thrownewBeanCreationException(
this.beanDefinition.getResourceDescription(),this.beanName,
"Cannot resolve reference to bean '"+ ref.getBeanName()+"' while setting "+ argName, ex);
}
}
//解析array类型的属性值
privateObjectresolveManagedArray(Object argName,List<?> ml,Class<?> elementType){
//创建一个指定类型的数组，用于存放和返回解析后的数组
Object resolved =Array.newInstance(elementType, ml.size());
for(int i =0; i < ml.size(); i++){
//递归解析array的每一个元素，并将解析后的值设置到resolved数组中，索引为i
Array.set(resolved, i,resolveValueIfNecessary(newKeyedArgName(argName, i), ml.get(i)));
}
return resolved;
}通过上面的代码分析，我们明白Spring是如何将引用类型，内部类以及集合类型等属性进行解析的，属性值解析完成后就可以进行依赖注入了，依赖注入的过程就是Bean对象实例设置到它所依赖的Bean对象属性上去。
而真正的依赖注入是通过bw.setPropertyValues()方法实现的，该方法也使用了委托模式 ， 在BeanWrapper接口中至少定义了方法声明，依赖注入的具体实现交由其实现类BeanWrapperImpl来完成，下面我们就分析依BeanWrapperImpl中赖注入相关的源码。
1.8 注入赋值
BeanWrapperImpl类主要是对容器中完成初始化的Bean实例对象进行属性的依赖注入，即把 Bean对象设置到它所依赖的另一个Bean的属性中去。然而，BeanWrapperImpl中的注入方法实际上由AbstractNestablePropertyAccessor来实现的，其相关源码：
//实现属性依赖注入功能
protectedvoidsetPropertyValue(PropertyTokenHolder tokens,PropertyValue pv)throwsBeansException{
if(tokens.keys !=null){
processKeyedProperty(tokens, pv);
}
else{
processLocalProperty(tokens, pv);
}
}
//实现属性依赖注入功能
@SuppressWarnings("unchecked")
privatevoidprocessKeyedProperty(PropertyTokenHolder tokens,PropertyValue pv){
//调用属性的getter方法获取属性值
Object propValue =getPropertyHoldingValue(tokens);
PropertyHandler ph =getLocalPropertyHandler(tokens.actualName);
if(ph ==null){
thrownewInvalidPropertyException(
getRootClass(),this.nestedPath + tokens.actualName,"No property handler found");
}
Assert.state(tokens.keys !=null,"No token keys");
String lastKey = tokens.keys[tokens.keys.length -1];
//注入array类型的属性值
if(propValue.getClass().isArray()){
Class<?> requiredType = propValue.getClass().getComponentType();
int arrayIndex =Integer.parseInt(lastKey);
Object oldValue =null;
try{
if(isExtractOldValueForEditor()&& arrayIndex <Array.getLength(propValue)){
oldValue =Array.get(propValue, arrayIndex);
}
Object convertedValue =convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
requiredType, ph.nested(tokens.keys.length));
//获取集合类型属性的长度
int length =Array.getLength(propValue);
if(arrayIndex >= length && arrayIndex <this.autoGrowCollectionLimit){
Class<?> componentType = propValue.getClass().getComponentType();
Object newArray =Array.newInstance(componentType, arrayIndex +1);
System.arraycopy(propValue,0, newArray,0, length);
setPropertyValue(tokens.actualName, newArray);
//调用属性值赋值给数组中的元素
propValue =getPropertyValue(tokens.actualName);
}
//将属性的值赋值给数组中的元素
Array.set(propValue, arrayIndex, convertedValue);
}
catch(IndexOutOfBoundsException ex){
thrownewInvalidPropertyException(getRootClass(),this.nestedPath + tokens.canonicalName,
"Invalid array index in property path '"+ tokens.canonicalName +"'", ex);
}
}
//注入list类型的属性值
elseif(propValue instanceofList){
//获取list集合的类型
Class<?> requiredType = ph.getCollectionType(tokens.keys.length);
List<Object> list =(List<Object>) propValue;
//获取list集合的size
int index =Integer.parseInt(lastKey);
Object oldValue =null;
if(isExtractOldValueForEditor()&& index < list.size()){
oldValue = list.get(index);
}
//获取解析后list的属性值
Object convertedValue =convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
requiredType, ph.nested(tokens.keys.length));
int size = list.size();
//如果list的长度大于属性值的长度，则将多余的元素赋值为null
if(index >= size && index <this.autoGrowCollectionLimit){
for(int i = size; i < index; i++){
try{
list.add(null);
}
catch(NullPointerException ex){
thrownewInvalidPropertyException(getRootClass(),this.nestedPath + tokens.canonicalName,
"Cannot set element with index "+ index +" in List of size "+
size +", accessed using property path '"+ tokens.canonicalName +
"': List does not support filling up gaps with null elements");
}
}
list.add(convertedValue);
}
else{
try{
//将值添加到list中
list.set(index, convertedValue);
}
catch(IndexOutOfBoundsException ex){
thrownewInvalidPropertyException(getRootClass(),this.nestedPath + tokens.canonicalName,
"Invalid list index in property path '"+ tokens.canonicalName +"'", ex);
}
}
}
//注入map类型的属性值
elseif(propValue instanceofMap){
//获取map集合key的类型
Class<?> mapKeyType = ph.getMapKeyType(tokens.keys.length);
//获取map集合的value的类型
Class<?> mapValueType = ph.getMapValueType(tokens.keys.length);
Map<Object,Object> map =(Map<Object,Object>) propValue;
TypeDescriptor typeDescriptor =TypeDescriptor.valueOf(mapKeyType);
//解析map类型的属性key值
Object convertedMapKey =convertIfNecessary(null,null, lastKey, mapKeyType, typeDescriptor);
Object oldValue =null;
if(isExtractOldValueForEditor()){
oldValue = map.get(convertedMapKey);
}
//解析map类型的属性value值
Object convertedMapValue =convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
mapValueType, ph.nested(tokens.keys.length));
//将解析后的key和value赋值给map属性
map.put(convertedMapKey, convertedMapValue);
}
else{
thrownewInvalidPropertyException(getRootClass(),this.nestedPath + tokens.canonicalName,
"Property referenced in indexed property path '"+ tokens.canonicalName +
"' is neither an array nor a List nor a Map; returned value was ["+ propValue +"]");
}
}
privateObjectgetPropertyHoldingValue(PropertyTokenHolder tokens){
Assert.state(tokens.keys !=null,"No token keys");
PropertyTokenHolder getterTokens =newPropertyTokenHolder(tokens.actualName);
getterTokens.canonicalName = tokens.canonicalName;
getterTokens.keys =newString[tokens.keys.length -1];
System.arraycopy(tokens.keys,0, getterTokens.keys,0, tokens.keys.length -1);
Object propValue;
try{
//获取属性值
propValue =getPropertyValue(getterTokens);
}
catch(NotReadablePropertyException ex){
thrownewNotWritablePropertyException(getRootClass(),this.nestedPath + tokens.canonicalName,
"Cannot access indexed value in property referenced "+
"in indexed property path '"+ tokens.canonicalName +"'", ex);
}
if(propValue ==null){
if(isAutoGrowNestedPaths()){
int lastKeyIndex = tokens.canonicalName.lastIndexOf('[');
getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
propValue =setDefaultValue(getterTokens);
}
else{
thrownewNullValueInNestedPathException(getRootClass(),this.nestedPath + tokens.canonicalName,
"Cannot access indexed value in property referenced "+
"in indexed property path '"+ tokens.canonicalName +"': returned null");
}
}
return propValue;
}通过对上面注入依赖代码的分析，我们已经明白了Spring IOC容器是如何将属性的值注入到Bean实例对象中去的：
对于集合类型的属性，将其属性值解析为目标类型的集合后直接赋值给属性。
对于非集合类型的属性，大量使用了JDK的反射机制，通过属性的getter()方法获取指定属性注入以前的值，同时调用属性的setter()方法为属性设置注入后的值。
1.9 小结
Bean的加载流程：
二、基于Annotation的依赖注入
从Spring2.0以后的版本中，Spring也引入了基于注解(Annotation)方式的配置，注解(Annotation)是JDK1.5中引入的一个新特性，用于简化Bean的配置，可以取代XML配置文件。
Spring IOC容器对于类级别的注解和类内部的注解分以下两种处理策略：
1、类级别的注解
如@Component、@Repository、@Controller、@Service等，Spring容器根据注解的过滤规则扫描读取注解Bean定义类，并将其注册到Spring IOC容器中。
2、类内部的注解
如@Autowire、@Value、@Resource等，都是添加在类内部的字段或者方法上的类内部注解，SpringIOC容器通过Bean后置注解处理器解析Bean内部的注解。下面将根据这两种处理策略，分别分析Spring处理注解相关的源码。
2.1 定位Bean扫描路径
在Spring中管理注解Bean定义的容器有两个：AnnotationConfigApplicationContext和 AnnotationConfigWebApplicationContex。这两个类是专门处理 Spring 注解方式配置的容器，直接依赖于注解作为容器配置信息来源的 IOC 容器。
AnnotationConfigWebApplicationContext是AnnotationConfigApplicationContext的Web版本，两者的用法以及对注解的处理方式几乎没有差别。现在我们以AnnotationConfigApplicationContext 为例看看它的源码：
publicclassAnnotationConfigApplicationContextextendsGenericApplicationContextimplementsAnnotationConfigRegistry{
// 保存一个读取注解的Bean定义读取器，并将其设置到容器中
privatefinalAnnotatedBeanDefinitionReader reader;
//保存一个扫描指定类路径中注解Bean定义的搜啊苗期，并将其设置到容器中
privatefinalClassPathBeanDefinitionScanner scanner;
//默认构造方法，初始化一个空容器，容器中不包含任何Bean信息，需要稍后通过调用register方法注册
//配置类，并调用refresh方法刷新容器，触发容器对注解bean的载入、解析和注册
publicAnnotationConfigApplicationContext(){
this.reader =newAnnotatedBeanDefinitionReader(this);
this.scanner =newClassPathBeanDefinitionScanner(this);
}
publicAnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory){
super(beanFactory);
this.reader =newAnnotatedBeanDefinitionReader(this);
this.scanner =newClassPathBeanDefinitionScanner(this);
}
//最常用的构造函数，通过将涉及的配置类传递给该构造函数，实现将应用配置类中的
//Bean自动注册到容器中
publicAnnotationConfigApplicationContext(Class<?>... componentClasses){
this();
register(componentClasses);
refresh();
}
//该构造函数会自动扫描已给定的包及其子包下的所有类，并自动识别所有的Spring Bean，
//将其注册到容器中
publicAnnotationConfigApplicationContext(String... basePackages){
this();
scan(basePackages);
refresh();
}
@Override
publicvoidsetEnvironment(ConfigurableEnvironment environment){
super.setEnvironment(environment);
this.reader.setEnvironment(environment);
this.scanner.setEnvironment(environment);
}
///为容器的注解Bean读取器和注解Bean扫描器设置Bean名称产生器
publicvoidsetBeanNameGenerator(BeanNameGenerator beanNameGenerator){
this.reader.setBeanNameGenerator(beanNameGenerator);
this.scanner.setBeanNameGenerator(beanNameGenerator);
getBeanFactory().registerSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
}
//为容器的注解Bean读取器和注解Bean扫描器设置作用范围元信息解析器
publicvoidsetScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver){
this.reader.setScopeMetadataResolver(scopeMetadataResolver);
this.scanner.setScopeMetadataResolver(scopeMetadataResolver);
}
//为容器注册一个要被处理的注解Bean，新注册的Bean，必须手动调用容器的refresh方法刷新容器，
//触发容器对新注册Bean的处理
@Override
publicvoidregister(Class<?>... componentClasses){
Assert.notEmpty(componentClasses,"At least one component class must be specified");
this.reader.register(componentClasses);
}
//扫描制定包路径及其子包下的注解类，为了使新添加的类被处理，必须手动调用refresh方法刷新容器
@Override
publicvoidscan(String... basePackages){
Assert.notEmpty(basePackages,"At least one base package must be specified");
this.scanner.scan(basePackages);
}通过上面的源码，我们可以看到Spring对注解的处理分为两种方式：
1、直接将注解Bean注册到容器中
可以在初始化容器时注册；也可以在容器创建之后手动调用注册方法向容器注册，然后通过手动刷新容器，使得容器对注册的注解Bean进行处理。
2、通过扫描指定的包及其子包下的所有类
在初始化注解容器时指定要自动扫描的路径，如果容器创建以后向给定路径动态添加了注解Bean，则需要手动调用容器扫描的方法，然后手动刷新容器，使得容器对所注册的Bean进行处理。
接下来，将会对两种处理方式详细分析其实现过程。
2.2 读取Annotation元数据
当创建注解处理容器时，如果传入的初始参数是具体的注解Bean定义类时，注解容器读取并注册。
1、AnnotationConfigApplicationContext通过调用注解Bean定义读取器
AnnotatedBeanDefinitionReader的register()方法向容器注册指定的注解 Bean，注解Bean定义读取器向容器注册注解Bean的源码：
//注册多个注解Bean定义类
publicvoidregister(Class<?>... componentClasses){
for(Class<?> componentClass : componentClasses){
registerBean(componentClass);
}
}
//注册一个注解Bean定义类
publicvoidregisterBean(Class<?> beanClass){
doRegisterBean(beanClass,null,null,null);
}
public<T>voidregisterBean(Class<T> beanClass,@NullableSupplier<T> instanceSupplier){
doRegisterBean(beanClass, instanceSupplier,null,null);
}
public<T>voidregisterBean(Class<T> beanClass,String name,@NullableSupplier<T> instanceSupplier){
doRegisterBean(beanClass, instanceSupplier, name,null);
}
//Bean定义读取器注册注解Bean定义的入口方法
@SuppressWarnings("unchecked")
publicvoidregisterBean(Class<?> beanClass,Class<?extendsAnnotation>... qualifiers){
doRegisterBean(beanClass,null,null, qualifiers);
}
//Bean定义读取器向容器注册注解Bean定义类
@SuppressWarnings("unchecked")
publicvoidregisterBean(Class<?> beanClass,String name,Class<?extendsAnnotation>... qualifiers){
doRegisterBean(beanClass,null, name, qualifiers);
}
//Bean定义读取器向容器注册注解Bean定义类
<T>voiddoRegisterBean(Class<T> beanClass,@NullableSupplier<T> instanceSupplier,@NullableString name,
@NullableClass<?extendsAnnotation>[] qualifiers,BeanDefinitionCustomizer... definitionCustomizers){
//根据指定的注解Bean定义类，创建Spring容器中对注解Bean的封装的数据结构
AnnotatedGenericBeanDefinition abd =newAnnotatedGenericBeanDefinition(beanClass);
if(this.conditionEvaluator.shouldSkip(abd.getMetadata())){
return;
}
abd.setInstanceSupplier(instanceSupplier);
//解析注解Bean定义的作用域，若@Scope("prototype")，则Bean为原型类型；
//若@Scope("singleton")，则Bean为单例类型；
ScopeMetadata scopeMetadata =this.scopeMetadataResolver.resolveScopeMetadata(abd);
//设置作用域
abd.setScope(scopeMetadata.getScopeName());
//生成Bean名称
String beanName =(name !=null? name :this.beanNameGenerator.generateBeanName(abd,this.registry));
//处理注解Bean定义中的通用注解
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
//如果在向容器注册注解Bean定义时，使用了额外的限定符注解，则解析限定符注解。
//主要是配置的关于autowiring自动依赖注入装配的限定条件，即@Qualifier注解
//Spring自动依赖注入装配默认是按类型装配，如果使用@Qualifier则按名称
if(qualifiers !=null){
for(Class<?extendsAnnotation> qualifier : qualifiers){
//如果配置了@Primary注解，设置该Bean为autowiring自动依赖注入装配时的首选
if(Primary.class== qualifier){
abd.setPrimary(true);
}
//如果设置了@Lazy注解，则设置该Bean为非延迟初始化
//如果没有设置，则该Bean为预实例化
elseif(Lazy.class== qualifier){
abd.setLazyInit(true);
}
else{
//如果使用了@Primary和@Lazy之外的其他注解，则为该Bean添加一个autowired自动
//依赖注入装配限定符，根据名称进行装配
abd.addQualifier(newAutowireCandidateQualifier(qualifier));
}
}
}
for(BeanDefinitionCustomizer customizer : definitionCustomizers){
customizer.customize(abd);
}
//创建一个指定Bean名称的Bean定义对象，封装注解Bean定义类数据
BeanDefinitionHolder definitionHolder =newBeanDefinitionHolder(abd, beanName);
//根据注解Bean定义类中配置的作用于，创建相应的代理对象
definitionHolder =AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder,this.registry);
//向IOC容器注册注解Bean类定义对象
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder,this.registry);
}从上面的源码我们可以看出，注册注解Bean定义类的基本步骤：
需要使用注解元数据解析器解析注解Bean中关于作用域的配置。
使用AnnotationConfigUtils的processCommonDefinitionAnnotations()方法处理注解Bean定义类中通用的注解。
使用AnnotationConfigUtils的applyScopedProxyMode()方法创建对于作用域的代理对象。
通过BeanDefinitionReaderUtils向容器注册Bean。
2、AnnotationScopeMetadataResolver解析作用域元数据
AnnotationScopeMetadataResolver通过resolveScopeMetadata()方法，解析注解Bean定义类的作用域元信息，即判断注册的Bean是原生类型(prototype)还是单态(singleton)类型，其源码：
//解析注解Bean定义类中的作用域元信息
@Override
publicScopeMetadataresolveScopeMetadata(BeanDefinition definition){
ScopeMetadata metadata =newScopeMetadata();
if(definition instanceofAnnotatedBeanDefinition){
AnnotatedBeanDefinition annDef =(AnnotatedBeanDefinition) definition;
//从注解Bean定义类的属性中查找属性为Scope的值，即@Scope注解的值
//annDef.getMetadata()将Bean中所有的注解和注解的值存放在map中
AnnotationAttributes attributes =AnnotationConfigUtils.attributesFor(
annDef.getMetadata(),this.scopeAnnotationType);
//将获取的scope注解的值设置到要返回的对象中
if(attributes !=null){
metadata.setScopeName(attributes.getString("value"));
//获取ProxyMode属性值，在创建代理对象的时候回用
ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
//设置proxyMode的属性值
if(proxyMode ==ScopedProxyMode.DEFAULT){
//设置proxyMode为NO
proxyMode =this.defaultProxyMode;
}
//为返回的元数据设置proxyMode
metadata.setScopedProxyMode(proxyMode);
}
}
return metadata;
}上述代码中的annDef.getMetadata().getAnnotationAttributes()方法就是获取对象中指定类型的注解的值。
3、AnnotationConfigUtils处理注解Bean定义类中的通用注解
AnnotationConfigUtils的processCommonDefinitionAnnotations()在向容器注册Bean之前，首先对注解Bean定义类中的通用Spring注解进行处理，源码：
//处理Bean定义的通用注解
staticvoidprocessCommonDefinitionAnnotations(AnnotatedBeanDefinition abd,AnnotatedTypeMetadata metadata){
//设置Lazy注解属性的值
AnnotationAttributes lazy =attributesFor(metadata,Lazy.class);
//如果Bean定义中有@Lazy注解，则将该Bean与实例化属性设置为@Lazy注解的值
if(lazy !=null){
abd.setLazyInit(lazy.getBoolean("value"));
}
elseif(abd.getMetadata()!= metadata){
lazy =attributesFor(abd.getMetadata(),Lazy.class);
if(lazy !=null){
abd.setLazyInit(lazy.getBoolean("value"));
}
}
//判断是否有@Primary注解，如果有则设置为依赖注入装配的首选对象
if(metadata.isAnnotated(Primary.class.getName())){
abd.setPrimary(true);
}
//如果有@DependsOn注解，则为该Bean设置需要依赖的Bean名称
//容器将确保在实例化该Bean之前首先实例化所依赖的Bean
AnnotationAttributes dependsOn =attributesFor(metadata,DependsOn.class);
if(dependsOn !=null){
abd.setDependsOn(dependsOn.getStringArray("value"));
}
AnnotationAttributes role =attributesFor(metadata,Role.class);
if(role !=null){
abd.setRole(role.getNumber("value").intValue());
}
AnnotationAttributes description =attributesFor(metadata,Description.class);
if(description !=null){
abd.setDescription(description.getString("value"));
}
}4、AnnotationConfigUtils根据注解Bean定义类中配置的作用域为其应用相应的代理策略
AnnotationConfigUtils类的applyScopedProxyMode()方法根据注解Bean定义类中配置的作用域@Scope 注解的值，为Bean定义应用相应的代理模式，主要是在Spring面向切面编程(AOP)中使用。
//根据作用域为Bean定义应用的代理模式
staticBeanDefinitionHolderapplyScopedProxyMode(
ScopeMetadata metadata,BeanDefinitionHolder definition,BeanDefinitionRegistry registry){
//获取注解Bean定义类中Scope注解的ProxyMode属性值
ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
//如果值为no，则不应用代理模式
if(scopedProxyMode.equals(ScopedProxyMode.NO)){
return definition;
}
//如果属性值为TARGET_CLASS，则返回true
//如果为INTERFACES，则返回false
boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
//为注册的Bean创建相应模式的代理对象
returnScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}这段为 Bean 引用创建相应模式的代理。
5、BeanDefinitionReaderUtils 向容器注册 Bean
BeanDefinitionReaderUtils 主要是校验 BeanDefinition 信息，然后将 Bean 添加到容器中一个管理BeanDefinition 的 HashMap 中。
2.3 扫描指定包并解析为BeanDefinition
当创建注解处理容器时，如果传入的初始参数是注解Bean定义类所在的包时，注解容器将扫描给定的包及其子包，将扫描到的注解Bean定义载入并注册。
1、ClassPathBeanDefinitionScanner扫描给定的包及其子包
AnnotationConfigApplicationContext通过调用类路径Bean定义扫描器 ClassPathBeanDefinitionScanner扫描给定包及其子包下的所有类，主要源码：
publicclassClassPathBeanDefinitionScannerextendsClassPathScanningCandidateComponentProvider{
//创建一个类路径Bean定义扫描器
publicClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry){
this(registry,true);
}
//为容器窗帘一个类路径Bean定义扫描器，并制定是否使用默认的扫描过滤规则
//即Spring默认扫描配置：@Component、@Repository、@Service、@Controller注解的Bean
publicClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,boolean useDefaultFilters){
this(registry, useDefaultFilters,getOrCreateEnvironment(registry));
}
publicClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,boolean useDefaultFilters,
Environment environment){
this(registry, useDefaultFilters, environment,
(registry instanceofResourceLoader?(ResourceLoader) registry :null));
}
publicClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry,boolean useDefaultFilters,
Environment environment,@NullableResourceLoader resourceLoader){
Assert.notNull(registry,"BeanDefinitionRegistry must not be null");
//为容器设置加载Bean定义的注册器
this.registry = registry;
if(useDefaultFilters){
registerDefaultFilters();
}
setEnvironment(environment);
//为容器设置资源加载器
setResourceLoader(resourceLoader);
}
//调用类路径Bean定义扫描器入口方法
publicintscan(String... basePackages){
//获取容器中已经注册的Bean的个数
int beanCountAtScanStart =this.registry.getBeanDefinitionCount();
//启动扫描器扫描给定包
doScan(basePackages);
//注册注解配置annotation config处理器
if(this.includeAnnotationConfig){
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
//返回注册的Bean的个数
return(this.registry.getBeanDefinitionCount()- beanCountAtScanStart);
}
// 类路径Bean定义扫描器扫描给定包及子包
protectedSet<BeanDefinitionHolder>doScan(String... basePackages){
Assert.notEmpty(basePackages,"At least one base package must be specified");
//创建一个集合，存放扫描到Bean定义的封装类
Set<BeanDefinitionHolder> beanDefinitions =newLinkedHashSet<>();
//遍历扫描所有给定的包
for(String basePackage : basePackages){
//扫描给定类路径，获取符合条件的Bean定义
Set<BeanDefinition> candidates =findCandidateComponents(basePackage);
//遍历扫描到的Bean
for(BeanDefinition candidate : candidates){
//获取Bean的作用域
ScopeMetadata scopeMetadata =this.scopeMetadataResolver.resolveScopeMetadata(candidate);
//为Bean设置作用域
candidate.setScope(scopeMetadata.getScopeName());
//为Bean生成名称
String beanName =this.beanNameGenerator.generateBeanName(candidate,this.registry);
//如果扫描到的Bean不是Spring的注解Bean,则为Bean设置默认值
if(candidate instanceofAbstractBeanDefinition){
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
//如果是Spring的注解Bean,则处理通用的注解
if(candidate instanceofAnnotatedBeanDefinition){
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//根据Bean名称检查指定Bean是否需要在容器中注册
if(checkCandidate(beanName, candidate)){
BeanDefinitionHolder definitionHolder =newBeanDefinitionHolder(candidate, beanName);
//根据注解中配置的作用域，为Bean应用相应的代理模式
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder,this.registry);
beanDefinitions.add(definitionHolder);
//向容器注册扫描到的Bean
registerBeanDefinition(definitionHolder,this.registry);
}
}
}
return beanDefinitions;
}类路径Bean定义扫描器ClassPathBeanDefinitionScanner主要通过findCandidateComponents()方法调用其父类ClassPathScanningCandidateComponentProvider 类来扫描获取给定包及其子包下的类。
2、ClassPathScanningCandidateComponentProvider扫描给定包及其子包的类
ClassPathScanningCandidateComponentProvider类的findCandidateComponents()方法具体实现扫描给定类路径包的功能，主要源码：
publicclassClassPathScanningCandidateComponentProviderimplementsEnvironmentCapable,ResourceLoaderAware{
//保存过滤规则包含的注解，即Spring默认的@Component、@Repository、@Service、@Controller注解的Bean
privatefinalList<TypeFilter> includeFilters =newLinkedList<>();
//保存过滤规则要排除的注解
privatefinalList<TypeFilter> excludeFilters =newLinkedList<>();
//构造方法，该方法在子类ClassPathBeanDefinitionScanner的构造方法中被调用
publicClassPathScanningCandidateComponentProvider(boolean useDefaultFilters){
this(useDefaultFilters,newStandardEnvironment());
}
publicClassPathScanningCandidateComponentProvider(boolean useDefaultFilters,Environment environment){
//如果使用Spring默认的过滤规则，向容器注册过滤规则
if(useDefaultFilters){
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(null);
}
//向容器中注册过滤规则
@SuppressWarnings("unchecked")
protectedvoidregisterDefaultFilters(){
//向要包含的过滤规则添加@Component注解，注意Spring中@Repository、@Service和@Controller都是Component
//因为这些注解都添加了@Component注解
this.includeFilters.add(newAnnotationTypeFilter(Component.class));
//获取当前类的类加载器
ClassLoader cl =ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try{
//向要包含的过滤规则中添加@ManagedBean注解
this.includeFilters.add(newAnnotationTypeFilter(
((Class<?extendsAnnotation>)ClassUtils.forName("javax.annotation.ManagedBean", cl)),false));
logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch(ClassNotFoundException ex){
}
try{
//向要包含的过滤规则添加@Named注解
this.includeFilters.add(newAnnotationTypeFilter(
((Class<?extendsAnnotation>)ClassUtils.forName("javax.inject.Named", cl)),false));
logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch(ClassNotFoundException ex){
}
}
//扫描给定类路径的包
publicSet<BeanDefinition>findCandidateComponents(String basePackage){
if(this.componentsIndex !=null&&indexSupportsIncludeFilters()){
returnaddCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else{
returnscanCandidateComponents(basePackage);
}
}
privateSet<BeanDefinition>addCandidateComponentsFromIndex(CandidateComponentsIndex index,String basePackage){
//创建存储扫描到的类的集合
Set<BeanDefinition> candidates =newLinkedHashSet<>();
try{
Set<String> types =newHashSet<>();
for(TypeFilter filter :this.includeFilters){
String stereotype =extractStereotype(filter);
if(stereotype ==null){
thrownewIllegalArgumentException("Failed to extract stereotype from "+ filter);
}
types.addAll(index.getCandidateTypes(basePackage, stereotype));
}
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for(String type : types){
//为指定资源获取元数据读取器，元数据读取器通过汇编(ASM)读取资源的元信息
MetadataReader metadataReader =getMetadataReaderFactory().getMetadataReader(type);
//如果扫描到的类符合容器配置的过滤规则
if(isCandidateComponent(metadataReader)){
//通过汇编(ASM)读取资源字节码中的Bean定义的元信息
AnnotatedGenericBeanDefinition sbd =newAnnotatedGenericBeanDefinition(
metadataReader.getAnnotationMetadata());
if(isCandidateComponent(sbd)){
if(debugEnabled){
logger.debug("Using candidate component class from index: "+ type);
}
candidates.add(sbd);
}
else{
if(debugEnabled){
logger.debug("Ignored because not a concrete top-level class: "+ type);
}
}
}
else{
if(traceEnabled){
logger.trace("Ignored because matching an exclude filter: "+ type);
}
}
}
}
catch(IOException ex){
thrownewBeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
//判断元信息读取器读取的类是否符合容器定义的注解过滤规则
protectedbooleanisCandidateComponent(MetadataReader metadataReader)throwsIOException{
//如果读取的类的注解在排除规则中，返回false
for(TypeFilter tf :this.excludeFilters){
if(tf.match(metadataReader,getMetadataReaderFactory())){
returnfalse;
}
}
//如果读取的类的注解在包含的注解过滤规则中，则返回true
for(TypeFilter tf :this.includeFilters){
if(tf.match(metadataReader,getMetadataReaderFactory())){
returnisConditionMatch(metadataReader);
}
}
//如果读取的类的注解既不在排除规则中，也不在包含规则中，则返回false
returnfalse;
}2.4 注册注解BeanDefinition
AnnotationConfigWebApplicationContext是AnnotationConfigApplicationContext的Web版， 它们对于注解Bean的注册和扫描是基本相同的，但是AnnotationConfigWebApplicationContext对注解Bean定义的载入稍有不同，AnnotationConfigWebApplicationContext 注入注解Bean定义源码：
//载入注解Bean定义资源
@Override
protectedvoidloadBeanDefinitions(DefaultListableBeanFactory beanFactory){
//为容器设置注解Bean定义读取器
AnnotatedBeanDefinitionReader reader =getAnnotatedBeanDefinitionReader(beanFactory);
//为容器设置类路径Bean定义扫描器
ClassPathBeanDefinitionScanner scanner =getClassPathBeanDefinitionScanner(beanFactory);
//获取容器的Bean名称生成器
BeanNameGenerator beanNameGenerator =getBeanNameGenerator();
//为注解Bean定义读取器和类路径扫描器设置Bean名称生成器
if(beanNameGenerator !=null){
reader.setBeanNameGenerator(beanNameGenerator);
scanner.setBeanNameGenerator(beanNameGenerator);
beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
}
//获取容器的作用域元信息解析器
ScopeMetadataResolver scopeMetadataResolver =getScopeMetadataResolver();
//为注解Bean定义读取器和类路径扫描器设置作用域元信息解析器
if(scopeMetadataResolver !=null){
reader.setScopeMetadataResolver(scopeMetadataResolver);
scanner.setScopeMetadataResolver(scopeMetadataResolver);
}
if(!this.componentClasses.isEmpty()){
if(logger.isDebugEnabled()){
logger.debug("Registering component classes: ["+
StringUtils.collectionToCommaDelimitedString(this.componentClasses)+"]");
}
reader.register(ClassUtils.toClassArray(this.componentClasses));
}
if(!this.basePackages.isEmpty()){
if(logger.isDebugEnabled()){
logger.debug("Scanning base packages: ["+
StringUtils.collectionToCommaDelimitedString(this.basePackages)+"]");
}
scanner.scan(StringUtils.toStringArray(this.basePackages));
}
//获取容器定义的Bean定义资源路径
String[] configLocations =getConfigLocations();
//如果定义的Bean定义资源路径不为空
if(configLocations !=null){
for(String configLocation : configLocations){
try{
//使用当前容器的类加载器加载定位路径的字节码文件
Class<?> clazz =ClassUtils.forName(configLocation,getClassLoader());
if(logger.isTraceEnabled()){
logger.trace("Registering ["+ configLocation +"]");
}
reader.register(clazz);
}
catch(ClassNotFoundException ex){
if(logger.isTraceEnabled()){
logger.trace("Could not load class for config location ["+ configLocation +
"] - trying package scan. "+ ex);
}
//如果容器类加载器加载定义路径的Bean定义资源失败，则
//启用容器类路径扫描器扫描给定路径包及其子包中的类
int count = scanner.scan(configLocation);
if(count ==0&& logger.isDebugEnabled()){
logger.debug("No component classes found for specified class/package ["+ configLocation +"]");
}
}
}
}
}以上就是解析和注入注解配置资源的全过程分析。
扫一扫
5713
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
