《Spring技术内幕》笔记-第二章 IoC容器的实现

简单介绍

1，在Spring中，SpringIoC提供了一个主要的JavaBean容器。通过IoC模式管理依赖关系。并通过依赖注入和AOP切面增强了为JavaBean这样子的POJO提供事务管理，生命周期管理等功能。

2，Spring IoC的设计中，主要包括两个基本的容器系列：

    -1，BeanFactory系列。该序列实现了容器的基本功能。

    -2。ApplicationContext应用上下文。

Spring IoC容器的设计

1，例如以下图，IoC容器的接口设计图。

    

2，简单介绍

    -1，从BeanFactory到HierarchicalbeanFactory再到ConfigurableBeanFactory是一条基本的BeanFactory设计路径。BeanFactory定义了基本的IoC容器接口。

HierarchicalBeanFactory接口继承了BeanFactory接口，并再其基础上添加了getParentBeanFactory()接口功能，使得BeanFactory具备双亲IoC管理功能。ConfigurableBeanFactory主要定义了对BeanFactory的配置功能。

    -2。以ApplicationContext为核心的接口设计。

BeanFactory的应用场景

    BeanFactory是最主要的IoC容器。

    用户在使用容器的时候能够通过&符来获取FactoryBean本身。FactoryBean跟普通Bean不同。通过BeanFactory类的getBean方法直接获取到的并非该FactoryBean的实例，而是 该FactoryBean中方法getObject返回的对象。

但我们能够通过其他途径获取到该FactoryBean的实例。方法就是在通过 getBean方法获取实例时在參数name前面加上“&”符号就可以。

    

1. String FACTORY_BEAN_PREFIX = "&";

    1。BeanFactory的主要接口，以及其作用例如以下：

    -1。容器推断是否包括指定名字的bean。

1. boolean containsBean(String name);

    -2，推断指定的bean是否是prototype类型。

1. boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    -3。推断指定的bean是否是singleton。

1. boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    -4，推断指定的bean是否与给定类型相匹配。

1. boolean isTypeMatch(String name, Class<?

   > targetType) throws NoSuchBeanDefinitionException;

    -5，获取指定Bean的类型。

1. Class<?

   > getType(String name) throws NoSuchBeanDefinitionException;

    -6。指定bean的全部别名。

1. String[] getAliases(String name);

2，BeanFactory的容器设计原理。

    BeanFactory接口提供了使用IoC的规范，而且Spring实现了一系列容器的实现供开发者使用。

以XmlBeanFactory为例。例如以下为XmlBeanFactory的继承结构图。

下面是XmlBeanFactory的代码，在Spring 4中。该类已经不推荐被使用了。

1. @Deprecated

2. @SuppressWarnings({"serial", "all"})

3. public class XmlBeanFactory extends DefaultListableBeanFactory {

5. private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

8. /**

9. * 通过给定的资源创建一个XmlBeanFactory实例。

10. */

11. public XmlBeanFactory(Resource resource) throws BeansException {

12. this(resource, null);

13. }

15. /**

16. * Create a new XmlBeanFactory with the given input stream,

17. * which must be parsable using DOM.

18. */

19. public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {

20. super(parentBeanFactory);

21. this.reader.loadBeanDefinitions(resource);

22. }

24. }

    该类继承了DefaultListableBeanFactory类。DefaultListableBeanFactory该类实现一个最为基础的IoC容器。

    例如以下是一个简单的使用方法举例：

1. ClassPathResource re = new ClassPathResource("bean.xml");

2. DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

3. XmlBeanDefinitionReader xdr = new XmlBeanDefinitionReader(beanFactory);

4. xdr.loadBeanDefinitions(re);

5. System.out.println(xdr.getRegistry());

ApplicationContext的应用场景

   1。 ApplicationContext在BeanFactory的基础上添加了非常多新的特性：

    -1。支持不同的信息源。ApplicationContext扩展了MessageSource接口，这些为国际化提供服务。

    -2，訪问资源。对ResourceLoader和Resource的支持。能够从不同的地方获取到资源。

    -3。支持应用事件。

继承ApplicationEventPublisher，从而引入的事件机制。

与Bean的生命周期结合，方便管理Bean。

    -4，在ApplicationContext添加附加服务。

    2，ApplicationContext设计原理，以FileSystemApplicationContext为例。

1. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

2. throws BeansException {

4. super(parent);

5. setConfigLocations(configLocations);

6. if (refresh) {

7. refresh();

8. }

9. }

    在实例化该应用中，调用了AbstractApplicationContext的refresh方法。该方法是IoC容器启动的主要方法。

    另一个主要方法是：

1. @Override

2. protected Resource getResourceByPath(String path) {

3. if (path != null && path.startsWith("/")) {

4. path = path.substring(1);

5. }

6. return new FileSystemResource(path);

7. }

该方法通过FileSystemResource获取资源路径。

