spring源码分析(一)IoC、DI

创建日期：2016.08.06

修改日期：2016.08.07 - 2016.08.12

交流QQ：992591601

参考书籍：《spring源码深度解析》、《spring技术内幕》

参考文章：http://www.cnblogs.com/xing901022/p/4178963.html

http://www.myexception.cn/program/1031276.html

http://blog.csdn.net/qian_348840260/article/details/7994936

一、搭建工程，运行简单示例：

1. @Test
2. public void testSimpleLoad() {
3. BeanFactory bf = new XmlBeanFactory(new ClassPathResource ("beans.xml"));
4. Person bean = (Person) bf.getBean("person");
5. bean.info();
6. }

其余代码我就不贴了，很基本。要说明一点，要看spring源码的话，需要在导入的spring jar包附上额外的源码包，eclipse可以配置：

二、这个工程的test程序只有短短几行，但背后的spring代码却是繁多复杂的。

BeanFactory bf = new XmlBeanFactory(new ClassPathResource ("beans.xml"));
Person bean = (Person) bf.getBean("person");

这两句的逻辑看起来很简单，首先依据xml文件创建工厂类，再通过工厂类从容器获取bean。在这个过程中用ClassPathResource类来对配置文件作一个包装，然后作为XmlBeanFactory构造函数的参数。

BeanFactory是一个接口。

先来看ClassPathResource类。经过代码阅读，可以总结UML图：

可以清晰看得出来，spring的设计者在这里应用了一个著名设计模式：策略模式。简单些讲，就是面向接口编程的一种思路。在这里UrlResource和ClassPathResource都实现了Resource接口，是Resource接口的两种实现策略。

我们首先看Resource接口，这是最基础的定义：

1. public interface Resource extends InputStreamSource {
2. boolean exists();
3. boolean isReadable();
4. boolean isOpen();
5. URL getURL() throws IOException;
6. URI getURI() throws IOException;
7. File getFile() throws IOException;
8. long contentLength() throws IOException;
9. long lastModified() throws IOException;
10. Resource createRelative(String relativePath) throws IOException;
11. String getFilename();
12. String getDescription();
13. }

该接口定义了一些很基本的方法。都是一些很必要的get操作。具体实现自然要交给两个策略来实现：UrlResource和ClassPathResource。另外，值得一提的是该接口还继承了一个接口InputStreamSource。该接口只定义了一个方法：

InputStream getInputStream() throws IOException;    是用来获取java I/O的。

抽象类AbstractResource是接口与实现策略之间的中间层。实现了Resource接口的所有方法。在此基础上，策略类继承该抽象类之后，就只需提供自己特有的方法即可了。然而很多方法例如getURL都要在策略类里重写的，因为url这种数据还是要具体实例化时才能得到。

具体实现细节不多说，总结一下，就是spring的资源文件通过Resource接口的实现类来包装。而这些实现类与Resource接口的关系是一种策略模式。

接下来看XmlBeanFactory类的代码：

1. public class XmlBeanFactory extends DefaultListableBeanFactory {
2. private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
3. /**
4. * Create a new XmlBeanFactory with the given resource,
5. * which must be parsable using DOM.
6. * @param resource XML resource to load bean definitions from
7. * @throws BeansException in case of loading or parsing errors
8. */
9. public XmlBeanFactory(Resource resource) throws BeansException {
10. this(resource, null);
11. }
12. /**
13. * Create a new XmlBeanFactory with the given input stream,
14. * which must be parsable using DOM.
15. * @param resource XML resource to load bean definitions from
16. * @param parentBeanFactory parent bean factory
17. * @throws BeansException in case of loading or parsing errors
18. */
19. public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
20. super(parentBeanFactory);
21. this.reader.loadBeanDefinitions(resource);
22. }
23. }

XmlBeanFactory将Resource作为构造函数参数。这里XmlBeanDefinitionReader是关键，用来根据Resource来loadBeanDefinitions。这是XmlBeanFactory对基类DefaultListableBeanFactory的添加。

EncodeResource是对resource的封装，采用装饰者模式。主要增加了编码的信息。在很多时候，虽然两个类具有一定继承关系，但采用组合代替继承是更好的设计

1. public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
2. Assert.notNull(encodedResource, "EncodedResource must not be null");
3. if (logger.isInfoEnabled()) {
4. logger.info("Loading XML bean definitions from " + encodedResource.getResource());
5. }
6. Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
7. if (currentResources == null) {
8. currentResources = new HashSet<EncodedResource>(4);
9. this.resourcesCurrentlyBeingLoaded.set(currentResources);
10. }
11. if (!currentResources.add(encodedResource)) {
12. throw new BeanDefinitionStoreException(
13. "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
14. }
15. try {
16. InputStream inputStream = encodedResource.getResource().getInputStream();
17. try {
18. InputSource inputSource = new InputSource(inputStream);
19. if (encodedResource.getEncoding() != null) {
20. inputSource.setEncoding(encodedResource.getEncoding());
21. }
22. return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
23. }
24. finally {
25. inputStream.close();
26. }
27. }
28. catch (IOException ex) {
29. throw new BeanDefinitionStoreException(
30. "IOException parsing XML document from " + encodedResource.getResource(), ex);
31. }
32. finally {
33. currentResources.remove(encodedResource);
34. if (currentResources.isEmpty()) {
35. this.resourcesCurrentlyBeingLoaded.remove();
36. }
37. }
38. }

该方法作用是将XML文件转化为BeanDefinitions。

这段代码意思是：

1，获取线程局部变量resourcesCurrentlyBeingLoaded，  final ThreadLocal<Set<EncodedResource>>类型。

将当前要加载的Source，放入final ThreadLocal<Set<EncodedResource>>，若无法放入则抛出异常。

2，核心，真正的去加载Resource：

InputStream inputStream = encodedResource.getResource().getInputStream();
try {
        InputSource inputSource = new InputSource(inputStream);
        if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
        }
        return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
       inputStream.close();
}

3，将加载过的Resource从resourcesCurrentlyBeingLoaded删除。

这里面1和3涉及多线程操作，这里面了解下java的ThreadLocal：ThreadLocal是指线程类的局部变量，他可以保证每一个线程都保有一份自己的局部变量的副本，线程之间不会对别的线程的ThreadLocal产生影响。

从代码上看，1和3的意义就是用ThreadLocal标注当前线程正在加载的Resource。

2是核心部分，调用doLoadBeanDefinitions(InputSource inputSource, Resource resource)方法

1. protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
2. throws BeanDefinitionStoreException {
3. try {
4. int validationMode = getValidationModeForResource(resource);
5. Document doc = this.documentLoader.loadDocument(
6. inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
7. return registerBeanDefinitions(doc, resource);
8. }
9. catch (BeanDefinitionStoreException ex) {
10. throw ex;
11. }
12. catch (SAXParseException ex) {
13. throw new XmlBeanDefinitionStoreException(resource.getDescription(),
14. "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
15. }
16. catch (SAXException ex) {
17. throw new XmlBeanDefinitionStoreException(resource.getDescription(),
18. "XML document from " + resource + " is invalid", ex);
19. }
20. catch (ParserConfigurationException ex) {
21. throw new BeanDefinitionStoreException(resource.getDescription(),
22. "Parser configuration exception parsing XML from " + resource, ex);
23. }
24. catch (IOException ex) {
25. throw new BeanDefinitionStoreException(resource.getDescription(),
26. "IOException parsing XML document from " + resource, ex);
27. }
28. catch (Throwable ex) {
29. throw new BeanDefinitionStoreException(resource.getDescription(),
30. "Unexpected exception parsing XML document from " + resource, ex);
31. }
32. }

关键是这三句：

int validationMode = getValidationModeForResource(resource);
Document doc = this.documentLoader.loadDocument(
                                                  inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
return registerBeanDefinitions(doc, resource);

继续看loadDocument方法代码：

1. public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
2. ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
3. DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
4. if (logger.isDebugEnabled()) {
5. logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
6. }
7. DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
8. return builder.parse(inputSource);
9. }

关于参数，entityResolver,解释起来有些麻烦，直接引用《spring源码深度解析》一书的文字吧：

int validationMode = getValidationModeForResource(resource); 这句是获取对应资源的验证方式。两种验证模式：DTD、XSD

这里DocumentBuilder的创建方式体现了工厂模式。具体创建是靠DocumentBuilderFactory factory作为参数。而factory的创建是方法protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware)

DocumentBuilderFactory和DocumentBuilder都是抽象类，真正实例化的是对抽象类的实现类。

不管怎么样，它return builder.parse(inputSource)   return的是一个Document类。

Document接口注释：

* The <code>Document</code> interface represents the entire HTML or XML
 * document. Conceptually, it is the root of the document tree, and provides
 * the primary access to the document's data.

而Document接口又是继承了Node接口。

loadDocument方法就是将文件转化为Document类的过程。

继续看代码：

1. public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
2. // Read document based on new BeanDefinitionDocumentReader SPI.
3. BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
4. int countBefore = getRegistry().getBeanDefinitionCount();
5. documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
6. return getRegistry().getBeanDefinitionCount() - countBefore;
7. }

1. public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
2. this.readerContext = readerContext;
3. logger.debug("Loading bean definitions");
4. Element root = doc.getDocumentElement();
5. BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);
6. preProcessXml(root);
7. parseBeanDefinitions(root, delegate);
8. postProcessXml(root);
9. }
10. protected BeanDefinitionParserDelegate createHelper(XmlReaderContext readerContext, Element root) {
11. BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
12. delegate.initDefaults(root);
13. return delegate;
14. }

Element root = doc.getDocumentElement();获取根节点Element。

/**
 * The <code>Element</code> interface represents an element in an HTML or XML
 * document. Elements may have attributes associated with them; since the
 * <code>Element</code> interface inherits from <code>Node</code>, the
 * generic <code>Node</code> interface attribute <code>attributes</code> may
 * be used to retrieve the set of all attributes for an element. There are
 * methods on the <code>Element</code> interface to retrieve either an
 * <code>Attr</code> object by name or an attribute value by name. In XML,
 * where an attribute value may contain entity references, an
 * <code>Attr</code> object should be retrieved to examine the possibly
 * fairly complex sub-tree representing the attribute value. On the other
 * hand, in HTML, where all attributes have simple string values, methods to
 * directly access an attribute value can safely be used as a convenience.
 * <p ><b>Note:</b> In DOM Level 2, the method <code>normalize</code> is
 * inherited from the <code>Node</code> interface where it was moved.
 * <p>See also the <a href='http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407'>Document Object Model (DOM) Level 3 Core Specification</a>.
 */
public interface Element extends Node{……}

而这里的BeanDefinitionParserDelegate delegate是用来做转换工作。

spring源码的阅读工作就是一层套一层……然而并不难搞懂

理解下面的代码必须要提及spring XML配置里有两种bean的声明，一种是默认的<bean id = "test" class = "test.TestBean"/>另一种就是自定义的：<tx:annotation-driven/>：

1. /**
2. * Parse the elements at the root level in the document:
3. * "import", "alias", "bean".
4. * @param root the DOM root element of the document
5. */
6. protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
7. //如果是默认方式声明bean
8. if (delegate.isDefaultNamespace(root)) {
9. NodeList nl = root.getChildNodes();
10. for (int i = 0; i < nl.getLength(); i++) {
11. Node node = nl.item(i);
12. if (node instanceof Element) {
13. Element ele = (Element) node;
14. if (delegate.isDefaultNamespace(ele)) {
15. parseDefaultElement(ele, delegate);
16. }
17. else {
18. delegate.parseCustomElement(ele);
19. }
20. }
21. }
22. }
23. //自定义方式声明bean
24. else {
25. delegate.parseCustomElement(root);
26. }
27. }

这里是从根节点，开始转换。

继续看核心操作parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法：

1. private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
2. if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
3. importBeanDefinitionResource(ele);
4. }
5. else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
6. processAliasRegistration(ele);
7. }
8. else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
9. processBeanDefinition(ele, delegate);
10. }
11. }

看代码感觉这是在根据节点名称类型选择注册操作，继续看void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)方法：

1. /**
2. * Process the given bean element, parsing the bean definition
3. * and registering it with the registry.
4. */
5. protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
6. BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
7. if (bdHolder != null) {
8. bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
9. try {
10. // Register the final decorated instance.
11. BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
12. }
13. catch (BeanDefinitionStoreException ex) {
14. getReaderContext().error("Failed to register bean definition with name '" +
15. bdHolder.getBeanName() + "'", ele, ex);
16. }
17. // Send registration event.
18. getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
19. }
20. }

这里BeanDefinitionHolder也是采用了装饰者模式。包含了BeanDefinition,添加了：

private final String beanName;

private final String[] aliases;
两个私有final变量。

另外注意BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());这句。

1. public static void registerBeanDefinition(
2. BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
3. throws BeanDefinitionStoreException {
4. // Register bean definition under primary name.
5. String beanName = definitionHolder.getBeanName();
6. registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
7. // Register aliases for bean name, if any.
8. String[] aliases = definitionHolder.getAliases();
9. if (aliases != null) {
10. for (String aliase : aliases) {
11. registry.registerAlias(beanName, aliase);
12. }
13. }
14. }

BeanDefinitionRegistry是XMLBeanFactory的基类之一。设置断点跟踪，我们可以发现，进入这个方法，传进来的类实例正是XmlBeanFactory。接下来调用的是XmlBeanFactory类的方法，registerBeanDefinition。方法内部调用的这里是真正的注册的实现：将BeanDefinition添加的，Spring的BeanFactory容器里，一个Map数据结构：

/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

1. public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
2. throws BeanDefinitionStoreException {
3. Assert.hasText(beanName, "Bean name must not be empty");
4. Assert.notNull(beanDefinition, "BeanDefinition must not be null");
5. if (beanDefinition instanceof AbstractBeanDefinition) {
6. try {
7. ((AbstractBeanDefinition) beanDefinition).validate();
8. }
9. catch (BeanDefinitionValidationException ex) {
10. throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
11. "Validation of bean definition failed", ex);
12. }
13. }
14. synchronized (this.beanDefinitionMap) {
15. Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
16. if (oldBeanDefinition != null) {
17. if (!this.allowBeanDefinitionOverriding) {
18. throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
19. "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
20. "': There is already [" + oldBeanDefinition + "] bound.");
21. }
22. else {
23. if (this.logger.isInfoEnabled()) {
24. this.logger.info("Overriding bean definition for bean '" + beanName +
25. "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
26. }
27. }
28. }
29. else {
30. this.beanDefinitionNames.add(beanName);
31. this.frozenBeanDefinitionNames = null;
32. }
33. this.beanDefinitionMap.put(beanName, beanDefinition);
34. resetBeanDefinition(beanName);
35. }
36. }

以上所述就是BeanFactory bf = new XmlBeanFactory(new ClassPathResource ("beans.xml"));这句代码背后的故事。

首先，ClassPathResource类封装了资源文件，作为构造函数参数来创建XmlBeanFactory。经过一系列复杂转换将XML文件转换为spring需要的数据结构~ BeanDefinition

对XML的解析和BeanDefinition就介绍到这，介绍的并不够绝对细致，主要是理解大意，另外也是spring源码确实比较繁杂。并且以后有了新的心得还会在这篇文章做修改补充。

接下来这句：Person bean = (Person) bf.getBean("person");

