上一篇跟踪了bean的创建过程，接下来，我们继续跟踪bean的属性填充的过程。先回到doCreateBean方法，代码如下：
1 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
2 throws BeanCreationException {
3
4 // Instantiate the bean.
5 BeanWrapper instanceWrapper = null;
6 if (mbd.isSingleton()) {
7 //如果是单例，先把缓存中的同名Bean清除
8 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
9 }
10 //如果缓存中没有
11 if (instanceWrapper == null) {
12 //则创建一个实例
13 instanceWrapper = createBeanInstance(beanName, mbd, args);
14 }
15 final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
16 Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
17 mbd.resolvedTargetType = beanType;
18
19 // Allow post-processors to modify the merged bean definition.
20 synchronized (mbd.postProcessingLock) {
21 if (!mbd.postProcessed) {
22 try {
23 //使用后置处理器进行处理
24 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
25 }
26 catch (Throwable ex) {
27 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
28 "Post-processing of merged bean definition failed", ex);
29 }
30 mbd.postProcessed = true;
31 }
32 }
33
34 // Eagerly cache singletons to be able to resolve circular references
35 // even when triggered by lifecycle interfaces like BeanFactoryAware.
36 //这里是对单例的循环引用的处理，单例&&允许循环依赖&&正在被创建同时满足，才为true
37 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
38 isSingletonCurrentlyInCreation(beanName));
39 if (earlySingletonExposure) {
40 if (logger.isDebugEnabled()) {
41 logger.debug("Eagerly caching bean '" + beanName +
42 "' to allow for resolving potential circular references");
43 }
44 addSingletonFactory(beanName, new ObjectFactory<Object>() {
45 @Override
46 public Object getObject() throws BeansException {
47 return getEarlyBeanReference(beanName, mbd, bean);
48 }
49 });
50 }
51
52 //这里是对bean的初始化，依赖注入往往是在这里进行的，这个exposedObject在初始化完成之后会作为依赖注入完成之后的Bean
53 // Initialize the bean instance.
54 Object exposedObject = bean;
55 try {
56 //属性的填充
57 populateBean(beanName, mbd, instanceWrapper);
58 if (exposedObject != null) {
59 exposedObject = initializeBean(beanName, exposedObject, mbd);
60 }
61 }
62 catch (Throwable ex) {
63 if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
64 throw (BeanCreationException) ex;
65 }
66 else {
67 throw new BeanCreationException(
68 mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
69 }
70 }
71
72 if (earlySingletonExposure) {
73 Object earlySingletonReference = getSingleton(beanName, false);
74 if (earlySingletonReference != null) {
75 if (exposedObject == bean) {
76 exposedObject = earlySingletonReference;
77 }
78 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
79 String[] dependentBeans = getDependentBeans(beanName);
80 Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
81 for (String dependentBean : dependentBeans) {
82 if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
83 actualDependentBeans.add(dependentBean);
84 }
85 }
86 if (!actualDependentBeans.isEmpty()) {
87 throw new BeanCurrentlyInCreationException(beanName,
88 "Bean with name '" + beanName + "' has been injected into other beans [" +
89 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
90 "] in its raw version as part of a circular reference, but has eventually been " +
91 "wrapped. This means that said other beans do not use the final version of the " +
92 "bean. This is often the result of over-eager type matching - consider using " +
93 "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
94 }
95 }
96 }
97 }
98
99 // Register bean as disposable.
100 try {
101 registerDisposableBeanIfNecessary(beanName, bean, mbd);
102 }
103 catch (BeanDefinitionValidationException ex) {
104 throw new BeanCreationException(
105 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
106 }
107
108 return exposedObject;
109 }
对于bean的创建，IOC容器其实是采用反射和cglib技术来生成的，我们可以跟踪一下createBeanInstance方法：
1 protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
2 // Make sure bean class is actually resolved at this point.
3 Class<?> beanClass = resolveBeanClass(mbd, beanName);
4
5 if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
6 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
7 "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
8 }
9
10 //使用工厂方法对Bean进行实例化
11 if (mbd.getFactoryMethodName() != null) {
12 return instantiateUsingFactoryMethod(beanName, mbd, args);
13 }
14
15 // Shortcut when re-creating the same bean...
16 boolean resolved = false;
17 boolean autowireNecessary = false;
18 if (args == null) {
19 synchronized (mbd.constructorArgumentLock) {
20 if (mbd.resolvedConstructorOrFactoryMethod != null) {
21 resolved = true;
22 autowireNecessary = mbd.constructorArgumentsResolved;
23 }
24 }
25 }
26 if (resolved) {
27 if (autowireNecessary) {
28 return autowireConstructor(beanName, mbd, null, null);
29 }
30 else {
31 return instantiateBean(beanName, mbd);
32 }
33 }
34
35 //使用构造函数对Bean实例化
36 // Need to determine the constructor...
37 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
38 if (ctors != null ||
39 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
40 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
41 return autowireConstructor(beanName, mbd, ctors, args);
42 }
43
44 //使用默认的构造函数对Bean进行实例化
45 // No special handling: simply use no-arg constructor.
46 return instantiateBean(beanName, mbd);
47 }
1、如果指定了工厂方法，则使用工厂进行创建；
2、如果没有指定工厂方法，则看有没指定某个构造器进行实例化；
3、都没有，则采用默认的构造器进行实例化。进入默认的构造器方法：
1 protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
2 try {
3 Object beanInstance;
4 final BeanFactory parent = this;
5 if (System.getSecurityManager() != null) {
6 beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
7 @Override
8 public Object run() {
9 return getInstantiationStrategy().instantiate(mbd, beanName, parent);
10 }
11 }, getAccessControlContext());
12 }
13 else {
14 beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
15 }
16 BeanWrapper bw = new BeanWrapperImpl(beanInstance);
17 initBeanWrapper(bw);
18 return bw;
19 }
20 catch (Throwable ex) {
21 throw new BeanCreationException(
22 mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
23 }
24 }
虽然getInstantiationStrategy()方法获取的是CglibSubclassingInstantiationStrategy实例，但是CglibSubclassingInstantiationStrategy中只有一个instantiate带一个参数和一个可变参数的方法，和这里调用的并不是同一个方法，所以，这里调用的是它的父类SimpleInstantiationStrategy中的instantiate方法，进入：
1 public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
2 // Don't override the class with CGLIB if no overrides.
3 if (bd.getMethodOverrides().isEmpty()) {
4 Constructor<?> constructorToUse;
5 synchronized (bd.constructorArgumentLock) {
6 //这里取得指定的构造器或者生产对象的工厂方法来对Bean进行实例化
7 constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
8 if (constructorToUse == null) {
9 final Class<?> clazz = bd.getBeanClass();
10 if (clazz.isInterface()) {
11 throw new BeanInstantiationException(clazz, "Specified class is an interface");
12 }
13 try {
14 if (System.getSecurityManager() != null) {
15 constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
16 @Override
17 public Constructor<?> run() throws Exception {
18 return clazz.getDeclaredConstructor((Class[]) null);
19 }
20 });
21 }
22 else {
23 constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
24 }
25 bd.resolvedConstructorOrFactoryMethod = constructorToUse;
26 }
27 catch (Throwable ex) {
28 throw new BeanInstantiationException(clazz, "No default constructor found", ex);
29 }
30 }
31 }
32 //使用反射进行实例化
33 return BeanUtils.instantiateClass(constructorToUse);
34 }
35 else {
36 //使用cglb进行实例化
37 // Must generate CGLIB subclass.
38 return instantiateWithMethodInjection(bd, beanName, owner);
39 }
40 }
这段代码可以看到，IOC是使用反射和cglib来进行实例化对象的。好了，我们回到之前的方法，到populateBean(beanName, mbd, instanceWrapper)方法进行跟踪：
1 protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
2 //在前面解析的过程中，XML中设置的属性已经填充到beanDefinition 的propertyValues属性中
3 PropertyValues pvs = mbd.getPropertyValues();
4
5 if (bw == null) {
6 if (!pvs.isEmpty()) {
7 throw new BeanCreationException(
8 mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
9 }
10 else {
11 // Skip property population phase for null instance.
12 return;
13 }
14 }
15
16 // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
17 // state of the bean before properties are set. This can be used, for example,
18 // to support styles of field injection.
19 boolean continueWithPropertyPopulation = true;
20
21 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
22 for (BeanPostProcessor bp : getBeanPostProcessors()) {
23 if (bp instanceof InstantiationAwareBeanPostProcessor) {
24 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
25 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
26 continueWithPropertyPopulation = false;
27 break;
28 }
29 }
30 }
31 }
32
33 if (!continueWithPropertyPopulation) {
34 return;
35 }
36
37 //开始进行依赖注入的操作
38 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
39 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
40 MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
41
42 //按属性的名字来进行注入
43 // Add property values based on autowire by name if applicable.
44 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
45 autowireByName(beanName, mbd, bw, newPvs);
46 }
47
48 //按属性的类型来进行注入
49 // Add property values based on autowire by type if applicable.
50 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
51 autowireByType(beanName, mbd, bw, newPvs);
52 }
53
54 pvs = newPvs;
55 }
56
57 boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
58 boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
59
60 if (hasInstAwareBpps || needsDepCheck) {
61 PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
62 if (hasInstAwareBpps) {
63 for (BeanPostProcessor bp : getBeanPostProcessors()) {
64 if (bp instanceof InstantiationAwareBeanPostProcessor) {
65 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
66 pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
67 if (pvs == null) {
68 return;
69 }
70 }
71 }
72 }
73 if (needsDepCheck) {
74 checkDependencies(beanName, mbd, filteredPds, pvs);
75 }
76 }
77
78 //对属性进行注入
79 applyPropertyValues(beanName, mbd, bw, pvs);
80 }
可以看到：
1、我们可以在XML中指定autowired的值，是按名称还是类型来进行注入；
2、真正进行属性注入的是applyPropertyValues方法，进入：
1 protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
2 if (pvs == null || pvs.isEmpty()) {
3 return;
4 }
5
6 if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
7 ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
8 }
9
10 MutablePropertyValues mpvs = null;
11 List<PropertyValue> original;
12
13 if (pvs instanceof MutablePropertyValues) {
14 mpvs = (MutablePropertyValues) pvs;
15 if (mpvs.isConverted()) {
16 // Shortcut: use the pre-converted values as-is.
17 try {
18 bw.setPropertyValues(mpvs);
19 return;
20 }
21 catch (BeansException ex) {
22 throw new BeanCreationException(
23 mbd.getResourceDescription(), beanName, "Error setting property values", ex);
24 }
25 }
26 original = mpvs.getPropertyValueList();
27 }
28 else {
29 original = Arrays.asList(pvs.getPropertyValues());
30 }
31
32 TypeConverter converter = getCustomTypeConverter();
33 if (converter == null) {
34 converter = bw;
35 }
36 //获取解析器
37 BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
38
39 // Create a deep copy, resolving any references for values.
40 List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
41 boolean resolveNecessary = false;
42 for (PropertyValue pv : original) {
43 //如果已经转换过，就直接存入
44 if (pv.isConverted()) {
45 deepCopy.add(pv);
46 }
47 else {
48 //获取属性名称
49 String propertyName = pv.getName();
50 //获取属性值
51 Object originalValue = pv.getValue();
52 //将值进行转换，比如属性的值有可能是数组、集合，或者对象，并且该对象也需要进行属性的注入，
53 //那么还会进行递归调用getBean方法，将该对象生成好之后再注入给当前的属性
54 Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
55 Object convertedValue = resolvedValue;
56 boolean convertible = bw.isWritableProperty(propertyName) &&
57 !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
58 if (convertible) {
59 convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
60 }
61 // Possibly store converted value in merged bean definition,
62 // in order to avoid re-conversion for every created bean instance.
63 if (resolvedValue == originalValue) {
64 if (convertible) {
65 pv.setConvertedValue(convertedValue);
66 }
67 deepCopy.add(pv);
68 }
69 else if (convertible && originalValue instanceof TypedStringValue &&
70 !((TypedStringValue) originalValue).isDynamic() &&
71 !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
72 pv.setConvertedValue(convertedValue);
73 deepCopy.add(pv);
74 }
75 else {
76 resolveNecessary = true;
77 deepCopy.add(new PropertyValue(pv, convertedValue));
78 }
79 }
80 }
81 if (mpvs != null && !resolveNecessary) {
82 mpvs.setConverted();
83 }
84
85 //设置依赖注入的地方
86 // Set our (possibly massaged) deep copy.
87 try {
88 bw.setPropertyValues(new MutablePropertyValues(deepCopy));
89 }
90 catch (BeansException ex) {
91 throw new BeanCreationException(
92 mbd.getResourceDescription(), beanName, "Error setting property values", ex);
93 }
94 }
至此，一个完整的bean就算创建完成了，要用的时候，直接找IOC容器拿就行了。