IoC容器的初始化过程

    简单来说IoC的初始化是由AbstractApplicationContext的refresh方法实现的。整个启动过程包含三个部分。BeanDefinition的Resource定位、加载和注冊三个基本部分。Spring将三个模块分开。并使用不同的模块完毕。

    第一个过程是Resource定位过程。这个Resource定位是指Spring找到我们定义的Bean配置的xml文件。

    第二步。BeanDefinition的加载。这个过程是把用户定义好的Bean表示成IoC容器内部的数据结构，而这个数据结构就是BeanDefinition。详细说。BeanDefination实际就是POJO在容器中的抽象，通过这个BeanDefinition定义的数据结构，使IoC容器可以方便的对POJO对象。也就是Bean进行管理。

    第三步，是向IoC容器注冊这些BeanDefinition的过程。这个过程通过调用BeanDefinationRegistry接口实现。

这个注冊过程把加载过程（第二步）得到的BeanDefinition向容器注冊。IoC内部，将BeanDefinition注入到一个HashMap中去，IoC容器就是通过HashMap来持有这些BeanDefinition数据的。

    一般，IoC的初始化过程，不包含依赖注入。依赖注入一般发生在应用第一次通过getBean向容器获取Bean的时候。

1，BeanDefinition的Resource定位。

  在使用DefaultListableBeanFactory的时候，首先须要使用Resource来进行资源定位容器使用的BeanDefinition。

    使用ClassPathResource进行资源定位。

1. ClassPathResource re = new ClassPathResource("bean.xml");

    在此处定义的资源文件不能被DefaultListableBeanFactory直接使用，通过BeanDefinitionReader来读取。

1. DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

2. XmlBeanDefinitionReader xdr = new XmlBeanDefinitionReader(beanFactory);

3. xdr.loadBeanDefinitions(re);

在此处我们发现使用比較麻烦。所以使用ApplicationContext，由于在ApplicationContext中。Spring为我们提供了一系列的资源定位，比方FileSystemXmlApplicationContext。

    以FileSystemXmlApplicationContext为例，解说相应的源代码。

    该构造函数通过文件路劲来生成相应的FileSystemXmlApplicationContext

1. public FileSystemXmlApplicationContext(String configLocation) throws BeansException {

2. this(new String[] {configLocation}, true, null);

3. }

通过refresh方法来加载BeanDefinition。

1. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

2. throws BeansException {

4. super(parent);

5. setConfigLocations(configLocations);

6. if (refresh) {

7. refresh();

8. }

9. }

通过文件系统来获取资源。

1. @Override

2. protected Resource getResourceByPath(String path) {

3. if (path != null && path.startsWith("/")) {

4. path = path.substring(1);

5. }

6. return new FileSystemResource(path);

7. }

2，BeanDefinition的加载和解析。

    对IoC容器来说。加载过程相当于把BeanDefinition在IoC容器中转换成一个Spring内部数据结构的过程。IoC对对象的管理都是通过对其持有的BeanDefination进行相关操作来实现的。

这些BeanDefinition是通过HashMap来维护的。

1. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

2. throws BeansException {

3. super(parent);

4. setConfigLocations(configLocations);

5. if (refresh) {

6. refresh();

7. }

8. }

    如上代码，refresh()方法启动了容器初始化。是加载BeanDefination的入口方法。
    refresh()详细的代码结构例如以下：

1. @Override

2. public void refresh() throws BeansException, IllegalStateException {

3. synchronized (this.startupShutdownMonitor) {

4. // Prepare this context for refreshing.

5. prepareRefresh();

7. // Tell the subclass to refresh the internal bean factory.

8. //在子类中启动refreshBeanFactory()的地方。

9. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

11. // Prepare the bean factory for use in this context.

12. prepareBeanFactory(beanFactory);

14. try {

15. // Allows post-processing of the bean factory in context subclasses.

16. //设置BeanFactory的后置处理。

17. postProcessBeanFactory(beanFactory);

19. // Invoke factory processors registered as beans in the context.

20. //调用BeanFactory的后置处理器。这些处理器是在Bean定义中向容器注冊的

21. invokeBeanFactoryPostProcessors(beanFactory);

23. // Register bean processors that intercept bean creation.

24. //注冊Bean的后处理器。在Bean的创建过程中调用

25. registerBeanPostProcessors(beanFactory);

27. // Initialize message source for this context.

28. //对上下文中的消息源初始化

29. initMessageSource();

31. // Initialize event multicaster for this context.

32. //初始化上下文中的时间机制

33. initApplicationEventMulticaster();

35. // Initialize other special beans in specific context subclasses.

36. //初始化其它Bean

37. onRefresh();

39. // Check for listener beans and register them.

40. //检查监听bean并注冊

41. registerListeners();

43. // Instantiate all remaining (non-lazy-init) singletons.

44. //实例化全部(non-lazy-init) 单例。

45. finishBeanFactoryInitialization(beanFactory);

47. // Last step: publish corresponding event.

48. //公布容器事件。结束

49. finishRefresh();

50. }

52. catch (BeansException ex) {

53. // Destroy already created singletons to avoid dangling resources.

54. //防止Bean资源占用，销毁已经创建的单例。

55. destroyBeans();

57. // Reset 'active' flag.

58. //重置active标志

59. cancelRefresh(ex);

61. // Propagate exception to caller.

62. throw ex;

63. }

64. }

65. }