代码的字面意思就是从spring容器里，获取person bean的实例对象。

这里要提到BeanFactory和ApplicationContext的区别：BeanFactory是采取延迟加载，只有当getBean的时候才会去加载、实例化这个对象。ApplicationContext则正相反，它是一次性加载所有bean。

getBean的最终实现是 AbstractBeanFactory的 doGetBean方法

1. @SuppressWarnings("unchecked")
2. protected <T> T doGetBean(
3. final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
4. throws BeansException {
5. final String beanName = transformedBeanName(name);
6. Object bean;
7. // Eagerly check singleton cache for manually registered singletons.
8. Object sharedInstance = getSingleton(beanName);
9. if (sharedInstance != null && args == null) {
10. if (logger.isDebugEnabled()) {
11. if (isSingletonCurrentlyInCreation(beanName)) {
12. logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
13. "' that is not fully initialized yet - a consequence of a circular reference");
14. }
15. else {
16. logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
17. }
18. }
19. bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
20. }
21. else {
22. // Fail if we're already creating this bean instance:
23. // We're assumably within a circular reference.
24. if (isPrototypeCurrentlyInCreation(beanName)) {
25. throw new BeanCurrentlyInCreationException(beanName);
26. }
27. // Check if bean definition exists in this factory.
28. BeanFactory parentBeanFactory = getParentBeanFactory();
29. if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
30. // Not found -> check parent.
31. String nameToLookup = originalBeanName(name);
32. if (args != null) {
33. // Delegation to parent with explicit args.
34. return (T) parentBeanFactory.getBean(nameToLookup, args);
35. }
36. else {
37. // No args -> delegate to standard getBean method.
38. return parentBeanFactory.getBean(nameToLookup, requiredType);
39. }
40. }
41. if (!typeCheckOnly) {
42. markBeanAsCreated(beanName);
43. }
44. final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
45. checkMergedBeanDefinition(mbd, beanName, args);
46. // Guarantee initialization of beans that the current bean depends on.
47. String[] dependsOn = mbd.getDependsOn();
48. if (dependsOn != null) {
49. for (String dependsOnBean : dependsOn) {
50. getBean(dependsOnBean);
51. registerDependentBean(dependsOnBean, beanName);
52. }
53. }
54. // Create bean instance.
55. if (mbd.isSingleton()) {
56. sharedInstance = getSingleton(beanName, new ObjectFactory() {
57. public Object getObject() throws BeansException {
58. try {
59. return createBean(beanName, mbd, args);
60. }
61. catch (BeansException ex) {
62. // Explicitly remove instance from singleton cache: It might have been put there
63. // eagerly by the creation process, to allow for circular reference resolution.
64. // Also remove any beans that received a temporary reference to the bean.
65. destroySingleton(beanName);
66. throw ex;
67. }
68. }
69. });
70. bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
71. }
72. else if (mbd.isPrototype()) {
73. // It's a prototype -> create a new instance.
74. Object prototypeInstance = null;
75. try {
76. beforePrototypeCreation(beanName);
77. prototypeInstance = createBean(beanName, mbd, args);
78. }
79. finally {
80. afterPrototypeCreation(beanName);
81. }
82. bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
83. }
84. else {
85. String scopeName = mbd.getScope();
86. final Scope scope = this.scopes.get(scopeName);
87. if (scope == null) {
88. throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
89. }
90. try {
91. Object scopedInstance = scope.get(beanName, new ObjectFactory() {
92. public Object getObject() throws BeansException {
93. beforePrototypeCreation(beanName);
94. try {
95. return createBean(beanName, mbd, args);
96. }
97. finally {
98. afterPrototypeCreation(beanName);
99. }
100. }
101. });
102. bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
103. }
104. catch (IllegalStateException ex) {
105. throw new BeanCreationException(beanName,
106. "Scope '" + scopeName + "' is not active for the current thread; " +
107. "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
108. ex);
109. }
110. }
111. }
112. // Check if required type matches the type of the actual bean instance.
113. if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
114. throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
115. }
116. return (T) bean;
117. }

看这个代码英文注释就明白了

1、Eagerly check singleton cache for manually registered singletons.

2、Check if bean definition exists in this factory.Not found -> check parent.（当前BeanFactory不存在，则通过递归，向上寻找。parentBeanFactory是XmlBeanFactory的成员变量。）

3、Guarantee initialization of beans that the current bean depends on.（生成依赖bean）

4、Create bean instance.（创建bean）(创建bean的过程会查看是singleton还是prototype，如果是singleton是单例模式，只会被创建一次，prototype则每次getBean相当于new一次。代码中首先通过Object sharedInstance = getSingleton(beanName);根据bean名称获取单例对象，若为空再创建);

1. @Override
2. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
3. throws BeanCreationException {
4. if (logger.isDebugEnabled()) {
5. logger.debug("Creating instance of bean '" + beanName + "'");
6. }
7. // Make sure bean class is actually resolved at this point.
8. resolveBeanClass(mbd, beanName);
9. // Prepare method overrides.
10. try {
11. mbd.prepareMethodOverrides();
12. }
13. catch (BeanDefinitionValidationException ex) {
14. throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
15. beanName, "Validation of method overrides failed", ex);
16. }
17. try {
18. // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
19. Object bean = resolveBeforeInstantiation(beanName, mbd);
20. if (bean != null) {
21. return bean;
22. }
23. }
24. catch (Throwable ex) {
25. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
26. "BeanPostProcessor before instantiation of bean failed", ex);
27. }
28. Object beanInstance = doCreateBean(beanName, mbd, args);
29. if (logger.isDebugEnabled()) {
30. logger.debug("Finished creating instance of bean '" + beanName + "'");
31. }
32. return beanInstance;
33. }

通过注解理解其意义：

// Make sure bean class is actually resolved at this point.（确保bean类此时已被分解）
resolveBeanClass(mbd, beanName);

// Prepare method overrides.（准备实现接口的方法）

mbd.prepareMethodOverrides();

// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.（如果可能的话，返回一个代理而不是实例的对象）
Object bean = resolveBeforeInstantiation(beanName, mbd);

最后这里才是真正核心的实例化bean的方法：

Object beanInstance = doCreateBean(beanName, mbd, args);

doCreateBean中有两个重要的方法，一个是createBeanInstance，用于实例化bean。

另一个是这句populateBean(beanName, mbd, instanceWrapper);这个方法用于依赖关系的处理过程。

