Spring IOC容器的初始化过程--资源定位

时间：2022-08-26 19:41:34
      IOC容器的初始化是又refresh()方法启动的，这个方法标志着IOC容器的正式启动。具体来说，这个启动包括bean的resource定位，载入和注册三个过程。今天我们主要了解资源定位的过程。

定位

       以编程的方式使用DefaultListableBeanFactory时，首先定义一个Resource来定位容器使用的BeanDefinition。这时使用的是ClassPathResource，这意味着Spring会在类路径中去寻找以文件形式存在的BeanDefinition信息。
    
    
    

  1. ClassPathResource res=new ClassPathResource("beans.xml"); 
    2.
       这里定义的Resource并不能由DefaultListableBeanFactory直接使用，Spring通过BeanDefinitionReader来对这些信息进行处理。我们也可以看到使用Application­Context 相对于直接使用DefaultListableBeanFactory的好处。因为在ApplicationContext中，spring已经为我们提供了一系列加载不同Resource的读取器的实现，而DefaultListableBeanFactory只是一个纯粹的IoC容器，需要为它配置特定的读取器才能完成这些功能。        当然， 有利就有弊， 使用DefaultListableBeanFactory这种更底层的容器，能提高定制IoC容器的灵活性。        FilesystemXmlApplicationContext可以从文件系统载入Resource，ClassPathXmlApplication­Context可以从ClassPath载入Resource,，XmlWebApplicationContext可以在Web容器中载入Resource。
       以FileSystemXmlApplicationContext为例， 通过分析这个ApplicationContext的实现来看看它是怎样完成这个Resource定位过程的。下面是这个ApplicationContext的继承体系。Spring IOC容器的初始化过程--资源定位
Spring IOC容器的初始化过程--资源定位图1   FilesystemXmlApplicationContext的继承体系
从源代码角度看：Spring IOC容器的初始化过程--资源定位
Spring IOC容器的初始化过程--资源定位
                                          图2    代码角度看FilesystemXmlApplicationContext的继承体系