-1。prepareRefresh()：

1. /**
2. * Prepare this context for refreshing, setting its startup date and
3. * active flag as well as performing any initialization of property sources.
4. */
5. protected void prepareRefresh() {
6. this.startupDate = System.currentTimeMillis();
8. synchronized (this.activeMonitor) {
9. this.active = true;
10. }
12. if (logger.isInfoEnabled()) {
13. logger.info("Refreshing " + this);
14. }
16. // Initialize any placeholder property sources in the context environment
17. initPropertySources();
19. // Validate that all properties marked as required are resolvable
20. // see ConfigurablePropertyResolver#setRequiredProperties
21. getEnvironment().validateRequiredProperties();
22. }

-2。启动refreshBeanFactory()：

1. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

1. /**
2. * Tell the subclass to refresh the internal bean factory.
3. * @return the fresh BeanFactory instance
4. * @see #refreshBeanFactory()
5. * @see #getBeanFactory()
6. */
7. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
8. refreshBeanFactory();
9. ConfigurableListableBeanFactory beanFactory = getBeanFactory();
10. if (logger.isDebugEnabled()) {
11. logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
12. }
13. return beanFactory;
14. }

终于调用，AbstractRefreshableApplicationContext中的refreshBeanFactory()方法。

2. /**
3. * This implementation performs an actual refresh of this context's underlying
4. * bean factory, shutting down the previous bean factory (if any) and
5. * initializing a fresh bean factory for the next phase of the context's lifecycle.
6. */
7. @Override
8. protected final void refreshBeanFactory() throws BeansException {
9. if (hasBeanFactory()) {//假设已经存在BeanFactory
10. destroyBeans();//销毁
11. closeBeanFactory();
12. }
13. try { //创建IoC容器
14. DefaultListableBeanFactory beanFactory = createBeanFactory();
15. beanFactory.setSerializationId(getId());
16. customizeBeanFactory(beanFactory);
17. loadBeanDefinitions(beanFactory);//加载BeanFactory。抽象方法
18. synchronized (this.beanFactoryMonitor) {
19. this.beanFactory = beanFactory;
20. }
21. }
22. catch (IOException ex) {
23. throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
24. }
25. }

这里调用的loadBeanDefinations()是一个抽象方法，详细实如今AbstractXmlApplicationContext。

1. /**
2. * Loads the bean definitions via an XmlBeanDefinitionReader.
3. * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
4. * @see #initBeanDefinitionReader
5. * @see #loadBeanDefinitions
6. */
7. @Override
8. protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
9. // Create a new XmlBeanDefinitionReader for the given BeanFactory.
10. XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
12. // Configure the bean definition reader with this context's
13. // resource loading environment.
14. beanDefinitionReader.setEnvironment(this.getEnvironment());
15. beanDefinitionReader.setResourceLoader(this);
16. beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
18. // Allow a subclass to provide custom initialization of the reader,
19. // then proceed with actually loading the bean definitions.
20. initBeanDefinitionReader(beanDefinitionReader);
21. loadBeanDefinitions(beanDefinitionReader);
22. }

接着就是调用loadBeanDefinations的地方，首先得到BeanDefinition信息的Resource定位，然后调用XmlBeanDefinitionReader来读取，详细过程托付给BeanDefinitionReader来完毕的。

XML文件则是通过XmlBeanDefinitionReader来加载BeanDefination到容器中。

    ​注：在XmlBeanDefinationReader中找到的loadBeanDefination()方法。与书中的代码块不同。

此处可能是Spring版本号的问题。

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. }
7. Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
8. if (currentResources == null) {
9. currentResources = new HashSet<EncodedResource>(4);
10. this.resourcesCurrentlyBeingLoaded.set(currentResources);
11. }
12. if (!currentResources.add(encodedResource)) {
13. throw new BeanDefinitionStoreException(
14. "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
15. }
16. try {//输入流读取资源
17. InputStream inputStream = encodedResource.getResource().getInputStream();
18. try {
19. InputSource inputSource = new InputSource(inputStream);
20. if (encodedResource.getEncoding() != null) {
21. inputSource.setEncoding(encodedResource.getEncoding());
22. }//调用解析XML文件
23. return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
24. }
25. finally {
26. inputStream.close();
27. }
28. }
29. catch (IOException ex) {
30. throw new BeanDefinitionStoreException(
31. "IOException parsing XML document from " + encodedResource.getResource(), ex);
32. }
33. finally {
34. currentResources.remove(encodedResource);
35. if (currentResources.isEmpty()) {
36. this.resourcesCurrentlyBeingLoaded.remove();
37. }
38. }
39. }

doLoadBeanDefinitions()方法：

1. protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
2. throws BeanDefinitionStoreException {
3. try {
4. //载入文件
5. Document doc = doLoadDocument(inputSource, resource);
6. //启动具体的解析过程
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. }

registerbeanDefinitions()方法代码：

1. public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
2. //获取XML文档读取
3. BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
4. documentReader.setEnvironment(this.getEnvironment());
5. int countBefore = getRegistry().getBeanDefinitionCount();
6. //详细解析过程
7. documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
8. return getRegistry().getBeanDefinitionCount() - countBefore;
9. }

BeanDefinition加载过程中，首先调用XML解析器，生成XML解析对象。然后再进行详细的解析。

createBeanDefinitionDocumentReader()方法：

1. protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
2. return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
3. }

获取到详细的解析器。然后托付给BeanDefinitionParserDelegate来完毕详细的解析。例如以下查看DefaultBeanDefinitionDocuementReader中的processBeanDefinition(Element , BeanDefinitionParserDelegate)方法：

1. protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

2. BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

3. //BeanDefinitionHolder是对BeanDefinition的封装。

4. if (bdHolder != null) {
5. bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
6. try {

7. // Register the final decorated instance.

8. //向IoC容器注冊解析到的BeanDefinition。

9. BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
10. }
11. catch (BeanDefinitionStoreException ex) {
12. getReaderContext().error("Failed to register bean definition with name '" +
13. bdHolder.getBeanName() + "'", ele, ex);
14. }
15. // Send registration event.
16. getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
17. }
18. }

BeanDefinitionHolder：

1. public class BeanDefinitionHolder implements BeanMetadataElement {
3. private final BeanDefinition beanDefinition;
5. private final String beanName;
7. private final String[] aliases;
9. ........

在BeanDefinitionParserDelegate类中，定义了对各种SpringBean类的处理。

查看其相应的parseBeanDefinitionElement方法：

1. public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
2. String id = ele.getAttribute(ID_ATTRIBUTE);//bean元素中的ID
3. String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//bean元素中的name
5. List<String> aliases = new ArrayList<String>();//aliases
6. if (StringUtils.hasLength(nameAttr)) {
7. String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
8. aliases.addAll(Arrays.asList(nameArr));
9. }
11. String beanName = id;
12. if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
13. beanName = aliases.remove(0);
14. if (logger.isDebugEnabled()) {
15. logger.debug("No XML 'id' specified - using '" + beanName +
16. "' as bean name and " + aliases + " as aliases");
17. }
18. }
20. if (containingBean == null) {
21. checkNameUniqueness(beanName, aliases, ele);
22. }
24. AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);//具体解析过程，返回AbstractBeanDefinition对象，该对象定义了Bean的基本属性
25. if (beanDefinition != null) {
26. if (!StringUtils.hasText(beanName)) {
27. try {
28. if (containingBean != null) {
29. beanName = BeanDefinitionReaderUtils.generateBeanName(
30. beanDefinition, this.readerContext.getRegistry(), true);
31. }
32. else {
33. beanName = this.readerContext.generateBeanName(beanDefinition);
34. // Register an alias for the plain bean class name, if still possible,
35. // if the generator returned the class name plus a suffix.
36. // This is expected for Spring 1.2/2.0 backwards compatibility.
37. String beanClassName = beanDefinition.getBeanClassName();
38. if (beanClassName != null &&
39. beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
40. !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
41. aliases.add(beanClassName);
42. }
43. }
44. if (logger.isDebugEnabled()) {
45. logger.debug("Neither XML 'id' nor 'name' specified - " +
46. "using generated bean name [" + beanName + "]");
47. }
48. }
49. catch (Exception ex) {
50. error(ex.getMessage(), ele);
51. return null;
52. }
53. }
54. String[] aliasesArray = StringUtils.toStringArray(aliases);
55. return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
56. }
58. return null;
59. }

查看详细的解析代码，parseBeanDefinitionEleent方法：

1. public AbstractBeanDefinition parseBeanDefinitionElement(
2. Element ele, String beanName, BeanDefinition containingBean) {
4. this.parseState.push(new BeanEntry(beanName));
6. String className = null;
7. if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
8. className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
9. }
11. try {
12. String parent = null;
13. if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
14. parent = ele.getAttribute(PARENT_ATTRIBUTE);
15. }
16. //生成BeanDefinition对象
17. AbstractBeanDefinition bd = createBeanDefinition(className, parent);
18. //解析属性，并设置Description信息
19. parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
20. bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
21. //解析bean元素信息
22. parseMetaElements(ele, bd);
23. parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
24. parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
25. //构造函数
26. parseConstructorArgElements(ele, bd);
27. //成员变量
28. parsePropertyElements(ele, bd);
29. parseQualifierElements(ele, bd);
31. bd.setResource(this.readerContext.getResource());
32. bd.setSource(extractSource(ele));
34. return bd;
35. }
36. catch (ClassNotFoundException ex) {
37. error("Bean class [" + className + "] not found", ele, ex);
38. }
39. catch (NoClassDefFoundError err) {
40. error("Class that bean class [" + className + "] depends on not found", ele, err);
41. }
42. catch (Throwable ex) {
43. error("Unexpected failure during bean definition parsing", ele, ex);
44. }
45. finally {
46. this.parseState.pop();
47. }
49. return null;
50. }