1. /**
2. * Actually create the specified bean. Pre-creation processing has already happened
3. * at this point, e.g. checking <code>postProcessBeforeInstantiation</code> callbacks.
4. * <p>Differentiates between default bean instantiation, use of a
5. * factory method, and autowiring a constructor.
6. * @param beanName the name of the bean
7. * @param mbd the merged bean definition for the bean
8. * @param args arguments to use if creating a prototype using explicit arguments to a
9. * static factory method. This parameter must be <code>null</code> except in this case.
10. * @return a new instance of the bean
11. * @throws BeanCreationException if the bean could not be created
12. * @see #instantiateBean
13. * @see #instantiateUsingFactoryMethod
14. * @see #autowireConstructor
15. */
16. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
17. // Instantiate the bean.
18. BeanWrapper instanceWrapper = null;
19. if (mbd.isSingleton()) {
20. instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
21. }
22. if (instanceWrapper == null) {
23. instanceWrapper = createBeanInstance(beanName, mbd, args);
24. }
25. final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
26. Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
27. // Allow post-processors to modify the merged bean definition.
28. synchronized (mbd.postProcessingLock) {
29. if (!mbd.postProcessed) {
30. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
31. mbd.postProcessed = true;
32. }
33. }
34. // Eagerly cache singletons to be able to resolve circular references
35. // even when triggered by lifecycle interfaces like BeanFactoryAware.
36. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
37. isSingletonCurrentlyInCreation(beanName));
38. if (earlySingletonExposure) {
39. if (logger.isDebugEnabled()) {
40. logger.debug("Eagerly caching bean '" + beanName +
41. "' to allow for resolving potential circular references");
42. }
43. addSingletonFactory(beanName, new ObjectFactory() {
44. public Object getObject() throws BeansException {
45. return getEarlyBeanReference(beanName, mbd, bean);
46. }
47. });
48. }
49. // Initialize the bean instance.
50. Object exposedObject = bean;
51. try {
52. populateBean(beanName, mbd, instanceWrapper);
53. if (exposedObject != null) {
54. exposedObject = initializeBean(beanName, exposedObject, mbd);
55. }
56. }
57. catch (Throwable ex) {
58. if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
59. throw (BeanCreationException) ex;
60. }
61. else {
62. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
63. }
64. }
65. if (earlySingletonExposure) {
66. Object earlySingletonReference = getSingleton(beanName, false);
67. if (earlySingletonReference != null) {
68. if (exposedObject == bean) {
69. exposedObject = earlySingletonReference;
70. }
71. else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
72. String[] dependentBeans = getDependentBeans(beanName);
73. Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
74. for (String dependentBean : dependentBeans) {
75. if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
76. actualDependentBeans.add(dependentBean);
77. }
78. }
79. if (!actualDependentBeans.isEmpty()) {
80. throw new BeanCurrentlyInCreationException(beanName,
81. "Bean with name '" + beanName + "' has been injected into other beans [" +
82. StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
83. "] in its raw version as part of a circular reference, but has eventually been " +
84. "wrapped. This means that said other beans do not use the final version of the " +
85. "bean. This is often the result of over-eager type matching - consider using " +
86. "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
87. }
88. }
89. }
90. }
91. // Register bean as disposable.
92. try {
93. registerDisposableBeanIfNecessary(beanName, bean, mbd);
94. }
95. catch (BeanDefinitionValidationException ex) {
96. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
97. }
98. return exposedObject;
99. }

这里面createBeanInstance方法用于实例化bean。下面可以看到实例化的bean的方式不止一种，有工厂方法方式，也有构造方法方式。主要根据BeanDefinition中的信息。

1. /**
2. * Create a new instance for the specified bean, using an appropriate instantiation strategy:
3. * factory method, constructor autowiring, or simple instantiation.
4. * @param beanName the name of the bean
5. * @param mbd the bean definition for the bean
6. * @param args arguments to use if creating a prototype using explicit arguments to a
7. * static factory method. It is invalid to use a non-null args value in any other case.
8. * @return BeanWrapper for the new instance
9. * @see #instantiateUsingFactoryMethod
10. * @see #autowireConstructor
11. * @see #instantiateBean
12. */
13. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
14. // Make sure bean class is actually resolved at this point.
15. Class beanClass = resolveBeanClass(mbd, beanName);
16. if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
17. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
18. "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
19. }
20. if (mbd.getFactoryMethodName() != null)  {
21. return instantiateUsingFactoryMethod(beanName, mbd, args);
22. }
23. // Shortcut when re-creating the same bean...
24. boolean resolved = false;
25. boolean autowireNecessary = false;
26. if (args == null) {
27. synchronized (mbd.constructorArgumentLock) {
28. if (mbd.resolvedConstructorOrFactoryMethod != null) {
29. resolved = true;
30. autowireNecessary = mbd.constructorArgumentsResolved;
31. }
32. }
33. }
34. if (resolved) {
35. if (autowireNecessary) {
36. return autowireConstructor(beanName, mbd, null, null);
37. }
38. else {
39. return instantiateBean(beanName, mbd);
40. }
41. }
42. // Need to determine the constructor...
43. Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
44. if (ctors != null ||
45. mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
46. mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
47. return autowireConstructor(beanName, mbd, ctors, args);
48. }
49. // No special handling: simply use no-arg constructor.
50. return instantiateBean(beanName, mbd);
51. }

工厂方法模式：

