spring - DI

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：

依赖注入发生的时间

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

  • 用户第一次通过 getBean 方法向 IOC 容索要 Bean 时，IOC 容器触发依赖注入。
  • 当用户在 Bean 定义资源中为<Bean>元素配置了 lazy-init 属性, 默认是false，即让容器在解析注册 Bean 定义时进行预实例化，触发依赖注入。
    BeanFactory 接口定义了 Spring IOC 容器的基本功能规范，是 Spring IOC 容器所应遵守的最底层和
    最基本的编程规范。BeanFactory 接口中定义了几个 getBean 方法，就是用户向 IOC 容器索取管理的 Bean
    的方法，我们通过分析其子类的具体实现，理解 Spring IOC 容器在用户索取 Bean 时如何完成依赖注
    入。

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

AbstractBeanFactory 通过 getBean 向 IOC 容器获取被管理的 Bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 //获取 IOC 容器中指定名称的 Bean
 public Object getBean(String name) throws BeansException {
     //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
     return doGetBean(name, null, null, false);
 }
 //获取 IOC 容器中指定名称和类型的 Bean
 public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
     //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
     return doGetBean(name, requiredType, null, false);
 }
 //获取 IOC 容器中指定名称和参数的 Bean
 public Object getBean(String name, Object... args) throws BeansException {
     //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
     return doGetBean(name, null, args, false);
 }
 //获取 IOC 容器中指定名称、类型和参数的 Bean
 public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
     //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
     return doGetBean(name, requiredType, args, false);
 }
 //真正实现向 IOC 容器获取 Bean 的功能，也是触发依赖注入功能的地方
 @SuppressWarnings("unchecked")
 protected <T> T doGetBean(
         final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
         throws BeansException {
     //根据指定的名称获取被管理 Bean 的名称，剥离指定名称中对容器的相关依赖
     //如果指定的是别名，将别名转换为规范的 Bean 名称
     final String beanName = transformedBeanName(name);
     Object bean;
     //先从缓存中取是否已经有被创建过的单态类型的 Bean
     //对于单例模式的 Bean 整个 IOC 容器中只创建一次，不需要重复创建
     Object sharedInstance = getSingleton(beanName);
     //IOC 容器创建单例模式 Bean 实例对象
     if (sharedInstance != null && args == null) {
         if (logger.isDebugEnabled()) {
             //如果指定名称的 Bean 在容器中已有单例模式的 Bean 被创建
             //直接返回已经创建的 Bean
             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 的实例对象，主要是完成 FactoryBean 的相关处理
         //注意：BeanFactory 是管理容器中 Bean 的工厂，而 FactoryBean 是
         //创建创建对象的工厂 Bean，两者之间有区别
         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
     }
     else {
         //缓存没有正在创建的单例模式 Bean
         //缓存中已经有已经创建的原型模式 Bean
         //但是由于循环引用的问题导致实例化对象失败
         if (isPrototypeCurrentlyInCreation(beanName)) {
             throw new BeanCurrentlyInCreationException(beanName);
         }
         //对 IOC 容器中是否存在指定名称的 BeanDefinition 进行检查，首先检查是否
         //能在当前的 BeanFactory 中获取的所需要的 Bean，如果不能则委托当前容器
         //的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找
         // 为什么要委托父容器去找呢？
// ioc容器是可以被关联的：FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent)
         BeanFactory parentBeanFactory = getParentBeanFactory();
         //当前容器的父级容器存在，且当前容器中不存在指定名称的 Bean
         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
             //解析指定 Bean 名称的原始名称
             // 因为有可能是通过别名去获取bean
             String nameToLookup = originalBeanName(name);
             if (args != null) {
                 //委派父级容器根据指定名称和显式的参数查找
                 // 为什么不传类型再去校验一次？
		// 因为这一步是强转成T ， 如果类型不一样, 在后续的调用中会报错ClassCastException
                 return (T) parentBeanFactory.getBean(nameToLookup, args);
             }
             else {
                 //委派父级容器根据指定名称和类型查找
                 return parentBeanFactory.getBean(nameToLookup, requiredType);
             }
         }
         //如果不是只检查类型，那就标记这个Bean被创建了~~添加到缓存里 也就是所谓的  当前创建Bean池
         if (!typeCheckOnly) {
             //向容器标记指定的 Bean 已经被创建
             markBeanAsCreated(beanName);
         }
         //根据指定 Bean 名称获取其父级的 Bean 定义
         //主要解决 Bean 继承时子类合并父类公共属性问题
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);
         //获取当前 Bean 所有依赖 Bean 的名称
         String[] dependsOn = mbd.getDependsOn();
         //如果当前 Bean 有依赖 Bean
         if (dependsOn != null) {
             for (String dependsOnBean : dependsOn) {
                 //递归调用 getBean 方法，获取当前 Bean 的依赖 Bean
                 getBean(dependsOnBean);
                 //把被依赖 Bean 注册给当前依赖的 Bean
                 registerDependentBean(dependsOnBean, beanName);
             }
         }
         //创建单例模式 Bean 的实例对象
         if (mbd.isSingleton()) {
             //这里使用了一个匿名内部类，创建 Bean 实例对象，并且注册给所依赖的对象
             sharedInstance = getSingleton(beanName, new ObjectFactory() {
                 public Object getObject() throws BeansException {
                     try {
                         //创建一个指定 Bean 实例对象，如果有父级继承，则合并子类和父类的定义
                         return createBean(beanName, mbd, args);
                     }
                     catch (BeansException ex) {
                         //显式地从容器单例模式 Bean 缓存中清除实例对象
                         destroySingleton(beanName);
                         throw ex;
                     }
                 }
             });
             //获取给定 Bean 的实例对象
             bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }
         //IOC 容器创建原型模式 Bean 实例对象
         else if (mbd.isPrototype()) {
             //原型模式(Prototype)是每次都会创建一个新的对象
             Object prototypeInstance = null;
             try {
                 //回调 beforePrototypeCreation 方法，默认的功能是注册当前创//建的原型对象
                 beforePrototypeCreation(beanName);
                 //创建指定 Bean 对象实例
                 prototypeInstance = createBean(beanName, mbd, args);
             }
             finally {
                 //回调 afterPrototypeCreation 方法，默认的功能告诉 IoC 容器指定 Bean 的原型对象不再创建了
                 //就是该bean已经从ing状态变成了ed状态
                 afterPrototypeCreation(beanName);
             }
             //获取给定 Bean 的实例对象
             bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }
         //要创建的 Bean 既不是单例模式，也不是原型模式，则根据 Bean 定义资源中
         //配置的生命周期范围，选择实例化 Bean 的合适方法，这种在 Web 应用程序中
         //比较常用，如：request、session、application 等生命周期
         else {
             String scopeName = mbd.getScope();
             //其实scopt也是用map去管理的, 这样的很多地方就能理解通了
             //private final Map<String, Scope> scopes = new HashMap<String, Scope>(8);
             final Scope scope = this.scopes.get(scopeName);
             //Bean 定义资源中没有配置生命周期范围，则 Bean 定义不合法
             if (scope == null) {
                 throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
             }
             try {
                 //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例
                 Object scopedInstance = scope.get(beanName, new ObjectFactory() {
                     public Object getObject() throws BeansException {
                         beforePrototypeCreation(beanName);
                         try {
                             return createBean(beanName, mbd, args);
                         }
                         finally {
                             afterPrototypeCreation(beanName);
                         }
                     }
                 });
                 //获取给定 Bean 的实例对象
                 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);
             }
         }
     }
     //对创建的 Bean 实例对象进行类型检查
     if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass()))
     {
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
     }
     return (T) bean;
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

		// Don't let calling code try to dereference the factory if the bean isn't a factory.
		// name 是否是工厂bean标记
		// beanInstance 是否继承factoryBean
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}

		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
		// If it's a FactoryBean, we use it to create a bean instance, unless the
		// caller actually wants a reference to the factory.
		// 1、true || false 普通类 纯的普通类
		// 2、false || true  工厂类 纯的工厂
		// 3、false || false 普通类 没有定义为工厂的普通工厂类
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		if (mbd == null) {
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			// 是否是合成的，意思就是是否当做工具类来使用
			// 这里的synthetic实际上是为了给用户自定义一些BeanDefinition注册到容器中以当作工具类来使用。
			// 什么是synthetic
			// 就是内部类，java在编译的时候内部类也会编译成单独的一个文件，那实际上，原始类及时两个类的合成类
			// 工具类就没有必要做一些封装、代理等工作，实际上是拿来就用，没有其他处理
			// 对于synthetic类型的BeanDefinition，getObjectFromFactoryBean中是不会对FactoryBean生成的bean用post-processor进行后置处理的。
			// 后置处理的实现是在AbstractAutowireCapableBeanFactory.postProcessObjectFromFactoryBean中，
			// 它会调用容器中的BeanPostProcessor.postProcessAfterInitialization,这里提供了一个扩展点对FactoryBean生成的bean进行封装，代理等
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			// bean实例化的缓存
            // private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>(16);
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}
1
2
3
4
5
6
//对 FactoryBean 的转义定义，因为如果使用 bean 的名字检索 FactoryBean 得到的对象是工厂生成的对象，
	//如果需要得到工厂本身，需要转义
	String FACTORY_BEAN_PREFIX = "&";