当中相应的各种异常信息，可能我们在编程工作中常常遇到。

1. public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
2. NodeList nl = beanEle.getChildNodes();
3. for (int i = 0; i < nl.getLength(); i++) {
4. Node node = nl.item(i);
5. if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
6. parsePropertyElement((Element) node, bd);//解析
7. }
8. }
9. }

1. /**
2. * Parse a property element.
3. */
4. public void parsePropertyElement(Element ele, BeanDefinition bd) {
5. String propertyName = ele.getAttribute(NAME_ATTRIBUTE);//获取property名字
6. if (!StringUtils.hasLength(propertyName)) {
7. error("Tag 'property' must have a 'name' attribute", ele);
8. return;
9. }
10. this.parseState.push(new PropertyEntry(propertyName));
11. try {
12. if (bd.getPropertyValues().contains(propertyName)) {//是否包括
13. error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
14. return;
15. }
16. Object val = parsePropertyValue(ele, bd, propertyName);//解析
17. PropertyValue pv = new PropertyValue(propertyName, val);//获取值
18. parseMetaElements(ele, pv);
19. pv.setSource(extractSource(ele));
20. bd.getPropertyValues().addPropertyValue(pv);
21. }
22. finally {
23. this.parseState.pop();
24. }
25. }

1. public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
2. String elementName = (propertyName != null) ?
3. "<property> element for property '" + propertyName + "'" :
4. "<constructor-arg> element";
6. // Should only have one child element: ref, value, list, etc.
7. NodeList nl = ele.getChildNodes();//xml文档解析
8. Element subElement = null;
9. for (int i = 0; i < nl.getLength(); i++) {
10. Node node = nl.item(i);
11. if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
12. !nodeNameEquals(node, META_ELEMENT)) {
13. // Child element is what we're looking for.
14. if (subElement != null) {
15. error(elementName + " must not contain more than one sub-element", ele);
16. }
17. else {
18. subElement = (Element) node;
19. }
20. }
21. }
23. boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);//是否是ref引用
24. boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);//值引用
25. if ((hasRefAttribute && hasValueAttribute) ||
26. ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
27. error(elementName +
28. " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
29. }
31. if (hasRefAttribute) {//ref引用
32. String refName = ele.getAttribute(REF_ATTRIBUTE);
33. if (!StringUtils.hasText(refName)) {
34. error(elementName + " contains empty 'ref' attribute", ele);
35. }
36. RuntimeBeanReference ref = new RuntimeBeanReference(refName);
37. ref.setSource(extractSource(ele));
38. return ref;
39. }//value 引用
40. else if (hasValueAttribute) {
41. TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
42. valueHolder.setSource(extractSource(ele));
43. return valueHolder;
44. }//假设还有子元素。触发对子元素的解析
45. else if (subElement != null) {
46. return parsePropertySubElement(subElement, bd);
47. }
48. else {
49. // Neither child element nor "ref" or "value" attribute found.
50. error(elementName + " must specify a ref or value", ele);
51. return null;
52. }
53. }

3，BeanDefinition在IoC容器中的注冊

BeanDefinition完毕加载和解析过程后。须要对其进行注冊操作。

注冊是在DefaultListableBeanFactory中，通过HashMap来加载Beandefinition的。

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

调用顺序：XmlBeanDefinitionReader调用loadBeanDefinitions(EncodedResource)方法，然后到registerBeanDefinitions()方法。在该方法中registerBeanDefinitions()方法被调用。在DefaultListableBeanFactory中，实现了BeanDefinitionRegistry接口。

1. @Override
2. public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
3. throws BeanDefinitionStoreException {
5. Assert.hasText(beanName, "Bean name must not be empty");
6. Assert.notNull(beanDefinition, "BeanDefinition must not be null");
8. if (beanDefinition instanceof AbstractBeanDefinition) {
9. try {
10. ((AbstractBeanDefinition) beanDefinition).validate();
11. }
12. catch (BeanDefinitionValidationException ex) {
13. throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
14. "Validation of bean definition failed", ex);
15. }
16. }
18. synchronized (this.beanDefinitionMap) {//是否存在同样名字
19. BeanDefinition oldBeanDefinition = this.beanDefinitionMap.get(beanName);
20. if (oldBeanDefinition != null) {
21. if (!this.allowBeanDefinitionOverriding) {
22. throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
23. "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
24. "': There is already [" + oldBeanDefinition + "] bound.");
25. }
26. else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
27. // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
28. if (this.logger.isWarnEnabled()) {
29. this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
30. " with a framework-generated bean definition ': replacing [" +
31. oldBeanDefinition + "] with [" + beanDefinition + "]");
32. }
33. }
34. else {
35. if (this.logger.isInfoEnabled()) {
36. this.logger.info("Overriding bean definition for bean '" + beanName +
37. "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
38. }
39. }
40. }
41. else {//注冊bean。将bean的name放入List
42. this.beanDefinitionNames.add(beanName);
43. this.frozenBeanDefinitionNames = null;

44. }