1. /**
2. * Instantiate the bean using a named factory method. The method may be static, if the
3. * bean definition parameter specifies a class, rather than a "factory-bean", or
4. * an instance variable on a factory object itself configured using Dependency Injection.
5. * <p>Implementation requires iterating over the static or instance methods with the
6. * name specified in the RootBeanDefinition (the method may be overloaded) and trying
7. * to match with the parameters. We don't have the types attached to constructor args,
8. * so trial and error is the only way to go here. The explicitArgs array may contain
9. * argument values passed in programmatically via the corresponding getBean method.
10. * @param beanName the name of the bean
11. * @param mbd the merged bean definition for the bean
12. * @param explicitArgs argument values passed in programmatically via the getBean
13. * method, or <code>null</code> if none (-> use constructor argument values from bean definition)
14. * @return a BeanWrapper for the new instance
15. */
16. public BeanWrapper instantiateUsingFactoryMethod(final String beanName, final RootBeanDefinition mbd, final Object[] explicitArgs) {
17. BeanWrapperImpl bw = new BeanWrapperImpl();
18. this.beanFactory.initBeanWrapper(bw);
19. Object factoryBean;
20. Class factoryClass;
21. boolean isStatic;
22. String factoryBeanName = mbd.getFactoryBeanName();
23. if (factoryBeanName != null) {
24. if (factoryBeanName.equals(beanName)) {
25. throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
26. "factory-bean reference points back to the same bean definition");
27. }
28. factoryBean = this.beanFactory.getBean(factoryBeanName);
29. if (factoryBean == null) {
30. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
31. "factory-bean '" + factoryBeanName + "' returned null");
32. }
33. factoryClass = factoryBean.getClass();
34. isStatic = false;
35. }
36. else {
37. // It's a static factory method on the bean class.
38. if (!mbd.hasBeanClass()) {
39. throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
40. "bean definition declares neither a bean class nor a factory-bean reference");
41. }
42. factoryBean = null;
43. factoryClass = mbd.getBeanClass();
44. isStatic = true;
45. }
46. Method factoryMethodToUse = null;
47. ArgumentsHolder argsHolderToUse = null;
48. Object[] argsToUse = null;
49. if (explicitArgs != null) {
50. argsToUse = explicitArgs;
51. }
52. else {
53. Object[] argsToResolve = null;
54. synchronized (mbd.constructorArgumentLock) {
55. factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
56. if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
57. // Found a cached factory method...
58. argsToUse = mbd.resolvedConstructorArguments;
59. if (argsToUse == null) {
60. argsToResolve = mbd.preparedConstructorArguments;
61. }
62. }
63. }
64. if (argsToResolve != null) {
65. argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
66. }
67. }
68. if (factoryMethodToUse == null || argsToUse == null) {
69. // Need to determine the factory method...
70. // Try all methods with this name to see if they match the given arguments.
71. factoryClass = ClassUtils.getUserClass(factoryClass);
72. Method[] rawCandidates;
73. final Class factoryClazz = factoryClass;
74. if (System.getSecurityManager() != null) {
75. rawCandidates = AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
76. public Method[] run() {
77. return (mbd.isNonPublicAccessAllowed() ?
78. ReflectionUtils.getAllDeclaredMethods(factoryClazz) : factoryClazz.getMethods());
79. }
80. });
81. }
82. else {
83. rawCandidates = (mbd.isNonPublicAccessAllowed() ?
84. ReflectionUtils.getAllDeclaredMethods(factoryClazz) : factoryClazz.getMethods());
85. }
86. List<Method> candidateSet = new ArrayList<Method>();
87. for (Method candidate : rawCandidates) {
88. if (Modifier.isStatic(candidate.getModifiers()) == isStatic &&
89. candidate.getName().equals(mbd.getFactoryMethodName()) &&
90. mbd.isFactoryMethod(candidate)) {
91. candidateSet.add(candidate);
92. }
93. }
94. Method[] candidates = candidateSet.toArray(new Method[candidateSet.size()]);
95. AutowireUtils.sortFactoryMethods(candidates);
96. ConstructorArgumentValues resolvedValues = null;
97. boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
98. int minTypeDiffWeight = Integer.MAX_VALUE;
99. Set<Method> ambiguousFactoryMethods = null;
100. int minNrOfArgs;
101. if (explicitArgs != null) {
102. minNrOfArgs = explicitArgs.length;
103. }
104. else {
105. // We don't have arguments passed in programmatically, so we need to resolve the
106. // arguments specified in the constructor arguments held in the bean definition.
107. ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
108. resolvedValues = new ConstructorArgumentValues();
109. minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
110. }
111. List<Exception> causes = null;
112. for (int i = 0; i < candidates.length; i++) {
113. Method candidate = candidates[i];
114. Class[] paramTypes = candidate.getParameterTypes();
115. if (paramTypes.length >= minNrOfArgs) {
116. ArgumentsHolder argsHolder;
117. if (resolvedValues != null) {
118. // Resolved constructor arguments: type conversion and/or autowiring necessary.
119. try {
120. String[] paramNames = null;
121. ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
122. if (pnd != null) {
123. paramNames = pnd.getParameterNames(candidate);
124. }
125. argsHolder = createArgumentArray(
126. beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
127. }
128. catch (UnsatisfiedDependencyException ex) {
129. if (this.beanFactory.logger.isTraceEnabled()) {
130. this.beanFactory.logger.trace("Ignoring factory method [" + candidate +
131. "] of bean '" + beanName + "': " + ex);
132. }
133. if (i == candidates.length - 1 && argsHolderToUse == null) {
134. if (causes != null) {
135. for (Exception cause : causes) {
136. this.beanFactory.onSuppressedException(cause);
137. }
138. }
139. throw ex;
140. }
141. else {
142. // Swallow and try next overloaded factory method.
143. if (causes == null) {
144. causes = new LinkedList<Exception>();
145. }
146. causes.add(ex);
147. continue;
148. }
149. }
150. }
151. else {
152. // Explicit arguments given -> arguments length must match exactly.
153. if (paramTypes.length != explicitArgs.length) {
154. continue;
155. }
156. argsHolder = new ArgumentsHolder(explicitArgs);
157. }
158. int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
159. argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
160. // Choose this factory method if it represents the closest match.
161. if (typeDiffWeight < minTypeDiffWeight) {
162. factoryMethodToUse = candidate;
163. argsHolderToUse = argsHolder;
164. argsToUse = argsHolder.arguments;
165. minTypeDiffWeight = typeDiffWeight;
166. ambiguousFactoryMethods = null;
167. }
168. else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight) {
169. if (ambiguousFactoryMethods == null) {
170. ambiguousFactoryMethods = new LinkedHashSet<Method>();
171. ambiguousFactoryMethods.add(factoryMethodToUse);
172. }
173. ambiguousFactoryMethods.add(candidate);
174. }
175. }
176. }
177. if (factoryMethodToUse == null) {
178. boolean hasArgs = (resolvedValues.getArgumentCount() > 0);
179. String argDesc = "";
180. if (hasArgs) {
181. List<String> argTypes = new ArrayList<String>();
182. for (ValueHolder value : resolvedValues.getIndexedArgumentValues().values()) {
183. String argType = (value.getType() != null ?
184. ClassUtils.getShortName(value.getType()) : value.getValue().getClass().getSimpleName());
185. argTypes.add(argType);
186. }
187. argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
188. }
189. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
190. "No matching factory method found: " +
191. (mbd.getFactoryBeanName() != null ?
192. "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
193. "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
194. "Check that a method with the specified name " +
195. (hasArgs ? "and arguments " : "") +
196. "exists and that it is " +
197. (isStatic ? "static" : "non-static") + ".");
198. }
199. else if (void.class.equals(factoryMethodToUse.getReturnType())) {
200. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
201. "Invalid factory method '" + mbd.getFactoryMethodName() +
202. "': needs to have a non-void return type!");
203. }
204. else if (ambiguousFactoryMethods != null && !mbd.isLenientConstructorResolution()) {
205. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
206. "Ambiguous factory method matches found in bean '" + beanName + "' " +
207. "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
208. ambiguousFactoryMethods);
209. }
210. if (explicitArgs == null && argsHolderToUse != null) {
211. argsHolderToUse.storeCache(mbd, factoryMethodToUse);
212. }
213. }
214. try {
215. Object beanInstance;
216. if (System.getSecurityManager() != null) {
217. final Object fb = factoryBean;
218. final Method factoryMethod = factoryMethodToUse;
219. final Object[] args = argsToUse;
220. beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
221. public Object run() {
222. return beanFactory.getInstantiationStrategy().instantiate(
223. mbd, beanName, beanFactory, fb, factoryMethod, args);
224. }
225. }, beanFactory.getAccessControlContext());
226. }
227. else {
228. beanInstance = beanFactory.getInstantiationStrategy().instantiate(
229. mbd, beanName, beanFactory, factoryBean, factoryMethodToUse, argsToUse);
230. }
231. if (beanInstance == null) {
232. return null;
233. }
234. bw.setWrappedInstance(beanInstance);
235. return bw;
236. }
237. catch (Throwable ex) {
238. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
239. }
240. }

构造函数方式：