public static boolean isFactoryDereference(String name) {
		return (name != null && name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
	}
1
2
3
4
5
6
7
private final ThreadLocal<Object> prototypesCurrentlyInCreation =
			new NamedThreadLocal<Object>("Prototype beans currently in creation");
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
		Object curVal = this.prototypesCurrentlyInCreation.get();
		return (curVal != null &&
				(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
protected void beforePrototypeCreation(String beanName) {
		Object curVal = this.prototypesCurrentlyInCreation.get();
		if (curVal == null) {
			this.prototypesCurrentlyInCreation.set(beanName);
		}
		else if (curVal instanceof String) {
			Set<String> beanNameSet = new HashSet<String>(2);
			beanNameSet.add((String) curVal);
			beanNameSet.add(beanName);
			this.prototypesCurrentlyInCreation.set(beanNameSet);
		}
		else {
			Set<String> beanNameSet = (Set<String>) curVal;
			beanNameSet.add(beanName);
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
protected void afterPrototypeCreation(String beanName) {
		Object curVal = this.prototypesCurrentlyInCreation.get();
		if (curVal instanceof String) {
			this.prototypesCurrentlyInCreation.remove();
		}
		else if (curVal instanceof Set) {
			Set<String> beanNameSet = (Set<String>) curVal;
			beanNameSet.remove(beanName);
			if (beanNameSet.isEmpty()) {
				this.prototypesCurrentlyInCreation.remove();
			}
		}
	}

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

上面的源码只是定义了根据 Bean 定义的模式，采取的不同创建 Bean 实例对象的策略，具体的 Bean 实
例对象的创建过程由实现了 ObejctFactory 接口的匿名内部类的 createBean 方法完成，ObejctFactory
使用委派模式，具体的 Bean 实例创建过程交由其实现类 AbstractAutowireCapableBeanFactory 完成，
我们继续分析 AbstractAutowireCapableBeanFactory 的 createBean 方法的源码，理解其创建 Bean 实
例的具体实现过程。

循环依赖的产生和解决的前提

  • A的构造方法中依赖了B的实例对象，同时B的构造方法中依赖了A的实例对象
  • A的构造方法中依赖了B的实例对象，同时B的某个field或者setter需要A的实例对象
  • A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象
    当然，Spring对于循环依赖的解决不是无条件的，首先前提条件是针对scope单例并且没有显式指明不需要解决循环依赖的对象，而且要求该对象没有被代理过。同时Spring解决循环依赖也不是万能，以上三种情况只能解决两种，第一种在构造方法中相互依赖的情况Spring也无力回天。结论先给在这，下面来看看Spring的解决方法，知道了解决方案就能明白为啥第一种情况无法解决了。
    Spring单例对象的初始化其实可以分为三步：
  • createBeanInstance， 实例化，实际上就是调用对应的构造方法构造对象，此时只是调用了构造方法，spring xml中指定的property并没有进行populate
  • populateBean 填充属性，这步对spring xml中指定的property进行populate
  • initializeBean 调用spring xml中指定的init方法，或者AfterPropertiesSet方法会发生循环依赖的步骤集中在第一步和第二步。

三级缓存

对于单例对象来说，在Spring的整个容器的生命周期内，有且只存在一个对象，很容易想到这个对象应该存在Cache中，Spring大量运用了Cache的手段，在循环依赖问题的解决过程中甚至使用了“三级缓存”。
“三级缓存”主要是指

1
2
3
4
5
6
7
8
9
// 完美并且已经在使用的bean
/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
// bean的工厂方法
/** Cache of early singleton objects: bean name --> bean instance */
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
// 新创建或不完美的bean
/** Cache of singleton factories: bean name --> ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

从字面意思来说：singletonObjects指单例对象的cache，singletonFactories指单例对象工厂的cache，earlySingletonObjects指提前曝光的单例对象的cache。以上三个cache构成了三级缓存，Spring就用这三级缓存巧妙的解决了循环依赖问题。
首先Spring会尝试从缓存中获取，这个缓存就是指singletonObjects，主要调用的方法是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return (singletonObject != NULL_OBJECT ? singletonObject : null);}

首先解释两个参数：

  • isSingletonCurrentlyInCreation 判断对应的单例对象是否在创建中，当单例对象没有被初始化完全(例如A定义的构造函数依赖了B对象，得先去创建B对象，或者在populatebean过程中依赖了B对象，得先去创建B对象，此时A处于创建中)
  • allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象，其实就是是否允许我重新创建一个

分析getSingleton的整个过程，Spring首先从singletonObjects（一级缓存）中尝试获取，如果获取不到并且对象在创建中，则尝试从earlySingletonObjects(二级缓存)中获取，如果还是获取不到并且允许从singletonFactories通过getObject获取，则通过singletonFactory.getObject()(三级缓存)获取。如果获取到了则

1
2
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);

Spring解决循环依赖的诀窍就在于singletonFactories这个cache，这个cache中存的是类型为ObjectFactory，其定义如下：

1
2
public interface ObjectFactory<T> {
    T getObject() throws BeansException;}

在bean创建过程中，有两处比较重要的匿名内部类实现了该接口。一处是

1
2
3
4
5
6
7
8
new ObjectFactory<Object>() {
   @Override   public Object getObject() throws BeansException {
      try {
         return createBean(beanName, mbd, args);
      }      catch (BeansException ex) {
         destroySingleton(beanName);
         throw ex;
      }   }

另一处就是:

1
2
3
4
addSingletonFactory(beanName, new ObjectFactory<Object>() {
   @Override   public Object getObject() throws BeansException {
      return getEarlyBeanReference(beanName, mbd, bean);
   }});

此处就是解决循环依赖的关键，这段代码发生在createBeanInstance之后，也就是说单例对象此时已经被创建出来的。这个对象已经被生产出来了，虽然还不完美（还没有进行初始化的第二步和第三步），但是已经能被人认出来了（根据对象引用能定位到堆中的对象），所以Spring此时将这个对象提前曝光出来让大家认识，让大家使用。

这样做有什么好处呢？让我们来分析一下“A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情况。A首先完成了初始化的第一步，并且将自己提前曝光到singletonFactories中，此时进行初始化的第二步，发现自己依赖对象B，此时就尝试去get(B)，发现B还没有被create，所以走create流程，B在初始化第一步的时候发现自己依赖了对象A，于是尝试get(A)，尝试一级缓存singletonObjects(肯定没有，因为A还没初始化完全)，尝试二级缓存earlySingletonObjects（也没有），尝试三级缓存singletonFactories，由于A通过ObjectFactory将自己提前曝光了，所以B能够通过ObjectFactory.getObject拿到A对象(虽然A还没有初始化完全，但是总比没有好呀)，B拿到A对象后顺利完成了初始化阶段1、2、3，完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中，A此时能拿到B的对象顺利完成自己的初始化阶段2、3，最终A也完成了初始化，长大成人，进去了一级缓存singletonObjects中，而且更加幸运的是，由于B拿到了A的对象引用，所以B现在hold住的A对象也蜕变完美了！

知道了这个原理时候，肯定就知道为啥Spring不能解决“A的构造方法中依赖了B的实例对象，同时B的构造方法中依赖了A的实例对象”这类问题了！

AbstractAutowireCapableBeanFactory 创建 Bean 实例对象

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
  //创建 Bean 实例对象
  protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[]
          args)
          throws BeanCreationException {
      if (logger.isDebugEnabled()) {
          logger.debug("Creating instance of bean '" + beanName + "'");
      }
      //判断需要创建的 Bean 是否可以实例化，即是否可以通过当前的类加载器加载
      resolveBeanClass(mbd, beanName);
      //校验和准备 Bean 中的方法覆盖
//除了原型模式，其他的bean基本上都会使用代理去创建
//默认使用cglib创建代理，好处就是spring有了代理类的控制权，同时也兼容接口代理
      try {
          mbd.prepareMethodOverrides();
      }
      catch (BeanDefinitionValidationException ex) {
          throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
                  beanName, "Validation of method overrides failed", ex);
      }
      try {
          //如果 Bean 配置了初始化前和初始化后的处理器，则试图返回一个需要创建 Bean 的代理对象
          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);
      }
      //创建 Bean 的入口
      Object beanInstance = doCreateBean(beanName, mbd, args);
      if (logger.isDebugEnabled()) {
          logger.debug("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
  }
  //真正创建 Bean 的方法
  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[]
          args) {
      //封装被创建的 Bean 对象
      BeanWrapper instanceWrapper = null;
      if (mbd.isSingleton()){
          //单例模式的 Bean，先从容器中缓存中获取同名 Bean
          instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
      }
      if (instanceWrapper == null) {
          //创建实例对象
	//生成 Bean 所包含的 java 对象实例
          instanceWrapper = createBeanInstance(beanName, mbd, args);
      }
      final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
      //获取实例化对象的类型
      Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
      //调用 PostProcessor 后置处理器
//就是类似aware监听器一样，监听对象什么时候初始化成功
      synchronized (mbd.postProcessingLock) {
          if (!mbd.postProcessed) {
              applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
              mbd.postProcessed = true;
          }
      }
      // Eagerly cache singletons to be able to resolve circular references
      //向容器中缓存单例模式的 Bean 对象，以防循环引用
      boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
              isSingletonCurrentlyInCreation(beanName));
      //earlySingletonExposure：如果你的bean允许被早期暴露出去 也就是说可以被循环引用  那这里就会进行检查
      if (earlySingletonExposure) {
          if (logger.isDebugEnabled()) {
              logger.debug("Eagerly caching bean '" + beanName +
                      "' to allow for resolving potential circular references");
          }
          //这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用
          addSingletonFactory(beanName, new ObjectFactory() {
              public Object getObject() throws BeansException {
                  return getEarlyBeanReference(beanName, mbd, bean);
              }
          });
      }
      //Bean 对象的初始化，依赖注入在此触发
      //这个 exposedObject 在初始化完成之后返回作为依赖注入完成后的 Bean
      Object exposedObject = bean;
      try {
          //将 Bean 实例对象封装，并且 Bean 定义中配置的属性值赋值给实例对象
	//对 Bean 属性的依赖注入进行处理。
          populateBean(beanName, mbd, instanceWrapper);
          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);
          }
      }
      //此时一级缓存肯定还没数据，但是呢此时候二级缓存earlySingletonObjects也没数据
      if (earlySingletonExposure) {
          //获取指定名称的已注册的单例模式 Bean 对象
          //此时一级缓存肯定还没数据，但是呢此时候二级缓存earlySingletonObjects也没数据
          //第二参数为false  表示不会再去三级缓存里查了~~~
          Object earlySingletonReference = getSingleton(beanName, false);
          if (earlySingletonReference != null) {
              //根据名称获取的已注册的 Bean 和正在实例化的 Bean 是同一个
              if (exposedObject == bean) {
                  //当前实例化的 Bean 初始化完成
                  exposedObject = earlySingletonReference;
              }
              //当前 Bean 依赖其他 Bean，并且当发生循环引用时不允许新创建实例对象
              // allowRawInjectionDespiteWrapping这个值默认是false
		// hasDependentBean：若它有依赖的bean 那就需要继续校验了~~~(若没有依赖的 就放过它~)
              else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                  String[] dependentBeans = getDependentBeans(beanName);
                  Set<String> actualDependentBeans = new
                          LinkedHashSet<String>(dependentBeans.length);
                  //获取当前 Bean 所依赖的其他 Bean
                  // 一个个检查它所以Bean
			// removeSingletonIfCreatedForTypeCheckOnly这个放见下面  在AbstractBeanFactory里面
			// 简单的说，它如果判断到该dependentBean并没有在创建中的了的情况下,那就把它从所有缓存中移除~~~  并且返回true
			// 否则（比如确实在创建中） 那就返回false 进入我们的if里面~  表示所谓的真正依赖
			//（解释：就是真的需要依赖它先实例化，才能实例化自己的依赖）
                  for (String dependentBean : dependentBeans) {
                      //对依赖 Bean 进行类型检查
                      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.");
                  }
              }
          }
      }
      //注册完成依赖注入的 Bean
      try {
          registerDisposableBeanIfNecessary(beanName, bean, mbd);
      }
      catch (BeanDefinitionValidationException ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid
                  destruction signature", ex);
      }
      return exposedObject;
  }

1
2
3
4
5
6
7
8
9
10
11
12
/ 虽然是remove方法 但是它的返回值也非常重要
// 该方法唯一调用的地方就是循环依赖的最后检查处
protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) {
        // 如果这个bean不在创建中  比如是ForTypeCheckOnly的  那就移除掉
		if (!this.alreadyCreated.containsKey(beanName)) {
			removeSingleton(beanName);
			return true;
		}
		else {
			return false;
		}
	}

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

  • createBeanInstance：生成 Bean 所包含的 java 对象实例
  • populateBean ：对 Bean 属性的依赖注入进行处理。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//创建 Bean 的实例对象
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args)
{
    //检查确认 Bean 是可实例化的
    Class beanClass = resolveBeanClass(mbd, beanName);
    //使用工厂方法对 Bean 进行实例化
    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) {
        //调用工厂方法实例化
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    //使用容器的自动装配方法进行实例化
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            //配置了自动装配属性，使用容器的自动装配实例化
            //容器的自动装配是根据参数类型匹配 Bean 的构造方法
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            //使用默认的无参构造方法实例化
            return instantiateBean(beanName, mbd);
        }
    }
    //使用 Bean 的构造方法进行实例化
    Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null ||
            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        //使用容器的自动装配特性，调用匹配的构造方法实例化
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    //使用默认的无参构造方法实例化
    return instantiateBean(beanName, mbd);
}
//使用默认的无参构造方法实例化 Bean 对象
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    try {
        Object beanInstance;
        final BeanFactory parent = this;
        //获取系统的安全管理接口，JDK 标准的安全管理 API
        if (System.getSecurityManager() != null) {
            //这里是一个匿名内置类，根据实例化策略创建实例对象
            beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                }
            }, getAccessControlContext());
        }
        else {
            //将实例化的对象封装起来
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
        }
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        initBeanWrapper(bw);
        return bw;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of
                bean failed", ex);
    }
}

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
  //使用初始化策略实例化 Bean 对象
  public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner)
  {
      //如果 Bean 定义中没有方法覆盖，则就不需要 CGLIB 
//那么是什么条件才会触发这个MethodOverrides呢？
//其实是Spring配置文件中的lookup-method和replace-method，
//这其实是两个方法级别的注入，和一般的属性(Property)注入是不一样的，
//它们注入的是方法(Method)。
//两者的差别是这样的
//如果需要替换的方法没有返回值，那么只能使用replace-method来替换，而不能用lookup-method来替换。
//replace-method必须实现MethodReplacer接口的Bean才能替换，而lookup-method则由BeanFactory自动为我们处理了。，
      if (beanDefinition.getMethodOverrides().isEmpty()) {
          Constructor<?> constructorToUse;
          synchronized (beanDefinition.constructorArgumentLock) {
              //获取对象的构造方法或工厂方法
              constructorToUse = (Constructor<?>)
                      beanDefinition.resolvedConstructorOrFactoryMethod;
              //如果没有构造方法且没有工厂方法
              if (constructorToUse == null) {
                  //使用 JDK 的反射机制，判断要实例化的 Bean 是否是接口
                  final Class clazz = beanDefinition.getBeanClass();
                  if (clazz.isInterface()) {
                      throw new BeanInstantiationException(clazz, "Specified class is an interface");
                  }
                  try {
                      if (System.getSecurityManager() != null) {
                          //这里是一个匿名内置类，使用反射机制获取 Bean 的构造方法
                          constructorToUse = AccessController.doPrivileged(new
                                                                                   PrivilegedExceptionAction<Constructor>() {
                                                                                       public Constructor run() throws Exception {
                                                                                           return clazz.getDeclaredConstructor((Class[]) null);
                                                                                       }
                                                                                   });
                      }
                      else {
                          constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
                      }
                      beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
                  }
                  catch (Exception ex) {
                      throw new BeanInstantiationException(clazz, "No default constructor found",
                              ex);
                  }
              }
          }
          //使用 BeanUtils 实例化，通过反射机制调用”构造方法.newInstance(arg)”来进行实例化
          return BeanUtils.instantiateClass(constructorToUse);
      }
      else {
          //使用 CGLIB 来实例化对象
          return instantiateWithMethodInjection(beanDefinition, beanName, owner);
      }
  }

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//使用 CGLIB 进行 Bean 对象实例化
public Object instantiate(Constructor ctor, Object[] args) {
    //CGLIB 中的类
    Enhancer enhancer = new Enhancer();
    //将 Bean 本身作为其基类
    enhancer.setSuperclass(this.beanDefinition.getBeanClass());
    enhancer.setCallbackFilter(new CallbackFilterImpl());
    enhancer.setCallbacks(new Callback[] {
            NoOp.INSTANCE,
            new LookupOverrideMethodInterceptor(),
            new ReplaceOverrideMethodInterceptor()
    });
    //使用 CGLIB 的 create 方法生成实例对象
    return (ctor == null) ?
            enhancer.create() :
            enhancer.create(ctor.getParameterTypes(), args);
}

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

populateBean 方法对 Bean 属性的依赖注入

在上面的分析中我们已经了解到 Bean 的依赖注入分为以下两个过程

  • createBeanInstance：生成 Bean 所包含的 java 对象实例
  • populateBean ：对 Bean 属性的依赖注入进行处理

我们已经分析了容器初始化生成 Bean 所包含的 Java 实例对象的过程，现在我们继续分析
生成对象后，Spring IOC 容器是如何将 Bean 的属性依赖关系注入 Bean 实例对象中并设置好的，属性
依赖注入的代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
   //将 Bean 属性设置到生成的实例对象上
   protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
       //获取容器在解析 Bean 定义资源时为 BeanDefiniton 中设置的属性值
       PropertyValues pvs = mbd.getPropertyValues();
       //实例对象为 null
       if (bw == null) {
           //属性值不为空
           if (!pvs.isEmpty()) {
               throw new BeanCreationException(
                       mbd.getResourceDescription(), beanName, "Cannot apply property values to null
                       instance");
           }
           else {
               //实例对象为 null，属性值也为空，不需要设置属性值，直接返回
               return;
           }
       }
       //在设置属性之前调用 Bean 的 PostProcessor 后置处理器
       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;
       }
       //依赖注入开始，首先处理 autowire 自动装配的注入
       if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
               mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
           MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
           //对 autowire 自动装配的处理，根据 Bean 名称自动装配注入
           if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
               autowireByName(beanName, mbd, bw, newPvs);
           }
           //根据 Bean 类型自动装配注入
           if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
               autowireByType(beanName, mbd, bw, newPvs);
           }
           pvs = newPvs;
       }
       //检查容器是否持有用于处理单例模式 Bean 关闭时的后置处理器
       boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
       //Bean 实例对象没有依赖，即没有继承基类
       boolean needsDepCheck = (mbd.getDependencyCheck() !=
               RootBeanDefinition.DEPENDENCY_CHECK_NONE);
       if (hasInstAwareBpps || needsDepCheck) {
           //从实例对象中提取属性描述符
           PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);
           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);
           }
       }
       //对属性进行注入
       applyPropertyValues(beanName, mbd, bw, pvs);
   }
   
   protected void autowireByName(
		String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

	String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
	for (String propertyName : propertyNames) {
		if (containsBean(propertyName)) {
			//使用当前Bean的属性名，在IoC容器中获取对应的bean，让将获取的bean设置为当前的Bean的属性值
			Object bean = getBean(propertyName);
			pvs.add(propertyName, bean);
			registerDependentBean(propertyName, beanName);
			if (logger.isDebugEnabled()) {
				logger.debug("Added autowiring by name from bean name '" + beanName +
						"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
						"' by name: no matching bean found");
			}
		}
	}
}
   
   public void registerDependentBean(String beanName, String dependentBeanName) {
	String canonicalName = canonicalName(beanName);
	// 翻译一下就是：set里的bean都要依赖 key
	synchronized (this.dependentBeanMap) {
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			dependentBeans = new LinkedHashSet<String>(8);
			this.dependentBeanMap.put(canonicalName, dependentBeans);
		}
		dependentBeans.add(dependentBeanName);
	}
	// 翻译一下就是：key需要依赖set中的bean
	synchronized (this.dependenciesForBeanMap) {
		Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
		if (dependenciesForBean == null) {
			dependenciesForBean = new LinkedHashSet<String>(8);
			this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
		}
		dependenciesForBean.add(canonicalName);
	}
}
   
   protected Map<String, Object> findAutowireCandidates(
		String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

	//找一下所有的Bean定义中指定Type的实现类或者子类
	String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
			this, requiredType, true, descriptor.isEager());
	Map<String, Object> result = new LinkedHashMap<String, Object>(candidateNames.length);
	//要自动装配的类型是不是要自动装配的纠正类型，这个在
	// 非懒加载的单例Bean初始化前后的一些操作，如果要自动装配的类型是纠正类型，
	// 比如是一个ResourceLoader，那么就会为该类型生成一个代理实例，
	// 具体可以看一下 AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
	for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {
		if (autowiringType.isAssignableFrom(requiredType)) {
			Object autowiringValue = this.resolvableDependencies.get(autowiringType);
			autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
			if (requiredType.isInstance(autowiringValue)) {
				result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
				break;
			}
		}
	}
	//逐个判断查找一下beanName对应的BeanDefinition，判断一下是不是自动装配候选者，默认都是的，如果<bean>的autowire-candidate属性设置为false就不是
	for (String candidateName : candidateNames) {
		if (!candidateName.equals(beanName) && isAutowireCandidate(candidateName, descriptor)) {
			result.put(candidateName, getBean(candidateName));
		}
	}
	return result;
}
   
   @Override
public String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
	if (!isConfigurationFrozen()  || type == null || !allowEagerInit) {
		return doGetBeanNamesForType(type, includeNonSingletons, allowEagerInit);
	}
	Map<Class<?>, String[]> cache =
			(includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
	String[] resolvedBeanNames = cache.get(type);
	if (resolvedBeanNames != null) {
		return resolvedBeanNames;
	}
	resolvedBeanNames = doGetBeanNamesForType(type, includeNonSingletons, allowEagerInit);
	cache.put(type, resolvedBeanNames);
	return resolvedBeanNames;
}
   
   
   //解析并注入依赖属性的过程
   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) {
               //设置安全上下文，JDK 安全机制
               ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
           }
       }
       if (pvs instanceof MutablePropertyValues) {
           mpvs = (MutablePropertyValues) pvs;
           //属性值已经转换
           if (mpvs.isConverted()) {
               try {
                   //为实例化对象设置属性值
                   bw.setPropertyValues(mpvs);
                   return;
               }
               catch (BeansException ex) {
                   throw new BeanCreationException(
                           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 = 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();
               //转换属性值，例如将引用转换为 IOC 容器中实例化对象引用
			//检查，接口和类、父类和子类之间的关系是否正确
			//同时处理ref类型数据
			/**
			 * <bean class="com.jphoebe.xxx">
			 *     <property name="referBeanName" ref="otherBeanName" />
			 * </bean>
			 */
               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);
               }
               //属性是可转换的，且属性原始值是字符串类型，且属性的原始类型值不是
               //动态生成的字符串，且属性的原始值不是集合或者数组类型
               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();
       }
       //进行属性依赖注入
       try {
           bw.setPropertyValues(new MutablePropertyValues(deepCopy));
       }
       catch (BeansException ex) {
           throw new BeanCreationException(
                   mbd.getResourceDescription(), beanName, "Error setting property values", ex);
       }
   }

分析上述代码，我们可以看出，对属性的注入过程分以下两种情况:

  • 属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入
  • 属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。

对属性值的解析是在 BeanDefinitionValueResolver 类中的 resolveValueIfNecessary 方法中进行的，
对属性值的依赖注入是通过 bw.setPropertyValues 方法实现的，在分析属性值的依赖注入之前，我们
先分析一下对属性值的解析过程。

BeanDefinitionValueResolver 解析属性值

当容器在对属性进行依赖注入时，如果发现属性值需要进行类型转换，如属性值是容器中另一个 Bean
实例对象的引用，则容器首先需要根据属性值解析出所引用的对象，然后才能将该引用对象注入到目标
实例对象的属性上去，对属性进行解析的由 resolveValueIfNecessary 方法实现，其源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
//解析属性值，对注入类型进行转换
    public Object resolveValueIfNecessary(Object argName, Object value) {
        //对引用类型的属性进行解析
        if (value instanceof RuntimeBeanReference) {
            RuntimeBeanReference ref = (RuntimeBeanReference) value;
            //调用引用类型属性的解析方法
            return resolveReference(argName, ref);
        }
        //对属性值是引用容器中另一个 Bean 名称的解析
        else if (value instanceof RuntimeBeanNameReference) {
            String refName = ((RuntimeBeanNameReference) value).getBeanName();
            refName = String.valueOf(evaluate(refName));
            //从容器中获取指定名称的 Bean
            if (!this.beanFactory.containsBean(refName)) {
                throw new BeanDefinitionStoreException(
                        "Invalid bean name '" + refName + "' in bean reference for " + argName);
            }
            return refName;
        }
        //对 Bean 类型属性的解析，主要是 Bean 中的内部类
        else if (value instanceof BeanDefinitionHolder) {
            BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
            return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
        }
        else if (value instanceof BeanDefinition) {
            BeanDefinition bd = (BeanDefinition) value;
            return resolveInnerBean(argName, "(inner bean)", bd);
        }
        //对集合数组类型的属性解析
        else if (value instanceof ManagedArray) {
            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) {
                        throw new BeanCreationException(
                                this.beanDefinition.getResourceDescription(), this.beanName,
                                "Error resolving array type for " + argName, ex);
                    }
                }
                //没有获取到数组的类型，也没有获取到数组元素的类型
                //则直接设置数组的类型为 Object
                else {
                    elementType = Object.class;
                }
            }
            //创建指定类型的数组
            return resolveManagedArray(argName, (List<?>) value, elementType);
        }
        //解析 list 类型的属性值
        else if (value instanceof ManagedList) {
            return resolveManagedList(argName, (List<?>) value);
        }
        //解析 set 类型的属性值
        else if (value instanceof ManagedSet) {
            return resolveManagedSet(argName, (Set<?>) value);
        }
        //解析 map 类型的属性值
        else if (value instanceof ManagedMap) {
            return resolveManagedMap(argName, (Map<?, ?>) value);
        }
        //解析 props 类型的属性值，props 其实就是 key 和 value 均为字符串的 map
        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) {
            TypedStringValue typedStringValue = (TypedStringValue) value;
            Object valueObject = evaluate(typedStringValue);
            try {
                //获取属性的目标类型
                Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
                if (resolvedTargetType != null) {
                    //对目标类型的属性进行解析，递归调用
                    return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
                }
                //没有获取到属性的目标对象，则按 Object 类型返回
                else {
                    return valueObject;
                }
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        this.beanDefinition.getResourceDescription(), this.beanName,
                        "Error converting typed String value for " + argName, ex);
            }
        }
        else {
            return evaluate(value);
        }
    }
    //解析引用类型的属性值
    private Object resolveReference(Object argName, RuntimeBeanReference ref) {
        try {
            //获取引用的 Bean 名称
            String refName = ref.getBeanName();
            refName = String.valueOf(evaluate(refName));
            //如果引用的对象在父类容器中，则从父类容器中获取指定的引用对象
            if (ref.isToParent()) {
                if (this.beanFactory.getParentBeanFactory() == null) {
                    throw new BeanCreationException(
                            this.beanDefinition.getResourceDescription(), this.beanName,
                            "Can't resolve reference to bean '" + refName +
                                    "' in parent factory: no parent factory available");
                }
                return this.beanFactory.getParentBeanFactory().getBean(refName);
            }
            //从当前的容器中获取指定的引用 Bean 对象，如果指定的 Bean 没有被实例化
            //则会递归触发引用 Bean 的初始化和依赖注入
            else {
                Object bean = this.beanFactory.getBean(refName);
                //将当前实例化对象的依赖引用对象
                this.beanFactory.registerDependentBean(refName, this.beanName);
                return bean;
            }
        }
        catch (BeansException ex) {
            throw new BeanCreationException(
                    this.beanDefinition.getResourceDescription(), this.beanName,
                    "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " +
                            argName, ex);
        }
    }
    //解析 array 类型的属性
    private Object resolveManagedArray(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(new KeyedArgName(argName, i), ml.get(i)));
        }
        return resolved;
    }
    //解析 list 类型的属性
    private List resolveManagedList(Object argName, List<?> ml) {
        List<Object> resolved = new ArrayList<Object>(ml.size());
        for (int i = 0; i < ml.size(); i++) {
            //递归解析 list 的每一个元素
            resolved.add(
                    resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
        }
        return resolved;
    }
    //解析 set 类型的属性
    private Set resolveManagedSet(Object argName, Set<?> ms) {
        Set<Object> resolved = new LinkedHashSet<Object>(ms.size());
        int i = 0;
        //递归解析 set 的每一个元素
        for (Object m : ms) {
            resolved.add(resolveValueIfNecessary(new KeyedArgName(argName, i), m));
            i++;
        }
        return resolved;
    }
    //解析 map 类型的属性
    private Map resolveManagedMap(Object argName, Map<?, ?> mm) {
        Map<Object, Object> resolved = new LinkedHashMap<Object, Object>(mm.size());
        //递归解析 map 中每一个元素的 key 和 value
        for (Map.Entry entry : mm.entrySet()) {
            Object resolvedKey = resolveValueIfNecessary(argName, entry.getKey());
            Object resolvedValue = resolveValueIfNecessary(
                    new KeyedArgName(argName, entry.getKey()), entry.getValue());
            resolved.put(resolvedKey, resolvedValue);
        }
        return resolved;
    }

通过上面的代码分析，我们明白了 Spring 是如何将引用类型，内部类以及集合类型等属性进行解析的，
属性值解析完成后就可以进行依赖注入了，依赖注入的过程就是 Bean 对象实例设置到它所依赖的 Bean
对象属性上去，在第 7 步中我们已经说过，依赖注入是通过 bw.setPropertyValues 方法实现的，该方
法也使用了委托模式，在 BeanWrapper 接口中至少定义了方法声明，依赖注入的具体实现交由其实现类
BeanWrapperImpl 来完成，下面我们就分析依 BeanWrapperImpl 中赖注入相关的源码。

BeanWrapperImpl 对 Bean 属性的依赖注入

BeanWrapperImpl 类主要是对容器中完成初始化的 Bean 实例对象进行属性的依赖注入，即把 Bean 对象
设置到它所依赖的另一个 Bean 的属性中去，依赖注入的相关源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
//实现属性依赖注入功能
    private void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
        //PropertyTokenHolder 主要保存属性的名称、路径，以及集合的 size 等信息
        String propertyName = tokens.canonicalName;
        String actualName = tokens.actualName;
        //keys 是用来保存集合类型属性的 size
        if (tokens.keys != null) {
            //将属性信息拷贝
            PropertyTokenHolder getterTokens = new PropertyTokenHolder();
            getterTokens.canonicalName = tokens.canonicalName;
            getterTokens.actualName = tokens.actualName;
            getterTokens.keys = new String[tokens.keys.length - 1];
            System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);
            Object propValue;
            try {
                //获取属性值，该方法内部使用 JDK 的内省( Introspector)机制
                //调用属性的 getter(readerMethod)方法，获取属性的值
                propValue = getPropertyValue(getterTokens);
            } catch (NotReadablePropertyException ex) {
                throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
                        "Cannot access indexed value in property referenced " +
                                "in indexed property path '" + propertyName + "'", ex);
            }
            //获取集合类型属性的长度
            String key = tokens.keys[tokens.keys.length - 1];
            if (propValue == null) {
                throw new NullValueInNestedPathException(getRootClass(), this.nestedPath +
                        propertyName,
                        "Cannot access indexed value in property referenced " +
                                "in indexed property path '" + propertyName + "': returned null");
            }
            //注入 array 类型的属性值
            else if (propValue.getClass().isArray()) {
                //获取属性的描述符
                PropertyDescriptor pd =
                        getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                //获取数组的类型
                Class requiredType = propValue.getClass().getComponentType();
                //获取数组的长度
                int arrayIndex = Integer.parseInt(key);
                Object oldValue = null;
                try {
                    //获取数组以前初始化的值
                    if (isExtractOldValueForEditor()) {
                        oldValue = Array.get(propValue, arrayIndex);
                    }
                    //将属性的值赋值给数组中的元素
                    Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
                            requiredType,
                            new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(),
                                    -1), requiredType));
                    Array.set(propValue, arrayIndex, convertedValue);
                } catch (IndexOutOfBoundsException ex) {
                    throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
                            "Invalid array index in property path '" + propertyName + "'", ex);
                }
            }
            //注入 list 类型的属性值
            else if (propValue instanceof List) {
                PropertyDescriptor pd =
                        getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                //获取 list 集合的类型
                Class requiredType = GenericCollectionTypeResolver.getCollectionReturnType(
                        pd.getReadMethod(), tokens.keys.length);
                List list = (List) propValue;
                //获取 list 集合的 size
                int index = Integer.parseInt(key);
                Object oldValue = null;
                if (isExtractOldValueForEditor() && index < list.size()) {
                    oldValue = list.get(index);
                }
                //获取 list 解析后的属性值
                Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
                        requiredType,
                        new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(), -1),
                                requiredType));
                if (index < list.size()) {
                    //为 list 属性赋值
                    list.set(index, convertedValue);
                }
                //如果 list 的长度大于属性值的长度，则多余的元素赋值为 null
                else if (index >= list.size()) {
                    for (int i = list.size(); i < index; i++) {
                        try {
                            list.add(null);
                        } catch (NullPointerException ex) {
                            throw new InvalidPropertyException(getRootClass(), this.nestedPath +
                                    propertyName,
                                    "Cannot set element with index " + index + " in List of size " +
                                            list.size() + ", accessed using property path '" + propertyName +
                                            "': List does not support filling up gaps with null elements");
                        }
                    }
                    list.add(convertedValue);
                }
            }
            //注入 map 类型的属性值
            else if (propValue instanceof Map) {
                PropertyDescriptor pd =
                        getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                //获取 map 集合 key 的类型
                Class mapKeyType = GenericCollectionTypeResolver.getMapKeyReturnType(
                        pd.getReadMethod(), tokens.keys.length);
                //获取 map 集合 value 的类型
                Class mapValueType = GenericCollectionTypeResolver.getMapValueReturnType(
                        pd.getReadMethod(), tokens.keys.length);
                Map map = (Map) propValue;
                //解析 map 类型属性 key 值
                Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType,
                        new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(), -1),
                                mapKeyType));
                Object oldValue = null;
                if (isExtractOldValueForEditor()) {
                    oldValue = map.get(convertedMapKey);
                }
                //解析 map 类型属性 value 值
                Object convertedMapValue = convertIfNecessary(
                        propertyName, oldValue, pv.getValue(), mapValueType,
                        new TypeDescriptor(new MethodParameter(pd.getReadMethod(), -1,
                                tokens.keys.length + 1)));
                //将解析后的 key 和 value 值赋值给 map 集合属性
                map.put(convertedMapKey, convertedMapValue);
            } else {
                throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
                        "Property referenced in indexed property path '" + propertyName +
                                "' is neither an array nor a List nor a Map; returned value was [" + pv.getValue()
                                + "]");
            }
        }
        //对非集合类型的属性注入
        else {
            PropertyDescriptor pd = pv.resolvedDescriptor;
            if (pd == null || !pd.getWriteMethod().getDeclaringClass().isInstance(this.object)) {
                pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                //无法获取到属性名或者属性没有提供 setter(写方法)方法
                if (pd == null || pd.getWriteMethod() == null) {
                    //如果属性值是可选的，即不是必须的，则忽略该属性值
                    if (pv.isOptional()) {
                        logger.debug("Ignoring optional value for property '" + actualName +
                                "' - property not found on bean class [" + getRootClass().getName() +
                                "]");
                        return;
                    }
                    //如果属性值是必须的，则抛出无法给属性赋值，因为没提供 setter 方法异常
                    else {
                        PropertyMatches matches = PropertyMatches.forProperty(propertyName,
                                getRootClass());
                        throw new NotWritablePropertyException(
                                getRootClass(), this.nestedPath + propertyName,
                                matches.buildErrorMessage(), matches.getPossibleMatches());
                    }
                }
                pv.getOriginalPropertyValue().resolvedDescriptor = pd;
            }
            Object oldValue = null;
            try {
                Object originalValue = pv.getValue();
                Object valueToApply = originalValue;
                if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
                    if (pv.isConverted()) {
                        valueToApply = pv.getConvertedValue();
                    } else {
                        if (isExtractOldValueForEditor() && pd.getReadMethod() != null) {
                            //获取属性的 getter 方法(读方法)，JDK 内省机制
                            final Method readMethod = pd.getReadMethod();
                            //如果属性的 getter 方法不是 public 访问控制权限的，即访问控制权限比较严格，
                            //则使用 JDK 的反射机制强行访问非 public 的方法(暴力读取属性值)
                            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers()) &&
                                    !readMethod.isAccessible()) {
                                if (System.getSecurityManager() != null) {
                                    //匿名内部类，根据权限修改属性的读取控制限制
                                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                                        public Object run() {
                                            readMethod.setAccessible(true);
                                            return null;
                                        }
                                    });
                                } else {
                                    readMethod.setAccessible(true);
                                }
                            }
                            try {
                                //属性没有提供 getter 方法时，调用潜在的读取属性值的方法，获取属性值
                                if (System.getSecurityManager() != null) {
                                    oldValue = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                                         public Object run() throws Exception {
                                             return readMethod.invoke(object);
                                         }
                                     }, acc);
                                } else {
                                    oldValue = readMethod.invoke(object);
                                }
                            } catch (Exception ex) {
                                if (ex instanceof PrivilegedActionException) {
                                    ex = ((PrivilegedActionException) ex).getException();
                                }
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Could not read previous value of property '" +
                                            this.nestedPath + propertyName + "'", ex);
                                }
                            }
                        }
                        //设置属性的注入值
                        valueToApply = convertForProperty(propertyName, oldValue, originalValue, pd);
                    }
                    pv.getOriginalPropertyValue().conversionNecessary = (valueToApply !=
                            originalValue);
                }
                //根据 JDK 的内省机制，获取属性的 setter(写方法)方法
                final Method writeMethod = (pd instanceof GenericTypeAwarePropertyDescriptor ?
                        ((GenericTypeAwarePropertyDescriptor) pd).getWriteMethodForActualAccess() :
                        pd.getWriteMethod());
                //如果属性的 setter 方法是非 public，即访问控制权限比较严格，则使用 JDK 的反射机制，
                //强行设置 setter 方法可访问(暴力为属性赋值)
                if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())
                        && !writeMethod.isAccessible()) {
                    //如果使用了 JDK 的安全机制，则需要权限验证
                    if (System.getSecurityManager() != null) {
                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                            public Object run() {
                                writeMethod.setAccessible(true);
                                return null;
                            }
                        });
                    } else {
                        writeMethod.setAccessible(true);
                    }
                }
                final Object value = valueToApply;
                if (System.getSecurityManager() != null) {
                    try {
                        //将属性值设置到属性上去
                        AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                            public Object run() throws Exception {
                                writeMethod.invoke(object, value);
                                return null;
                            }
                        }, acc);
                    } catch (PrivilegedActionException ex) {
                        throw ex.getException();
                    }
                } else {
                    writeMethod.invoke(this.object, value);
                }
            } catch (TypeMismatchException ex) {
                throw ex;
            } catch (InvocationTargetException ex) {
                PropertyChangeEvent propertyChangeEvent =
                        new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName,
                                oldValue, pv.getValue());
                if (ex.getTargetException() instanceof ClassCastException) {
                    throw new TypeMismatchException(propertyChangeEvent, pd.getPropertyType(),
                            ex.getTargetException());
                } else {
                    throw new MethodInvocationException(propertyChangeEvent,
                            ex.getTargetException());
                }
            } catch (Exception ex) {
                PropertyChangeEvent pce =
                        new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName,
                                oldValue, pv.getValue());
                throw new MethodInvocationException(pce, ex);
            }
        }
    }

通过对上面注入依赖代码的分析，我们已经明白了 Spring IOC 容器是如何将属性的值注入到 Bean 实
例对象中去的：

  • 对于集合类型的属性，将其属性值解析为目标类型的集合后直接赋值给属性。
  • 对于非集合类型的属性，大量使用了 JDK 的反射和内省机制，通过属性的 getter 方法(reader method)获取指定属性注入以前的值，同时调用属性的 setter 方法(writer method)为属性设置注入后的值。看到这里相信很多人都明白了 Spring 的 setter 注入原理。

至此 Spring IOC 容器对 Bean 定义资源文件的定位，载入、解析和依赖注入已经全部分析完毕，现在
Spring IOC 容器中管理了一系列靠依赖关系联系起来的 Bean，程序不需要应用自己手动创建所需的对
象，Spring IOC 容器会在我们使用的时候自动为我们创建，并且为我们注入好相关的依赖，这就是
Spring 核心功能的控制反转和依赖注入的相关功能。

Jeff-Eric wechat