45. //map中增加

46. this.beanDefinitionMap.put(beanName, beanDefinition);
47. }
49. resetBeanDefinition(beanName);
50. }

完毕了注冊。就完毕了IoC容器的初始化。

在使用的IoC容器的DefaultListableBeanFactory中已经建立了Bean的配置信息，并且这些BeanDefinition已经能够被容器使用，他们都在beanDefinitionMap中被检索和使用。容器的作用就是对这些信息进行维护和处理。

IoC容器的依赖注入    ​    ​

    ​依赖注入是用户第一次向Ioc容器索要Bean的时候触发的。除非通过lazy-init控制Bean的记载时机。

    ​从DefaultListableBeanFactory的基类AbstractBeanFactory的getBean方法開始查看实现。

1. @Override
2. public Object getBean(String name) throws BeansException {
3. return doGetBean(name, null, null, false);
4. }
6. @Override
7. public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
8. return doGetBean(name, requiredType, null, false);
9. }
11. @Override
12. public Object getBean(String name, Object... args) throws BeansException {
13. return doGetBean(name, null, args, false);
14. }

查看doGetBean方法：

2. protected <T> T doGetBean(
3. final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
4. throws BeansException {
6. final String beanName = transformedBeanName(name);
7. Object bean;
9. // Eagerly check singleton cache for manually registered singletons.
10. //从缓存入手。处理单例bean
11. Object sharedInstance = getSingleton(beanName);
12. if (sharedInstance != null && args == null) {
13. if (logger.isDebugEnabled()) {
14. if (isSingletonCurrentlyInCreation(beanName)) {
15. logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
16. "' that is not fully initialized yet - a consequence of a circular reference");
17. }
18. else {
19. logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
20. }
21. }
22. //对FactoryBean的处理，获取FactoryBean的相关实例。
23. bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
24. }
26. else {
27. // Fail if we're already creating this bean instance:
28. // We're assumably within a circular reference.
29. if (isPrototypeCurrentlyInCreation(beanName)) {
30. throw new BeanCurrentlyInCreationException(beanName);
31. }
33. // Check if bean definition exists in this factory.
34. //减产是否已经存在相应的BeanDefinition对象
35. BeanFactory parentBeanFactory = getParentBeanFactory();
36. if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
37. // Not found -> check parent.
38. String nameToLookup = originalBeanName(name);
39. if (args != null) {
40. // Delegation to parent with explicit args.
41. return (T) parentBeanFactory.getBean(nameToLookup, args);
42. }
43. else {
44. // No args -> delegate to standard getBean method.
45. return parentBeanFactory.getBean(nameToLookup, requiredType);
46. }
47. }
49. if (!typeCheckOnly) {
50. markBeanAsCreated(beanName);
51. }
53. try {
54. //依据Bean的名字获取BeanDefinition
55. final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
56. checkMergedBeanDefinition(mbd, beanName, args);
58. // Guarantee initialization of beans that the current bean depends on.
59. //获取当前bean的全部依赖bean
60. String[] dependsOn = mbd.getDependsOn();
61. if (dependsOn != null) {
62. for (String dependsOnBean : dependsOn) {
63. if (isDependent(beanName, dependsOnBean)) {
64. throw new BeanCreationException("Circular depends-on relationship between '" +
65. beanName + "' and '" + dependsOnBean + "'");
66. }
67. registerDependentBean(dependsOnBean, beanName);//注冊依赖bean
68. getBean(dependsOnBean);//获取bean的递归调用
69. }
70. }
72. // Create bean instance.
73. //创建单例bean
74. if (mbd.isSingleton()) {
75. sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
76. @Override
77. public Object getObject() throws BeansException {
78. try {
79. return createBean(beanName, mbd, args);
80. }
81. catch (BeansException ex) {
82. // Explicitly remove instance from singleton cache: It might have been put there
83. // eagerly by the creation process, to allow for circular reference resolution.
84. // Also remove any beans that received a temporary reference to the bean.
85. destroySingleton(beanName);
86. throw ex;
87. }
88. }
89. });
90. bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
91. }
93. else if (mbd.isPrototype()) {// property bean
94. // It's a prototype -> create a new instance.
95. Object prototypeInstance = null;
96. try {
97. beforePrototypeCreation(beanName);
98. prototypeInstance = createBean(beanName, mbd, args);
99. }
100. finally {
101. afterPrototypeCreation(beanName);
102. }
103. bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
104. }
106. else {
107. String scopeName = mbd.getScope();//其它scope
108. final Scope scope = this.scopes.get(scopeName);
109. if (scope == null) {
110. throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
111. }
112. try {
113. Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
114. @Override
115. public Object getObject() throws BeansException {
116. beforePrototypeCreation(beanName);
117. try {
118. return createBean(beanName, mbd, args);
119. }
120. finally {
121. afterPrototypeCreation(beanName);
122. }
123. }
124. });
125. bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
126. }
127. catch (IllegalStateException ex) {
128. throw new BeanCreationException(beanName,
129. "Scope '" + scopeName + "' is not active for the current thread; " +
130. "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
131. ex);
132. }
133. }
134. }
135. catch (BeansException ex) {
136. cleanupAfterBeanCreationFailure(beanName);
137. throw ex;
138. }
139. }
141. // Check if required type matches the type of the actual bean instance.
142. //检查bean的类型。
143. if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
144. try {
145. return getTypeConverter().convertIfNecessary(bean, requiredType);
146. }
147. catch (TypeMismatchException ex) {
148. if (logger.isDebugEnabled()) {
149. logger.debug("Failed to convert bean '" + name + "' to required type [" +
150. ClassUtils.getQualifiedName(requiredType) + "]", ex);
151. }
152. throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
153. }
154. }
155. return (T) bean;
156. }