1. /**
2. * "autowire constructor" (with constructor arguments by type) behavior.
3. * Also applied if explicit constructor argument values are specified,
4. * matching all remaining arguments with beans from the bean factory.
5. * <p>This corresponds to constructor injection: In this mode, a Spring
6. * bean factory is able to host components that expect constructor-based
7. * dependency resolution.
8. * @param beanName the name of the bean
9. * @param mbd the merged bean definition for the bean
10. * @param chosenCtors chosen candidate constructors (or <code>null</code> if none)
11. * @param explicitArgs argument values passed in programmatically via the getBean method,
12. * or <code>null</code> if none (-> use constructor argument values from bean definition)
13. * @return a BeanWrapper for the new instance
14. */
15. public BeanWrapper autowireConstructor(
16. final String beanName, final RootBeanDefinition mbd, Constructor[] chosenCtors, final Object[] explicitArgs) {
17. BeanWrapperImpl bw = new BeanWrapperImpl();
18. this.beanFactory.initBeanWrapper(bw);
19. Constructor constructorToUse = null;
20. ArgumentsHolder argsHolderToUse = null;
21. Object[] argsToUse = null;
22. if (explicitArgs != null) {
23. argsToUse = explicitArgs;
24. }
25. else {
26. Object[] argsToResolve = null;
27. synchronized (mbd.constructorArgumentLock) {
28. constructorToUse = (Constructor) mbd.resolvedConstructorOrFactoryMethod;
29. if (constructorToUse != null && mbd.constructorArgumentsResolved) {
30. // Found a cached constructor...
31. argsToUse = mbd.resolvedConstructorArguments;
32. if (argsToUse == null) {
33. argsToResolve = mbd.preparedConstructorArguments;
34. }
35. }
36. }
37. if (argsToResolve != null) {
38. argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
39. }
40. }
41. if (constructorToUse == null) {
42. // Need to resolve the constructor.
43. boolean autowiring = (chosenCtors != null ||
44. mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
45. ConstructorArgumentValues resolvedValues = null;
46. int minNrOfArgs;
47. if (explicitArgs != null) {
48. minNrOfArgs = explicitArgs.length;
49. }
50. else {
51. ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
52. resolvedValues = new ConstructorArgumentValues();
53. minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
54. }
55. // Take specified constructors, if any.
56. Constructor[] candidates = chosenCtors;
57. if (candidates == null) {
58. Class beanClass = mbd.getBeanClass();
59. try {
60. candidates = (mbd.isNonPublicAccessAllowed() ?
61. beanClass.getDeclaredConstructors() : beanClass.getConstructors());
62. }
63. catch (Throwable ex) {
64. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
65. "Resolution of declared constructors on bean Class [" + beanClass.getName() +
66. "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
67. }
68. }
69. AutowireUtils.sortConstructors(candidates);
70. int minTypeDiffWeight = Integer.MAX_VALUE;
71. Set<Constructor> ambiguousConstructors = null;
72. List<Exception> causes = null;
73. for (int i = 0; i < candidates.length; i++) {
74. Constructor<?> candidate = candidates[i];
75. Class[] paramTypes = candidate.getParameterTypes();
76. if (constructorToUse != null && argsToUse.length > paramTypes.length) {
77. // Already found greedy constructor that can be satisfied ->
78. // do not look any further, there are only less greedy constructors left.
79. break;
80. }
81. if (paramTypes.length < minNrOfArgs) {
82. continue;
83. }
84. ArgumentsHolder argsHolder;
85. if (resolvedValues != null) {
86. try {
87. String[] paramNames = null;
88. if (constructorPropertiesAnnotationAvailable) {
89. paramNames = ConstructorPropertiesChecker.evaluateAnnotation(candidate, paramTypes.length);
90. }
91. if (paramNames == null) {
92. ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
93. if (pnd != null) {
94. paramNames = pnd.getParameterNames(candidate);
95. }
96. }
97. argsHolder = createArgumentArray(
98. beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
99. }
100. catch (UnsatisfiedDependencyException ex) {
101. if (this.beanFactory.logger.isTraceEnabled()) {
102. this.beanFactory.logger.trace(
103. "Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
104. }
105. if (i == candidates.length - 1 && constructorToUse == null) {
106. if (causes != null) {
107. for (Exception cause : causes) {
108. this.beanFactory.onSuppressedException(cause);
109. }
110. }
111. throw ex;
112. }
113. else {
114. // Swallow and try next constructor.
115. if (causes == null) {
116. causes = new LinkedList<Exception>();
117. }
118. causes.add(ex);
119. continue;
120. }
121. }
122. }
123. else {
124. // Explicit arguments given -> arguments length must match exactly.
125. if (paramTypes.length != explicitArgs.length) {
126. continue;
127. }
128. argsHolder = new ArgumentsHolder(explicitArgs);
129. }
130. int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
131. argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
132. // Choose this constructor if it represents the closest match.
133. if (typeDiffWeight < minTypeDiffWeight) {
134. constructorToUse = candidate;
135. argsHolderToUse = argsHolder;
136. argsToUse = argsHolder.arguments;
137. minTypeDiffWeight = typeDiffWeight;
138. ambiguousConstructors = null;
139. }
140. else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
141. if (ambiguousConstructors == null) {
142. ambiguousConstructors = new LinkedHashSet<Constructor>();
143. ambiguousConstructors.add(constructorToUse);
144. }
145. ambiguousConstructors.add(candidate);
146. }
147. }
148. if (constructorToUse == null) {
149. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
150. "Could not resolve matching constructor " +
151. "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
152. }
153. else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
154. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
155. "Ambiguous constructor matches found in bean '" + beanName + "' " +
156. "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
157. ambiguousConstructors);
158. }
159. if (explicitArgs == null) {
160. argsHolderToUse.storeCache(mbd, constructorToUse);
161. }
162. }
163. try {
164. Object beanInstance;
165. if (System.getSecurityManager() != null) {
166. final Constructor ctorToUse = constructorToUse;
167. final Object[] argumentsToUse = argsToUse;
168. beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
169. public Object run() {
170. return beanFactory.getInstantiationStrategy().instantiate(
171. mbd, beanName, beanFactory, ctorToUse, argumentsToUse);
172. }
173. }, beanFactory.getAccessControlContext());
174. }
175. else {
176. beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
177. mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
178. }
179. bw.setWrappedInstance(beanInstance);
180. return bw;
181. }
182. catch (Throwable ex) {
183. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
184. }
185. }

采用默认构造函数方式（这也是spring默认的形式）主要看看这个的代码：

1. /**
2. * Instantiate the given bean using its default constructor.
3. * @param beanName the name of the bean
4. * @param mbd the bean definition for the bean
5. * @return BeanWrapper for the new instance
6. */
7. protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
8. try {
9. Object beanInstance;
10. final BeanFactory parent = this;
11. if (System.getSecurityManager() != null) {
12. beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
13. public Object run() {
14. return getInstantiationStrategy().instantiate(mbd, beanName, parent);
15. }
16. }, getAccessControlContext());
17. }
18. else {
19. beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
20. }
21. BeanWrapper bw = new BeanWrapperImpl(beanInstance);
22. initBeanWrapper(bw);
23. return bw;
24. }
25. catch (Throwable ex) {
26. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
27. }
28. }

继续跟踪比较核心的getInstantiationStrategy().instantiate(mbd, beanName, parent)：

1. /**
2. * Simple object instantiation strategy for use in a BeanFactory.
3. *
4. * <p>Does not support Method Injection, although it provides hooks for subclasses
5. * to override to add Method Injection support, for example by overriding methods.
6. *
7. * @author Rod Johnson
8. * @author Juergen Hoeller
9. * @since 1.1
10. */
11. public class SimpleInstantiationStrategy implements InstantiationStrategy {
12. public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
13. // Don't override the class with CGLIB if no overrides.
14. if (beanDefinition.getMethodOverrides().isEmpty()) {
15. Constructor<?> constructorToUse;
16. synchronized (beanDefinition.constructorArgumentLock) {
17. constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
18. if (constructorToUse == null) {
19. final Class clazz = beanDefinition.getBeanClass();
20. if (clazz.isInterface()) {
21. throw new BeanInstantiationException(clazz, "Specified class is an interface");
22. }
23. try {
24. if (System.getSecurityManager() != null) {
25. constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
26. public Constructor run() throws Exception {
27. return clazz.getDeclaredConstructor((Class[]) null);
28. }
29. });
30. }
31. else {
32. constructorToUse =  clazz.getDeclaredConstructor((Class[]) null);
33. }
34. beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
35. }
36. catch (Exception ex) {
37. throw new BeanInstantiationException(clazz, "No default constructor found", ex);
38. }
39. }
40. }
41. return BeanUtils.instantiateClass(constructorToUse);
42. }
43. else {
44. // Must generate CGLIB subclass.
45. return instantiateWithMethodInjection(beanDefinition, beanName, owner);
46. }
47. }

最后一句return instantiateWithMethodInjection(beanDefinition, beanName, owner);便是采用CGLIB的方式。上面的代码BeanUtils.instantiateClass(constructorToUse);是使用构造器或生成对象的工厂方法来实例化。

cglib代码包结构

（是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。Hibernate用它来实现PO(Persistent Object 持久化对象)字节码的动态生成。）

• core (核心代码)
  • EmitUtils
  • ReflectUtils
  • KeyFactory
  • ClassEmitter/CodeEmitter
  • NamingPolicy/DefaultNamingPolicy
  • GeneratorStrategy/DefaultGeneratorStrategy
  • DebuggingClassWriter
  • ClassGenerator/AbstractClassGenerator
• beans (bean操作类)
  • BeanCopier
  • BulkBean
  • BeanMap
  • ImmutableBean
  • BeanGenerator
• reflect
  • FastClass
• proxy
  • MethodInterceptor , Dispatcher, LazyLoader , ProxyRefDispatcher , NoOp , FixedValue , InvocationHandler(提供和jdk proxy的功能)
  • Enhancer
  • CallbackGenerator
  • Callback
  • CallbackFilter
• util
  • StringSwitcher
  • ParallelSorter
