1
2
ApplicationContext context = new ClassPathXmlApplicationContext("spring-beans.xml");

1
2
3
4
5
6
7
8
9
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)throws BeansException {
    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        // 容器初始化入口
        refresh();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        prepareRefresh();
        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);
        // Allows post-processing of the bean factory in context subclasses.
        postProcessBeanFactory(beanFactory);
        // Invoke factory processors registered as beans in the context.
        invokeBeanFactoryPostProcessors(beanFactory);
        // Register bean processors that intercept bean creation.
        registerBeanPostProcessors(beanFactory);
        // Instantiate all remaining (non-lazy-init) singletons.
        // 初始化所有非 懒加载的bean！！！！
        finishBeanFactoryInitialization(beanFactory);
        // Last step: publish corresponding event.
        finishRefresh();
    }
  }

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
finishBeanFactoryInitialization(beanFactory);// 初始化所有非 懒加载的bean！！!

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   	// Stop using the temporary ClassLoader for type matching.
   	beanFactory.setTempClassLoader(null);
   	// 此处省略多行与本次无关代码
   	// Instantiate all remaining (non-lazy-init) singletons.
   	beanFactory.preInstantiateSingletons();
   }

public void preInstantiateSingletons() throws BeansException {
   // 所有beanDefinition集合
   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
   // 触发所有非懒加载单例bean的初始化
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 判断是否是懒加载单例bean，如果是单例的并且不是懒加载的则在Spring 容器
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
          // 判断是否是FactoryBean
         if (isFactoryBean(beanName)) {
             // 对FactoryBean的处理
         }else {
             // 如果是普通bean则进行初始化依赖注入，此 getBean(beanName)接下来触发的逻辑跟
             // context.getBean("beanName") 所触发的逻辑是一样的
            getBean(beanName);
         }
      }
   }
}


@Override
public Object getBean(String name) throws BeansException {   
    return doGetBean(name, null, null, false);
}

1
2
3
4
5
@Override
public Object getBean(String name) throws BeansException {   
    return doGetBean(name, null, null, false);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
	//第一步 创建bean实例 还未进行属性填充和各种特性的初始化
	BeanWrapper instanceWrapper = null;
	if (instanceWrapper == null) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
	Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
	Object exposedObject = bean;
	try {
	    // 第二步 进行依赖注入(注入属性)
	    populateBean(beanName, mbd, instanceWrapper);
	    if (exposedObject != null) {
	     // 第三步  执行bean的初始化方法
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	    }
	}catch (Throwable ex) {
	 //  抛相应的异常
	}
	return exposedObject;
}

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
populateBean(beanName, mbd, instanceWrapper);

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        // 所有的属性
	PropertyValues pvs = mbd.getPropertyValues();
	// 这里是处理自动装配类型的, autowire=byName 或者byType。如果不配置不走这个分支，xml或注解都可配 
	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		pvs = newPvs;
	}
	// 后处理器是否已经准备好（后处理器会处理已@Autowired 形式来注入的bean， 有一个  
	// 子类AutowiredAnnotationBeanPostProcessor来处理@Autowired注入的bean）
	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;
					// 这里会处理对注解形式的注入 重点！！！！
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvs == null) {
						return;
					}
				}
			}
		}
	}
    // 注入参数的方法（注解的Bean的依赖注入除外）
	applyPropertyValues(beanName, mbd, bw, pvs);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        // 这里定义了把谁注入到哪里
	InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
	try {  
	   // 进行注入
	   metadata.inject(bean, beanName, pvs);
	}catch (Throwable ex) {
		throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
	}
	return pvs;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
protected void inject(Object target, String requestingBeanName, PropertyValues pvs) throws Throwable {
	if (this.isField) {
		Field field = (Field) this.member;
		ReflectionUtils.makeAccessible(field);
		field.set(target, getResourceToInject(target, requestingBeanName));
	}else {
		if (checkPropertySkipping(pvs)) {
		   return;
		}
		try {
		   Method method = (Method) this.member;
		   ReflectionUtils.makeAccessible(method);
		   method.invoke(target, getResourceToInject(target, requestingBeanName));
		}catch (InvocationTargetException ex) {
		  throw ex.getTargetException();
		}
	}
}

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
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        MutablePropertyValues mpvs = null;
        List<PropertyValue> original;
        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            // 判断是否已转换，已经转换了则return
            if (mpvs.isConverted()) {
                // Shortcut: use the pre-converted values as-is.
                bw.setPropertyValues(mpvs);
                return;
            }
            original = mpvs.getPropertyValueList();
        }
        TypeConverter converter = getCustomTypeConverter();
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
        // Create a deep copy, resolving any references for values.
        List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            if (pv.isConverted()) {
                deepCopy.add(pv);
            } else {
                // 属性名 如（name,orderService）
                String propertyName = pv.getName();
                // 未转换前的值，稍后贴出debug时的图
                Object originalValue = pv.getValue();
                // 转换后的值,进行转换处理(重要！！！！)
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                Object convertedValue = resolvedValue;
                //
                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();
        }
        // 这里就是进行属性注入的地方，跟上面的inject方法类似
        try {
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        } catch (BeansException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", ex);
        }
    }

1
2
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);

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
public Object resolveValueIfNecessary(Object argName, Object value) {
     // Bean 类型
    if (value instanceof RuntimeBeanReference) {
        RuntimeBeanReference ref = (RuntimeBeanReference) value;
        return resolveReference(argName, ref);
    }
    else if (value instanceof ManagedArray) {
        // 处理数组
        return resolveManagedArray(argName, (List<?>) value, elementType);
    }
    else if (value instanceof ManagedList) {
        // 处理list
        return resolveManagedList(argName, (List<?>) value);
    }
    else if (value instanceof ManagedSet) {
        // 处理set
        return resolveManagedSet(argName, (Set<?>) value);
    }
    else if (value instanceof ManagedMap) {
        // 处理map
        return resolveManagedMap(argName, (Map<?, ?>) value);
    }
    else if (value instanceof TypedStringValue) {
    // 处理字符串
    }
    else {
        return evaluate(value);
    }
}

private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    try {
    String refName = ref.getBeanName();
    refName = String.valueOf(doEvaluate(refName));
    if (ref.isToParent()) {
        if (this.beanFactory.getParentBeanFactory() == null) {
            throw new BeanCreationException("");
        }
        return this.beanFactory.getParentBeanFactory().getBean(refName);
    }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);
    }
}

Object bean = this.beanFactory.getBean(refName);

this.beanFactory.getParentBeanFactory().getBean(refName);