FilesystemXmlApplicationContext.class

    
    
    

  1. public class FileSystemXmlApplicationContext extends AbstractXmlApplicationContext {
    2. 
     
     
    3. 
     
     
  3. public FileSystemXmlApplicationContext() {
    4. 
     
     
  4. }
    5. 
     
     
    6. 
     
     
  6. public FileSystemXmlApplicationContext(ApplicationContext parent) {
    7. 
     
     
  7. super(parent);
    8. 
     
     
  8. }
    9. 
     
     
    10. 
     
     
  10. /**
    11. 
     
     
  11.  * Create a new FileSystemXmlApplicationContext, loading the definitions
    12. 
     
     
  12.  * from the given XML file and automatically refreshing the context.
    13. 
     
     
  13.  * @param configLocation file path
    14. 
     
     
  14.  * @throws BeansException if context creation failed
    15. 
     
     
  15.  */
    16. 
     
     
  16. public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
    17. 
     
     
  17. this(new String[] {configLocation}, true, null);
    18. 
     
     
  18. }
    19. 
     
     
    20. 
     
     
  20. /**
    21. 
     
     
  21.  * Create a new FileSystemXmlApplicationContext, loading the definitions
    22. 
     
     
  22.  * from the given XML files and automatically refreshing the context.
    23. 
     
     
  23.  * @param configLocations array of file paths
    24. 
     
     
  24.  * @throws BeansException if context creation failed
    25. 
     
     
  25.  */
    26. 
     
     
  26. public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
    27. 
     
     
  27. this(configLocations, true, null);
    28. 
     
     
  28. }
    29. 
     
     
    30. 
     
     
  30. /**
    31. 
     
     
  31.  * Create a new FileSystemXmlApplicationContext with the given parent,
    32. 
     
     
  32.  * loading the definitions from the given XML files and automatically
    33. 
     
     
  33.  * refreshing the context.
    34. 
     
     
  34.  * @param configLocations array of file paths
    35. 
     
     
  35.  * @param parent the parent context
    36. 
     
     
  36.  * @throws BeansException if context creation failed
    37. 
     
     
  37.  */
    38. 
     
     
  38. public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
    39. 
     
     
  39. this(configLocations, true, parent);
    40. 
     
     
  40. }
    41. 
     
     
    42. 
     
     
  42. /**
    43. 
     
     
  43.  * Create a new FileSystemXmlApplicationContext, loading the definitions
    44. 
     
     
  44.  * from the given XML files.
    45. 
     
     
  45.  * @param configLocations array of file paths
    46. 
     
     
  46.  * @param refresh whether to automatically refresh the context,
    47. 
     
     
  47.  * loading all bean definitions and creating all singletons.
    48. 
     
     
  48.  * Alternatively, call refresh manually after further configuring the context.
    49. 
     
     
  49.  * @throws BeansException if context creation failed
    50. 
     
     
  50.  * @see #refresh()
    51. 
     
     
  51.  */
    52. 
     
     
  52. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
    53. 
     
     
  53. this(configLocations, refresh, null);
    54. 
     
     
  54. }
    55. 
     
     
    56. 
     
     
  56. /**
    57. 
     
     
  57.  * Create a new FileSystemXmlApplicationContext with the given parent,
    58. 
     
     
  58.  * loading the definitions from the given XML files.
    59. 
     
     
  59.  * @param configLocations array of file paths
    60. 
     
     
  60.  * @param refresh whether to automatically refresh the context,
    61. 
     
     
  61.  * loading all bean definitions and creating all singletons.
    62. 
     
     
  62.  * Alternatively, call refresh manually after further configuring the context.
    63. 
     
     
  63.  * @param parent the parent context
    64. 
     
     
  64.  * @throws BeansException if context creation failed
    65. 
     
     
  65.  * @see #refresh()
    66. 
     
     
  66.  */
    67. 
     
     
  67. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    68. 
     
     
  68. throws BeansException {
    69. 
     
     
    70. 
     
     
  70. super(parent);
    71. 
     
     
  71. setConfigLocations(configLocations);
    72. 
     
     
  72. if (refresh) {
    73. 
     
     
  73. refresh();
    74. 
     
     
  74. }
    75. 
     
     
  75. }
    76. 
     
     
    77. 
     
     
    78. 
     
     
  78. /**
    79. 
     
     
  79.  * Resolve resource paths as file system paths.
    80. 
     
     
  80.  * <p>Note: Even if a given path starts with a slash, it will get
    81. 
     
     
  81.  * interpreted as relative to the current VM working directory.
    82. 
     
     
  82.  * This is consistent with the semantics in a Servlet container.
    83. 
     
     
  83.  * @param path path to the resource
    84. 
     
     
  84.  * @return Resource handle
    85. 
     
     
  85.  * @see org.springframework.web.context.support.XmlWebApplicationContext#getResourceByPath
    86. 
     
     
  86.  */
    87. 
     
     
  87. @Override
    88. 
     
     
  88. protected Resource getResourceByPath(String path) {
    89. 
     
     
  89. if (path != null && path.startsWith("/")) {
    90. 
     
     
  90. path = path.substring(1);
    91. 
     
     
  91. }
    92. 
     
     
  92. return new FileSystemResource(path);
    93. 
     
     
  93. }
    94. 
     
     
    95. 
     
     
  95. }
    96.
       我们可以看到在构造函数中，实现了对configuration进行处理的功能。让所有配置在文件系统中的，以.XML 文件方式存在的BeanDefnition都能够得到有效的处理。实现了 getResourceByPath方法，这个方法是个模板方法，是为读取Resource服务的。对于IoC容器功能的实现，这里没有涉及，因为它继承了AbstractXmlApplicationContext 。关于IoC容器功能相关的实现，都是在FileSysternXmlApplicationContext中完成的，但是在构造函数中通过refresh来启动IoC容器的初始化，这个refresh方法非常重要，也是我们以后分析容器初始化过程实现的一个重要入口。       关于读入器的配置，可以到它的基类AbstractXmlApplicationContext中查看。      Spring IOC容器的初始化过程--资源定位Spring IOC容器的初始化过程--资源定位                                                           图3   getResourceByPath的调用关系
Spring IOC容器的初始化过程--资源定位
Spring IOC容器的初始化过程--资源定位
                                                 图4   getResourceByPath的调用过程我们重点AbstractRefreshableApplicationContext的refreshBeanFactory方法的实现。

AbstractRefreshableApplicationContext.class

    
    
    

  1. protected final void refreshBeanFactory() throws BeansException {
    2. 
     
     
  2. //这里判断，如果已经建立了BeanFactory，则销毁并关闭该工厂。
    3. 
     
     
  3. if (hasBeanFactory()) {
    4. 
     
     
  4. destroyBeans();
    5. 
     
     
  5. closeBeanFactory();
    6. 
     
     
  6. }
    7. 
     
     
  7. //创建并设置持有的DefaultListableBeanFactory的地方同时调用loadBeanDefinitions载入beandefinition信息
    8. 
     
     
  8. try {
    9. 
     
     
  9. DefaultListableBeanFactory beanFactory = createBeanFactory();
    10. 
     
     
  10. beanFactory.setSerializationId(getId());
    11. 
     
     
  11. customizeBeanFactory(beanFactory);
    12. 
     
     
  12. loadBeanDefinitions(beanFactory);
    13. 
     
     
  13. synchronized (this.beanFactoryMonitor) {
    14. 
     
     
  14. this.beanFactory = beanFactory;
    15. 
     
     
  15. }
    16. 
     
     
  16. }
    17. 
     
     
  17. catch (IOException ex) {
    18. 
     
     
  18. throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    19. 
     
     
  19. }
    20. 
     
     
  20. }
    21. 
     
     
  21. //在上下文中创建DefaultListableBeanFactory的地方载入bean定义，因为允许有多种载入方式，虽然用得最多的是XML定义的形式，
    22. 
     
     
  22. //这里通过一个抽象函数把具体的实现委托给子类来完成
    23. 
     
     
  23. protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
    24. 
     
     
  24. throws BeansException, IOException;
    25.