• transform

继续跟踪具体的cglib实例化bean的代码：

1. /**
2. * Create a new instance of a dynamically generated subclasses implementing the
3. * required lookups.
4. * @param ctor constructor to use. If this is <code>null</code>, use the
5. * no-arg constructor (no parameterization, or Setter Injection)
6. * @param args arguments to use for the constructor.
7. * Ignored if the ctor parameter is <code>null</code>.
8. * @return new instance of the dynamically generated class
9. */
10. public Object instantiate(Constructor ctor, Object[] args) {
11. Enhancer enhancer = new Enhancer();
12. enhancer.setSuperclass(this.beanDefinition.getBeanClass());
13. enhancer.setCallbackFilter(new CallbackFilterImpl());
14. enhancer.setCallbacks(new Callback[] {
15. NoOp.INSTANCE,
16. new LookupOverrideMethodInterceptor(),
17. new ReplaceOverrideMethodInterceptor()
18. });
19. return (ctor == null) ?
20. enhancer.create() :
21. enhancer.create(ctor.getParameterTypes(), args);
22. }

跟踪一下BeanUtils.instantiateClass(constructorToUse);

1. /**
2. * Convenience method to instantiate a class using the given constructor.
3. * As this method doesn't try to load classes by name, it should avoid
4. * class-loading issues.
5. * <p>Note that this method tries to set the constructor accessible
6. * if given a non-accessible (that is, non-public) constructor.
7. * @param ctor the constructor to instantiate
8. * @param args the constructor arguments to apply
9. * @return the new instance
10. * @throws BeanInstantiationException if the bean cannot be instantiated
11. */
12. public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
13. Assert.notNull(ctor, "Constructor must not be null");
14. try {
15. ReflectionUtils.makeAccessible(ctor);
16. return ctor.newInstance(args);
17. }
18. catch (InstantiationException ex) {
19. throw new BeanInstantiationException(ctor.getDeclaringClass(),
20. "Is it an abstract class?", ex);
21. }
22. catch (IllegalAccessException ex) {
23. throw new BeanInstantiationException(ctor.getDeclaringClass(),
24. "Is the constructor accessible?", ex);
25. }
26. catch (IllegalArgumentException ex) {
27. throw new BeanInstantiationException(ctor.getDeclaringClass(),
28. "Illegal arguments for constructor", ex);
29. }
30. catch (InvocationTargetException ex) {
31. throw new BeanInstantiationException(ctor.getDeclaringClass(),
32. "Constructor threw exception", ex.getTargetException());
33. }
34. }

用到了Reflection类，是使用了反射。

1. /**
2. * Uses the constructor represented by this {@code Constructor} object to
3. * create and initialize a new instance of the constructor's
4. * declaring class, with the specified initialization parameters.
5. * Individual parameters are automatically unwrapped to match
6. * primitive formal parameters, and both primitive and reference
7. * parameters are subject to method invocation conversions as necessary.
8. *
9. * <p>If the number of formal parameters required by the underlying constructor
10. * is 0, the supplied {@code initargs} array may be of length 0 or null.
11. *
12. * <p>If the constructor's declaring class is an inner class in a
13. * non-static context, the first argument to the constructor needs
14. * to be the enclosing instance; see section 15.9.3 of
15. * <cite>The Java™ Language Specification</cite>.
16. *
17. * <p>If the required access and argument checks succeed and the
18. * instantiation will proceed, the constructor's declaring class
19. * is initialized if it has not already been initialized.
20. *
21. * <p>If the constructor completes normally, returns the newly
22. * created and initialized instance.
23. *
24. * @param initargs array of objects to be passed as arguments to
25. * the constructor call; values of primitive types are wrapped in
26. * a wrapper object of the appropriate type (e.g. a {@code float}
27. * in a {@link java.lang.Float Float})
28. *
29. * @return a new object created by calling the constructor
30. * this object represents
31. *
32. * @exception IllegalAccessException    if this {@code Constructor} object
33. *              is enforcing Java language access control and the underlying
34. *              constructor is inaccessible.
35. * @exception IllegalArgumentException  if the number of actual
36. *              and formal parameters differ; if an unwrapping
37. *              conversion for primitive arguments fails; or if,
38. *              after possible unwrapping, a parameter value
39. *              cannot be converted to the corresponding formal
40. *              parameter type by a method invocation conversion; if
41. *              this constructor pertains to an enum type.
42. * @exception InstantiationException    if the class that declares the
43. *              underlying constructor represents an abstract class.
44. * @exception InvocationTargetException if the underlying constructor
45. *              throws an exception.
46. * @exception ExceptionInInitializerError if the initialization provoked
47. *              by this method fails.
48. */
49. @CallerSensitive
50. public T newInstance(Object ... initargs)
51. throws InstantiationException, IllegalAccessException,
52. IllegalArgumentException, InvocationTargetException
53. {
54. if (!override) {
55. if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
56. Class<?> caller = Reflection.getCallerClass();
57. checkAccess(caller, clazz, null, modifiers);
58. }
59. }
60. if ((clazz.getModifiers() & Modifier.ENUM) != 0)
61. throw new IllegalArgumentException("Cannot reflectively create enum objects");
62. ConstructorAccessor ca = constructorAccessor;   // read volatile
63. if (ca == null) {
64. ca = acquireConstructorAccessor();
65. }
66. return (T) ca.newInstance(initargs);
67. }

之后终于看到了populateBean这个方法，之前也说过，这是用来处理依赖关系的。在AbstractAutowireCapableBeanFactory类中：

1. /**
2. * Populate the bean instance in the given BeanWrapper with the property values
3. * from the bean definition.
4. * @param beanName the name of the bean
5. * @param mbd the bean definition for the bean
6. * @param bw BeanWrapper with bean instance
7. */
8. protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
9. PropertyValues pvs = mbd.getPropertyValues();
10. if (bw == null) {
11. if (!pvs.isEmpty()) {
12. throw new BeanCreationException(
13. mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
14. }
15. else {
16. // Skip property population phase for null instance.
17. return;
18. }
19. }
20. // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
21. // state of the bean before properties are set. This can be used, for example,
22. // to support styles of field injection.
23. boolean continueWithPropertyPopulation = true;
24. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
25. for (BeanPostProcessor bp : getBeanPostProcessors()) {
26. if (bp instanceof InstantiationAwareBeanPostProcessor) {
27. InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
28. if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
29. continueWithPropertyPopulation = false;
30. break;
31. }
32. }
33. }
34. }
35. if (!continueWithPropertyPopulation) {
36. return;
37. }
38. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
39. mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
40. MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
41. // Add property values based on autowire by name if applicable.
42. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
43. autowireByName(beanName, mbd, bw, newPvs);
44. }
45. // Add property values based on autowire by type if applicable.
46. if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
47. autowireByType(beanName, mbd, bw, newPvs);
48. }
49. pvs = newPvs;
50. }
51. boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
52. boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
53. if (hasInstAwareBpps || needsDepCheck) {
54. PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);
55. if (hasInstAwareBpps) {
56. for (BeanPostProcessor bp : getBeanPostProcessors()) {
57. if (bp instanceof InstantiationAwareBeanPostProcessor) {
58. InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
59. pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
60. if (pvs == null) {
61. return;
62. }
63. }
64. }
65. }
66. if (needsDepCheck) {
67. checkDependencies(beanName, mbd, filteredPds, pvs);
68. }
69. }
70. applyPropertyValues(beanName, mbd, bw, pvs);
71. }

设断点单步跟踪，可知PropertyValues pvs = mbd.getPropertyValues();这句是获取该bean的所有属性。

真正核心的是最后这句，其中PropertyValues pvs作为其参数：