这种方法就是依赖注入的入口，由于他触发了依赖注入。

虽然能够以最简单的方法来描写叙述Spring IoC容器，即Spring容器就是一个HashMap，通过HashMap来管理BeanDefinition对象。

在getBean()的时候，会触发createBean()来进创建须要的Bean对象。

    ​终于的调用，到AbstractAutowireCapableBeanFactory的createBean()方法，代码例如以下：

1. /**
2. * Central method of this class: creates a bean instance,
3. * populates the bean instance, applies post-processors, etc.
4. * @see #doCreateBean
5. */
6. @Override
7. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
8. throws BeanCreationException {
10. if (logger.isDebugEnabled()) {
11. logger.debug("Creating instance of bean '" + beanName + "'");
12. }

13. // Make sure bean class is actually resolved at this point.

14. //推断须要创建的Bean是否可实例化，这个类是否可通过类装载器来加载

15. resolveBeanClass(mbd, beanName);
17. // Prepare method overrides.
18. try {
19. mbd.prepareMethodOverrides();
20. }
21. catch (BeanDefinitionValidationException ex) {
22. throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
23. beanName, "Validation of method overrides failed", ex);
24. }
26. try {

27. // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.

28. //假设Bean配置了BeanPostProcessors，则返回代理对象

29. Object bean = resolveBeforeInstantiation(beanName, mbd);
30. if (bean != null) {
31. return bean;
32. }
33. }
34. catch (Throwable ex) {
35. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
36. "BeanPostProcessor before instantiation of bean failed", ex);

37. }

38. //创建bean

40. Object beanInstance = doCreateBean(beanName, mbd, args);
41. if (logger.isDebugEnabled()) {
42. logger.debug("Finished creating instance of bean '" + beanName + "'");
43. }
44. return beanInstance;
45. }

再查看doCreateBean()方法：

1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
2. // Instantiate the bean.
3. BeanWrapper instanceWrapper = null;

4. if (mbd.isSingleton()) {//假设是单例的。则移除缓存中的同name bean

5. instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
6. }
7. if (instanceWrapper == null) {//创建Bean
8. instanceWrapper = createBeanInstance(beanName, mbd, args);
9. }
10. final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
11. Class<?

    > beanType = (instanceWrapper != null ?

    instanceWrapper.getWrappedClass() : null);

13. // Allow post-processors to modify the merged bean definition.
14. synchronized (mbd.postProcessingLock) {
15. if (!mbd.postProcessed) {
16. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
17. mbd.postProcessed = true;
18. }
19. }
21. // Eagerly cache singletons to be able to resolve circular references
22. // even when triggered by lifecycle interfaces like BeanFactoryAware.
23. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
24. isSingletonCurrentlyInCreation(beanName));
25. if (earlySingletonExposure) {
26. if (logger.isDebugEnabled()) {
27. logger.debug("Eagerly caching bean '" + beanName +
28. "' to allow for resolving potential circular references");
29. }
30. addSingletonFactory(beanName, new ObjectFactory<Object>() {
31. @Override
32. public Object getObject() throws BeansException {
33. return getEarlyBeanReference(beanName, mbd, bean);
34. }
35. });
36. }
38. // Initialize the bean instance.初始化bean。通常在此处发生依赖注入
39. Object exposedObject = bean;
40. try {
41. populateBean(beanName, mbd, instanceWrapper);
42. if (exposedObject != null) {
43. exposedObject = initializeBean(beanName, exposedObject, mbd);
44. }
45. }
46. catch (Throwable ex) {
47. if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
48. throw (BeanCreationException) ex;
49. }
50. else {
51. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
52. }
53. }
55. if (earlySingletonExposure) {
56. Object earlySingletonReference = getSingleton(beanName, false);
57. if (earlySingletonReference != null) {
58. if (exposedObject == bean) {
59. exposedObject = earlySingletonReference;
60. }
61. else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
62. String[] dependentBeans = getDependentBeans(beanName);
63. Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
64. for (String dependentBean : dependentBeans) {
65. if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
66. actualDependentBeans.add(dependentBean);
67. }
68. }
69. if (!actualDependentBeans.isEmpty()) {
70. throw new BeanCurrentlyInCreationException(beanName,
71. "Bean with name '" + beanName + "' has been injected into other beans [" +
72. StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
73. "] in its raw version as part of a circular reference, but has eventually been " +
74. "wrapped. This means that said other beans do not use the final version of the " +
75. "bean. This is often the result of over-eager type matching - consider using " +
76. "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
77. }
78. }
79. }
80. }
82. // Register bean as disposable.
83. try {
84. registerDisposableBeanIfNecessary(beanName, bean, mbd);
85. }
86. catch (BeanDefinitionValidationException ex) {
87. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
88. }
90. return exposedObject;
91. }