AbstractBeanDefinitionReader.class

    
    
    

  1. public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    2. 
     
     
  2. //这里取得ResourceLoader，使用的是DefaultResourceLoader
    3. 
     
     
  3. ResourceLoader resourceLoader = getResourceLoader();
    4. 
     
     
  4. if (resourceLoader == null) {
    5. 
     
     
  5. throw new BeanDefinitionStoreException(
    6. 
     
     
  6. "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    7. 
     
     
  7. }
    8. 
     
     
  8. //对Resource的路径模式进行解析，得到需要的Resource集合
    9. 
     
     
  9. if (resourceLoader instanceof ResourcePatternResolver) {
    10. 
     
     
  10. // Resource pattern matching available.
    11. 
     
     
  11. try {
    12. 
     
     
  12. Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
    13. 
     
     
  13. int loadCount = loadBeanDefinitions(resources);
    14. 
     
     
  14. if (actualResources != null) {
    15. 
     
     
  15. for (Resource resource : resources) {
    16. 
     
     
  16. actualResources.add(resource);
    17. 
     
     
  17. }
    18. 
     
     
  18. }
    19. 
     
     
  19. if (logger.isDebugEnabled()) {
    20. 
     
     
  20. logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
    21. 
     
     
  21. }
    22. 
     
     
  22. return loadCount;
    23. 
     
     
  23. }
    24. 
     
     
  24. catch (IOException ex) {
    25. 
     
     
  25. throw new BeanDefinitionStoreException(
    26. 
     
     
  26. "Could not resolve bean definition resource pattern [" + location + "]", ex);
    27. 
     
     
  27. }
    28. 
     
     
  28. }
    29. 
     
     
  29. else {
    30. 
     
     
  30. // Can only load single resources by absolute URL.
    31. 
     
     
  31. Resource resource = resourceLoader.getResource(location);
    32. 
     
     
  32. int loadCount = loadBeanDefinitions(resource);
    33. 
     
     
  33. if (actualResources != null) {
    34. 
     
     
  34. actualResources.add(resource);
    35. 
     
     
  35. }
    36. 
     
     
  36. if (logger.isDebugEnabled()) {
    37. 
     
     
  37. logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
    38. 
     
     
  38. }
    39. 
     
     
  39. return loadCount;
    40. 
     
     
  40. }
    41. 
     
     
  41. }
    42.

DefaultResourceLoader.class

    
    
    

  1. //对于取得Resource的具体过程，看DefaultResourceLoader是怎样完成的。
    2. 
     
     
  2. public Resource getResource(String location) {
    3. 
     
     
  3. Assert.notNull(location, "Location must not be null");
    4. 
     
     
  4. //这里处理带有classpath标识的Resource
    5. 
     
     
  5. if (location.startsWith("/")) {
    6. 
     
     
  6. return getResourceByPath(location);
    7. 
     
     
  7. }
    8. 
     
     
  8. else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
    9. 
     
     
  9. return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
    10. 
     
     
  10. }
    11. 
     
     
  11. else {
    12. 
     
     
  12. try {
    13. 
     
     
  13. //这里处理带有URL标识的Resource
    14. 
     
     
  14. URL url = new URL(location);
    15. 
     
     
  15. return new UrlResource(url);
    16. 
     
     
  16. }
    17. 
     
     
  17. catch (MalformedURLException ex) {
    18. 
     
     
  18. // No URL -> resolve as resource path.
    19. 
     
     
  19. //两者都不是，用此方法，默认得到一个ClassPathContextResource，这个方法常用子类来实现
    20. 
     
     
  20. //前面看到子类FilesystemXmlApplicationContext实现此方法，返回一个Filesystemresource。
    21. 
     
     
  21. return getResourceByPath(location);
    22. 
     
     
  22. }
    23. 
     
     
  23. }
    24. 
     
     
  24. }
    25.
                 其他ApplicationContext会对应生成其他种类的Resource。下图中我们可以看到Resource类的继承关系。
 Spring IOC容器的初始化过程--资源定位Spring IOC容器的初始化过程--资源定位                                                图5   Resource的定义和继承关系              我们通过对FilesystemXmlApplicationContext的实现原理为例，了解了Resource定位问题的解决方案。定位完成，接下来就是对返回的Resource对象进行载入了。接下来我们会介绍BeanDdfinition的载入和解析过程。
标签：

相关文章