1. /**
2. * Apply the given property values, resolving any runtime references
3. * to other beans in this bean factory. Must use deep copy, so we
4. * don't permanently modify this property.
5. * @param beanName the bean name passed for better exception information
6. * @param mbd the merged bean definition
7. * @param bw the BeanWrapper wrapping the target object
8. * @param pvs the new property values
9. */
10. protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
11. if (pvs == null || pvs.isEmpty()) {
12. return;
13. }
14. MutablePropertyValues mpvs = null;
15. List<PropertyValue> original;
16. if (System.getSecurityManager()!= null) {
17. if (bw instanceof BeanWrapperImpl) {
18. ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
19. }
20. }
21. if (pvs instanceof MutablePropertyValues) {
22. mpvs = (MutablePropertyValues) pvs;
23. if (mpvs.isConverted()) {
24. // Shortcut: use the pre-converted values as-is.
25. try {
26. bw.setPropertyValues(mpvs);
27. return;
28. }
29. catch (BeansException ex) {
30. throw new BeanCreationException(
31. mbd.getResourceDescription(), beanName, "Error setting property values", ex);
32. }
33. }
34. original = mpvs.getPropertyValueList();
35. }
36. else {
37. original = Arrays.asList(pvs.getPropertyValues());
38. }
39. TypeConverter converter = getCustomTypeConverter();
40. if (converter == null) {
41. converter = bw;
42. }
43. BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
44. // Create a deep copy, resolving any references for values.
45. List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
46. boolean resolveNecessary = false;
47. for (PropertyValue pv : original) {
48. if (pv.isConverted()) {
49. deepCopy.add(pv);
50. }
51. else {
52. String propertyName = pv.getName();
53. Object originalValue = pv.getValue();
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. // Set our (possibly massaged) deep copy.
85. try {
86. bw.setPropertyValues(new MutablePropertyValues(deepCopy));
87. }
88. catch (BeansException ex) {
89. throw new BeanCreationException(
90. mbd.getResourceDescription(), beanName, "Error setting property values", ex);
91. }
92. }
93. /**
94. * Convert the given value for the specified target property.
95. */
96. private Object convertForProperty(Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
97. if (converter instanceof BeanWrapperImpl) {
98. return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
99. }
100. else {
101. PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
102. MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
103. return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
104. }
105. }

这个方法很长，其内在逻辑却也不难。主要是对传进来的PropertyValues pvs参数的每一项做一个解析过程，而BeanWrapper bw参数包装着前面实例化的bean实例对象。

而BeanDefinition mbd这个参数，也就是BeanDefinition，在这里只用于抛出异常信息，没什么大用。

看代码for (PropertyValue pv : original) {}循环遍历PropertyValues，循环过程解析每一个字段：Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue)，最后bw.setPropertyValues(new MutablePropertyValues(deepCopy));这句将之前得到的结果set进我们要处理的实例化对象;

1. /**
2. * Given a PropertyValue, return a value, resolving any references to other
3. * beans in the factory if necessary. The value could be:
4. * <li>A BeanDefinition, which leads to the creation of a corresponding
5. * new bean instance. Singleton flags and names of such "inner beans"
6. * are always ignored: Inner beans are anonymous prototypes.
7. * <li>A RuntimeBeanReference, which must be resolved.
8. * <li>A ManagedList. This is a special collection that may contain
9. * RuntimeBeanReferences or Collections that will need to be resolved.
10. * <li>A ManagedSet. May also contain RuntimeBeanReferences or
11. * Collections that will need to be resolved.
12. * <li>A ManagedMap. In this case the value may be a RuntimeBeanReference
13. * or Collection that will need to be resolved.
14. * <li>An ordinary object or <code>null</code>, in which case it's left alone.
15. * @param argName the name of the argument that the value is defined for
16. * @param value the value object to resolve
17. * @return the resolved object
18. */
19. public Object resolveValueIfNecessary(Object argName, Object value) {
20. // We must check each value to see whether it requires a runtime reference
21. // to another bean to be resolved.
22. if (value instanceof RuntimeBeanReference) {
23. RuntimeBeanReference ref = (RuntimeBeanReference) value;
24. return resolveReference(argName, ref);
25. }
26. else if (value instanceof RuntimeBeanNameReference) {
27. String refName = ((RuntimeBeanNameReference) value).getBeanName();
28. refName = String.valueOf(evaluate(refName));
29. if (!this.beanFactory.containsBean(refName)) {
30. throw new BeanDefinitionStoreException(
31. "Invalid bean name '" + refName + "' in bean reference for " + argName);
32. }
33. return refName;
34. }
35. else if (value instanceof BeanDefinitionHolder) {
36. // Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
37. BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
38. return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
39. }
40. else if (value instanceof BeanDefinition) {
41. // Resolve plain BeanDefinition, without contained name: use dummy name.
42. BeanDefinition bd = (BeanDefinition) value;
43. return resolveInnerBean(argName, "(inner bean)", bd);
44. }
45. else if (value instanceof ManagedArray) {
46. // May need to resolve contained runtime references.
47. ManagedArray array = (ManagedArray) value;
48. Class elementType = array.resolvedElementType;
49. if (elementType == null) {
50. String elementTypeName = array.getElementTypeName();
51. if (StringUtils.hasText(elementTypeName)) {
52. try {
53. elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
54. array.resolvedElementType = elementType;
55. }
56. catch (Throwable ex) {
57. // Improve the message by showing the context.
58. throw new BeanCreationException(
59. this.beanDefinition.getResourceDescription(), this.beanName,
60. "Error resolving array type for " + argName, ex);
61. }
62. }
63. else {
64. elementType = Object.class;
65. }
66. }
67. return resolveManagedArray(argName, (List<?>) value, elementType);
68. }
69. else if (value instanceof ManagedList) {
70. // May need to resolve contained runtime references.
71. return resolveManagedList(argName, (List<?>) value);
72. }
73. else if (value instanceof ManagedSet) {
74. // May need to resolve contained runtime references.
75. return resolveManagedSet(argName, (Set<?>) value);
76. }
77. else if (value instanceof ManagedMap) {
78. // May need to resolve contained runtime references.
79. return resolveManagedMap(argName, (Map<?, ?>) value);
80. }
81. else if (value instanceof ManagedProperties) {
82. Properties original = (Properties) value;
83. Properties copy = new Properties();
84. for (Map.Entry propEntry : original.entrySet()) {
85. Object propKey = propEntry.getKey();
86. Object propValue = propEntry.getValue();
87. if (propKey instanceof TypedStringValue) {
88. propKey = evaluate((TypedStringValue) propKey);
89. }
90. if (propValue instanceof TypedStringValue) {
91. propValue = evaluate((TypedStringValue) propValue);
92. }
93. copy.put(propKey, propValue);
94. }
95. return copy;
96. }
97. else if (value instanceof TypedStringValue) {
98. // Convert value to target type here.
99. TypedStringValue typedStringValue = (TypedStringValue) value;
100. Object valueObject = evaluate(typedStringValue);
101. try {
102. Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
103. if (resolvedTargetType != null) {
104. return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
105. }
106. else {
107. return valueObject;
108. }
109. }
110. catch (Throwable ex) {
111. // Improve the message by showing the context.
112. throw new BeanCreationException(
113. this.beanDefinition.getResourceDescription(), this.beanName,
114. "Error converting typed String value for " + argName, ex);
115. }
116. }
117. else {
118. return evaluate(value);
119. }
120. }

简单总结：

一、容器初始化：

1，Resource来进行资源定位

2，spring创建工厂时（以XmlBeanFactory为例），解析xml文件，转化为document

3，注册BeanDefinition，在BeanFactory的map数据结构里。BeanDefinition就是spring内部用来描绘bean的数据结构

4，getBean时，依据BeanDefinition，实例化对象

5， populateBean 处理 前面实例化的对象的依赖关系