与依赖注入相关的两个方法：createBeanInstance和populateBean。

 

1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {

2. // Make sure bean class is actually resolved at this point.

3. //确认须要创建实例的类能够实例化

4. Class<?> beanClass = resolveBeanClass(mbd, beanName);
6. if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
7. throw new BeanCreationException(mbd.getResourceDescription(), beanName,
8. "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());

9. }

10. //工厂方法实例化

11. if (mbd.getFactoryMethodName() != null) {
12. return instantiateUsingFactoryMethod(beanName, mbd, args);
13. }
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. }
35. //构造函数实例化
36. Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
37. if (ctors != null ||
38. mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
39. mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
40. return autowireConstructor(beanName, mbd, ctors, args);
41. }
43. // 使用无參构造函数
44. return instantiateBean(beanName, mbd);
45. }

1. protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {

2. //使用CGLIB对bean进行实例化。

3. try {
4. Object beanInstance;
5. final BeanFactory parent = this;
6. if (System.getSecurityManager() != null) {
7. beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
8. @Override
9. public Object run() {
10. return getInstantiationStrategy().instantiate(mbd, beanName, parent);
11. }
12. }, getAccessControlContext());
13. }
14. else {
15. beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
16. }
17. BeanWrapper bw = new BeanWrapperImpl(beanInstance);
18. initBeanWrapper(bw);
19. return bw;
20. }
21. catch (Throwable ex) {
22. throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
23. }
24. }

在Bean实例化后，就是相关的依赖关系。

    ​依赖注入的发生是在BeanWrapper的setPropertyValues中实现。详细实现是在BeanWrapper的子类，BeanWrapperImpl中实现。

以上便是整个IoC过程创建Bean的总体思路。与书中相比，省略了部分代码。

ApplicationContext和Bean的初始化及销毁

    ​ApplicationContext的启动是在AbstractApplicationContext中实现。

    ​相同的销毁操作是在doClose()方法中完毕。

1. protected void doClose() {
2. boolean actuallyClose;
3. synchronized (this.activeMonitor) {
4. actuallyClose = this.active && !this.closed;
5. this.closed = true;
6. }
8. if (actuallyClose) {
9. if (logger.isInfoEnabled()) {
10. logger.info("Closing " + this);
11. }
13. LiveBeansView.unregisterApplicationContext(this);
15. try {
16. // Publish shutdown event.
17. publishEvent(new ContextClosedEvent(this));
18. }
19. catch (Throwable ex) {
20. logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
21. }
23. // Stop all Lifecycle beans, to avoid delays during individual destruction.
24. try {
25. getLifecycleProcessor().onClose();
26. }
27. catch (Throwable ex) {
28. logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
29. }
31. // Destroy all cached singletons in the context's BeanFactory.
32. destroyBeans();
34. // Close the state of this context itself.
35. closeBeanFactory();
37. // Let subclasses do some final clean-up if they wish...
38. onClose();
40. synchronized (this.activeMonitor) {
41. this.active = false;
42. }
43. }
44. }

    ​Bean的销毁和创建，Spring通过IoC管理Bean的生命周期来实现。

Spring中Bean的生命周期包括：

    ​    ​-1。Bean实例的创建。

    ​    ​-2，为Bean实例设置属性。

    ​    ​-3。调用Bean的初始化方法。

    ​    ​-4，通过IoC获取Bean。

    ​    ​-5，当容器关闭的时候调用bean的销毁方法。

总结

    ​BeanDefinition的定位。对IoC容器来说，它为管理POJO直接的关系提供了帮助，但也要依据Spring的定义规则提供Bean定义信息。在Bean定义方面，Spring为用户提供了非常大的灵活性。在初始化过程中，首先须要定义到这些有效地Bean定义信息。这里Spring使用Resource接口来统一这些信息。而定位由ResourceLoader完毕。

    ​容器的初始化。容器的初始化过程是在refresh()方法中完毕的。这个refresh()相当于容器的初始化函数。在初始化中，比較重要的就是对Bean信息的加载和注冊功能。

​