SpringMVC 源代码深度解析 IOC容器（Bean实例化和依赖注入）
SpringMVC最核心的IOC的控制反转，动态的向某个对象提供它所需要的其他对象，例如：对象A时，需要对象B时，这时不像以前我们之前要在A对象里实例化B对象，这时B对象的实例化由IOC容器会主动创建一个对象B然后注入到对象A里，提供使用。我们项目开发中，最经常用到，那怎么实现实例Bean并依赖注入呢？我们今天带着这些问题来通过SpringMVC源代码进行深入的解析。这篇介绍不对注解实例化和注入进
·
SpringMVC最核心的IOC的控制反转，动态的向某个对象提供它所需要的其他对象，例如：对象A时，需要对象B时，这时不像以前我们之前要在A对象里实例化B对象，这时B对象的实例化由IOC容器会主动创建一个对象B然后注入到对象A里，提供使用。我们项目开发中，最经常用到，那怎么实现实例Bean并依赖注入呢？我们今天带着这些问题来通过SpringMVC源代码进行深入的解析。这篇介绍不对注解实例化和注入进行讲解，这个放在后面在介绍。
我们平常写的一个类，并依赖调用了类的某个方法，这时需要依赖那个类已经实例化，这样才能调用，这些都是交给IOC控制反转，这是我们写的一个类，代码如下
package cn.test.service.impl;
import cn.test.service.TestService2;
public class TestServiceImpl2 implements TestService2{
}
package cn.test.service.impl;
import cn.test.service.TestService;
import cn.test.service.TestService2;
public class TestServiceImpl implements TestService{
private TestServiceImpl(){
System.out.println("xx");
}
private TestService2 testService2;
public TestService2 getTestService2() {
return testService2;
}
public void setTestService2(TestService2 testService2) {
this.testService2 = testService2;
}
}在配置文件配置了对应的Bean
<span style="font-size:18px;"> <bean id="testService" class="cn.test.service.impl.TestServiceImpl" >
<property name="testService2" ref="testService2"></property>
</bean>
<bean id="testService2" class="cn.test.service.impl.TestServiceImpl2" ></bean></span>首先我们先回到refresh这个方法，在上一篇Bean解析和注册，大家应该还记得吧，里面有postProcessBeanFactory这个方法，就是实例化bean的，我们带着好奇心来分析了解。当Bean定义资源被载入IoC容器之后，容器将Bean定义资源解析为容器内部的数据结构，然后BeanDefinition注册到容器中，AbstractApplicationContext类中的finishBeanFactoryInitialization方法对配置了属性的Bean进行初始化过程，源码如下：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// CONVERSION_SERVICE_BEAN_NAME为转换服务(ConversionService)
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// 对bean进行实例化
<span style="color:#ff0000;">beanFactory.preInstantiateSingletons();</span>
}
preInstantiateSingletons由对bean进行实例化由子类DefaultListableBeanFactory来实现的。源代码：
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isInfoEnabled()) {
this.logger.info("Pre-instantiating singletons in " + this);
}
List<String> beanNames;
synchronized (this.beanDefinitionMap) {
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
beanNames = new ArrayList<String>(this.beanDefinitionNames);
}
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
<span style="color:#cc0000;">getBean(beanName);</span>
}
}
}
}getBean(beanName);对bean进行实例化并对属性依赖进行注入过程。前面解析的代码不重要，主要是入口点，接下来才是重点， 创建bean时，如果缓存中有单例Bean时，就从缓存获取，如果没有就新建，通过匿名的内部类来创建Bean时根据Bean的作用域来创建的，有单实例作用域、原型作用域、Request等。源代码如下：
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//如果指定的是别名，将别名转换为规范的Bean名称
final String beanName = transformedBeanName(name);
Object 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 + "'");
}
}
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);
}
// 获取父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
//检查BeanDefinition是否有当前的BeanFactory，如果没有，就到父工厂去查找
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 {
//看说明（2）
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//是否为抽象的、是否Prototype
checkMergedBeanDefinition(mbd, beanName, args);
// 获取当前Bean所有依赖Bean的名称
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
//递归调用getBean方法
getBean(dependsOnBean);
//注册依赖的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) {
// 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实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//是否为原型bean 每次我们从容器中调用bean时，都返回一个新的实例
else if (mbd.isPrototype()) {
// 原型bean都会创建一个新的出来
Object prototypeInstance = null;
try {
//注册新bean
beforePrototypeCreation(beanName);
//创建新的bean实例对象
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
//获取bean对象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//创建Bean作用域类型 request、session、globalSession,通过Scope接口定义新的作用域
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
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 = 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.
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;
}我们解析到这边，对前面的思路在整理一下，这样我们到后面就比较不会那么模糊
总结：（1）先List<String> beanDefinitionNames获取BeanName，然后通过BeanName 获取Map<String, RootBeanDefinition> RootBeanDefinition，然后判断是否 为单例、不是抽象、是为Lazy-init=false 然后调用getBean方法。我们在配置中可以定义父Bean和子bean，父Bean用RootBeanDefinition 表示，子Bean 用ChildBeanDefinition表示，而没有父Bean用RootBeanDefinition 表示。如图所示：
（2）如果BeanName是别名，先转换为原来的BeanName不是别名，然后如果缓存中有单例Bean时，就从缓存获取，如果没有的话，就创建一个
（3）先检查是否父工厂存在，如果有的话，获取父工厂
（4）判断Bean依赖对象所有的名称，如果有的话，获取依赖对象的名称，然后循环getBean（）；
（5）检查Bean的作用域，Scope 作用域、原型作用域、Request等，来实例化Bean ,是由FactoryBean是创建创建对象的工厂Bean，通过调用这个对象 的 getObject 方法就能获取用户自定义产生的对象，从而为 Spring 提供了很好的扩展性。Spring 获取 FactoryBean 本身的对象是在前面加上 & 来完成 的。
现在思路就比较清晰了，接下来我们来解析具体实现创建Bean实例化的类。
接下来我们来继续分析具体的创建过程createBean(beanName, mbd, args);这个方法，是由AbstractAutowireCapableBeanFactory来实现的，AbstractAutowireCapableBeanFactory我们来看看它的继承关系，之前就有总体的继承关系，我们这边在温习一下，如图所示：
createBean(beanName, mbd, args);这个方法，源代码如下：
@Override
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// Make sure bean class is actually resolved at this point.
resolveBeanClass(mbd, beanName);
// Prepare method overrides.
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
Object beanInstance = <span style="color:#cc0000;">doCreateBean(beanName, mbd, args);</span>
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}我们这里来看最主要的创建bean实例对象的方法doCreateBean();
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
// 封装bean对象
BeanWrapper instanceWrapper = null;
//是否为单实例
if (mbd.isSingleton()) {
//根据beanName从容器中获取
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建
instanceWrapper = <span style="color:#ff0000;">createBeanInstance(beanName, mbd, args);</span>
}
//获取bean的实例化
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
//bean的类型
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;
}
}
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对象，以防循环实例化
addSingletonFactory(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//设置bean实例的属性,如果属性需要注入的bean实例，则把bean实例对象封装好依赖注入
<span style="color:#ff0000;">populateBean(beanName, mbd, instanceWrapper);</span>
if (exposedObject != null) {
//初始化bean
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) {
//获取实例化好的单态实例的bean
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
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);
}
}
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 {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
我们对这个方法在总结一下：
（1）封装Bean，用 BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器，由于BeanWrapper接口是PropertyAccessor的子接口，因此其也可以设置以及访问被包装对象的属性值。BeanWrapper大部分情况下是在IOC内部进行使用，通过BeanWrapper,IOC容器可以用统一的方式来访问Bean的属性。上一篇转载的有介绍BeanWrapper,这里就不具体介绍了。
（2）根据BeanName去容器缓存中获取已经Bean的包装好的BeanWrapper，如果没有就调用createBeanInstance(beanName, mbd, args)，实例化Bean
（3）获取Bean的类型，这个类型是什么，如图所示：
(4)获取BeanWrapper里已经实例好的Bean，然后放到缓存，这样下次已经有了，就不用在创建。
（5）设置Bean实例的属性,对需要转换的属性进行转换，例如数组等，如果属性是引用类型，如果引用Bean没实例化，要在实例化，把bean实例对象封装好依赖注入在注入进来。
这里面有两个重要的实现方法createBeanInstance(beanName, mbd, args);和populateBean(beanName, mbd, instanceWrapper);createBeanInstance是创建bean实例的，populateBean设置属性的，如果属性的是对象，需要把依赖的对象创建好，设置实例化对象。这两个方法也是重点。
第一个：我们来分析createBeanInstance的方法,这里有介绍了注解的实例化，我们后面章节在介绍。可以带有参数构造函数或者默认无参的构造函数、还有工厂方法来创建Bean的实例，源代码如下：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// 确实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());
}
if (mbd.getFactoryMethodName() != null) {
// //使用工厂方法实例化bean
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 {
//实例化bean
return <span style="color:#990000;">instantiateBean(beanName, mbd)</span>;
}
}
// Need to determine the constructor...
、、
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.
return instantiateBean(beanName, mbd);
}instantiateBean默认是实例化无参的构造函数的。
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
beanInstance = <span style="color:#cc0000;">getInstantiationStrategy().instantiate(mbd, beanName, parent);</span>
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
getInstantiationStrategy().instantiate(mbd, beanName, parent);是由InstantiationStrategy的子类SimpleInstantiationStrategy来实现的，关系如图所示：
为了方便我们采用不同的实例化策略，以满足不同应用的需求，可以用CGLib类库来动态的创建Bean实例或者JDK反射机制来实现的，在子类中生成方法注入的逻辑，然后使用这个动态生成的子类创建bean的实例，这个实例化过程是没有对bean进行设置属性的，是有BeanWrapper 来设置的。具体由instantiate实现的，这里面说明了，如果方法有被覆盖，用JDK反射机制来实例化，否则用CGLib类库来动态的创建Bean实例，这里用beanDefinition.resolvedConstructorOrFactoryMethod来判断的。源代码如下：
public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
if (beanDefinition.getMethodOverrides().isEmpty()) {
Constructor<?> constructorToUse;
synchronized (beanDefinition.constructorArgumentLock) {
constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = beanDefinition.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
//用java反射机制来实例化bean
if (System.getSecurityManager() != null) {
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);
}
}
}
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
//用CGLIB 来动态创建bean
return instantiateWithMethodInjection(beanDefinition, beanName, owner);
}
}
SimpleInstantiationStrategy，如果方法有被覆盖，用JDK反射机制来实例化，否则用CGLib类库来动态的创建Bean实例。这里CGLib类继承，如图所示：
这里我们来验证一下如果方法有被覆盖，用JDK反射机制来实例化，否则用CGLib类库来动态的创建Bean实例，还记得我们最开始的TestServiceImpl这个类，并在配置文件配置了Bean，在实例化肯定是使用了，JDK反射机制来实例化，因为它类还有依赖了TestServiceImpl2这个类，我们跟踪代码证实一下：
我们这边有写了一个无参的构造函数，并且有实例化，然后我们继续跟踪是采用什么实例化，如图所示：
经过我们验证是正确的。
第二个：实例化就讲到这里，接下去我们继续解析Bean属性的注入。
实现的方法是populateBean这个方法，应该还记得吧。doCreateBean();方法里面的。
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
<span style="color:#cc0000;">PropertyValues pvs = mbd.getPropertyValues();
</span>
if (bw == null) {
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
///使用BeanPostProcessor处理器处理属性值
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
//对属性的注入
<span style="color:#ff0000;">applyPropertyValues(beanName, mbd, bw, pvs);</span>
}
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs == null || pvs.isEmpty()) {
return;
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (System.getSecurityManager() != null) {
if (bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
}
//对属性进行循环
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
}
else {
//获取了<property name="testService2" ref="testService2"></property>里面的ref值或者value
original = Arrays.asList(pvs.getPropertyValues());
}
//获取用户自定义的类型转换
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
//实现了一个BeanDefinition的解析实例
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
//对属性值进行复制
List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
//是否要转换
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
//获取名称
String propertyName = pv.getName();
//获取值
Object originalValue = pv.getValue();
//对属性对应的值进行转换对应的类型
Object resolvedValue = <span style="color:#990000;">valueResolver.resolveValueIfNecessary(pv, originalValue);</span>
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
（1）对属性进行循环，然后获取属性值
（2）获取用户自定义的类型转换
（3）实现了一个BeanDefinition的解析实例的BeanDefinitionValueResolver，我们来看一个这个类的属性，有保存用户自定义的转换类型、还有保存BeanDefinition
（4）对属性值进行复制，如图所示：
（5）在（3）实例化了一个BeanDefinition解析实例的BeanDefinitionValueResolver对象，通过这个对象调用对具体实现了解析属性值进行解析，并对属性值进行转换。转换类型有对象引用、对集合数组类型的属性解析等。如果对引用对象进行解析时，调用了getBean（）方法。
接下来我们来解析属性的具体解析，是由BeanDefinitionValueResolver类实现的,具体实现了解析属性值进行解析，并对属性值进行转换。
resolveValueIfNecessary方法源代码如下：
ublic Object resolveValueIfNecessary(Object argName, Object value) {
// 对引用的类型进行转换
// to another bean to be resolved.
if (value instanceof RuntimeBeanReference) {
RuntimeBeanReference ref = (RuntimeBeanReference) value;
return resolveReference(argName, ref);
}
else if (value instanceof RuntimeBeanNameReference) {
String refName = ((RuntimeBeanNameReference) value).getBeanName();
refName = String.valueOf(evaluate(refName));
if (!this.beanFactory.containsBean(refName)) {
throw new BeanDefinitionStoreException(
"Invalid bean name '" + refName + "' in bean reference for " + argName);
}
return refName;
}
else if (value instanceof BeanDefinitionHolder) {
// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
}
else if (value instanceof BeanDefinition) {
// Resolve plain BeanDefinition, without contained name: use dummy name.
BeanDefinition bd = (BeanDefinition) value;
return resolveInnerBean(argName, "(inner bean)", bd);
}
//对集合数组类型的属性解析
else if (value instanceof ManagedArray) {
// May need to resolve contained runtime references.
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.
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error resolving array type for " + argName, ex);
}
}
else {
elementType = Object.class;
}
}
return resolveManagedArray(argName, (List<?>) value, elementType);
}
else if (value instanceof ManagedList) {
// May need to resolve contained runtime references.
return resolveManagedList(argName, (List<?>) value);
}
else if (value instanceof ManagedSet) {
// May need to resolve contained runtime references.
return resolveManagedSet(argName, (Set<?>) value);
}
else if (value instanceof ManagedMap) {
// May need to resolve contained runtime references.
return resolveManagedMap(argName, (Map<?, ?>) value);
}
else if (value instanceof ManagedProperties) {
Properties original = (Properties) value;
Properties copy = new Properties();
for (Map.Entry propEntry : original.entrySet()) {
Object propKey = propEntry.getKey();
Object propValue = propEntry.getValue();
if (propKey instanceof TypedStringValue) {
propKey = evaluate((TypedStringValue) propKey);
}
if (propValue instanceof TypedStringValue) {
propValue = evaluate((TypedStringValue) propValue);
}
copy.put(propKey, propValue);
}
return copy;
}
else if (value instanceof TypedStringValue) {
// Convert value to target type here.
TypedStringValue typedStringValue = (TypedStringValue) value;
Object valueObject = evaluate(typedStringValue);
try {
Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
if (resolvedTargetType != null) {
return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
}
else {
return valueObject;
}
}
catch (Throwable ex) {
// Improve the message by showing the context.
throw new BeanCreationException(
this.beanDefinition.getResourceDescription(), this.beanName,
"Error converting typed String value for " + argName, ex);
}
}
else {
return evaluate(value);
}
} 这里我们来验证一下我们解析是否正确，还记得我们最开始的TestServiceImpl这个类，并在配置文件配置了Bean，它类还有依赖了TestServiceImpl2这个类，在配置文件
<bean id="testService" class="cn.test.service.impl.TestServiceImpl" > <property name="testService2" ref="testService2"></property></bean>，在属性注入时，类型转换肯定是引用类型。我们来跟踪一下代码，如图所示：
是走引用类型路线，这时会调用genBean（），进行对引用类进行实例化，这都是交给IOC容器实现的，如图所示：
这时已经实例化好了，接下来就是注入进来，如图所示：
我们对Bean的实例化和属性解析并进行类型转换，例如依赖注入。
我们这里总结整个思路：
（1）先List<String> beanDefinitionNames获取BeanName，然后通过BeanName 获取Map<String, RootBeanDefinition> RootBeanDefinition，然后判断是否为单例、不是抽象、是为Lazy-init=false 然后调用getBean方法。
（2）如果BeanName是别名，先转换为原来的BeanName不是别名，然后如果缓存中有单例Bean时，就从缓存获取，如果没有的话，就创建一个
（3）先检查是否父工厂存在，如果有的话，获取父工厂
（4）判断Bean依赖对象所有的名称，如果有的话，获取依赖对象的名称，然后循环getBean（）；
（5）检查Bean的作用域，Scope 作用域、原型作用域、Request等，来实例化Bean ,是由FactoryBean是创建创建对象的工厂Bean，通过调用这个对象的 getObject 方法就能获取用户自定义产生的对象，从而为 Spring 提供了很好的扩展性。Spring 获取 FactoryBean 本身的对象是在前面加上 & 来完成的。
（6）封装Bean，用 BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器，由于BeanWrapper接口是PropertyAccessor的子接口，因此其也可以设置以及访问被包装对象的属性值。BeanWrapper大部分情况下是在IOC内部进行使用，通过BeanWrapper,IOC容器可以用统一的方式来访问Bean的属性。
（7）根据BeanName去容器缓存中获取已经Bean的包装好的BeanWrapper，如果没有就调用createBeanInstance(beanName, mbd, args)，实例化Bean
(8)获取BeanWrapper里已经实例好的Bean，然后放到缓存，这样下次已经有了，就不用在创建。
（9）设置Bean实例的属性,对需要转换的属性进行转换，例如数组等，如果属性是引用类型，如果引用Bean没实例化，要在实例化，把bean实例对象封装好依赖注入在注入进来。
我这边介绍的主要是配置文件的xml中的配置bean。对注解的@Autowire,@Service@Controller等怎么实例化，和依赖注入等怎么使用，我们在SpringMVC中大部分都是用注解来开发，方便我们使用。我们带着这些问题，下一篇继续解析。
权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区
更多推荐
6
0- 0
已为社区贡献3条内容
所有评论(0)