Spring源码分析之 Spring IOC容器初始化过程（一）资源定位过程

最新推荐文章于 2024-06-28 14:54:26 发布

置顶味无味_

最新推荐文章于 2024-06-28 14:54:26 发布

阅读量3.4k

点赞数 26

分类专栏： Spring 文章标签： spring 源码 java ioc

本文链接：https://blog.csdn.net/i_wonder_how_/article/details/115315339

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Spring IOC容器初始化过程（一）资源定位过程

最近复习了一遍Spring IOC容器的初始化过程，结合书籍《Spring源码深度解析》总结了一下，IOC容器的初始化过程，大概分为以下三点：

定位资源

定位相关的配置文件，扫描相关注解
加载资源

将配置信息加载到内存中
注册

根据载入的配置信息，初始化对象，并将其装载至容器中

整体加载的时序图

工程目录

POM文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>springTest</artifactId>
    <version>1.0-SNAPSHOT</version>

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

</dependencies>
</project>

测试代码

public class ServiceB {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        Object serviceA = context.getBean("serviceA");
        System.out.println(serviceA);
    }
}

xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/cache
       http://www.springframework.org/schema/cache/spring-cache.xsd">

    <context:component-scan base-package="com.donkeys.spring"/>
    <bean id="serviceA" class="com.donkeys.spring.service.ServiceA"></bean>
</beans>

资源定位过程解析

代码中，使用的是ClassPathXmlApplicationContext类去加载Sping的配置文件，所以先给出该类类图

ClassPathXmlApplicationContext构造方法

	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

		super(parent);
		//根据传入的配置文件名称，调用父类的setConfigLocations方法，解析配置文件路径,
		setConfigLocations(configLocations);
		//refresh = true
		//refresh() 方法会重启整个容器
		if (refresh) {
			refresh();
		}
	}

构造方法中一共做了2件事，首先是设置配置文件的路径，然后对整个容器进行刷新。

这里我们重点关注refresh()方法；进入refresh()方法

AbstractApplicationContext类的refresh()方法

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      //为刷新前做准备
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      //获取IOC容器，这里就是处理资源定位以配置文件加载/注册的方法
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         initMessageSource();

         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // Check for listener beans and register them.
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

这里主要关注**obtainFreshBeanFactory()**方法

/**
 * Tell the subclass to refresh the internal bean factory.
 * @return the fresh BeanFactory instance
 * @see #refreshBeanFactory()
 * @see #getBeanFactory()
 */
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   //刷新IOC容器
   //这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory方法，具体调用实现调用子类的refreshBeanFactory方法
   refreshBeanFactory();
   //获取一个新的容器
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
   }
   return beanFactory;
}

**obtainFreshBeanFactory()**方法总共干了2件事，

重置容器，refreshBeanFactory()方法中会设置相关标志，清除旧的容器，同时为Spring上下文生成一个新的容器
获取一个新的容器

AbstractRefreshableApplicationContext的refreshBeanFactory()方法

下面我们进入**refreshBeanFactory()**方法

/**
 * This implementation performs an actual refresh of this context's underlying
 * bean factory, shutting down the previous bean factory (if any) and
 * initializing a fresh bean factory for the next phase of the context's lifecycle.
 * 该方法会将之前的bean工厂全部关闭，并初始化一个全新的bean 工厂类 用于Spring 上下文的生命周期
 * bean工厂就是IOC容器
 */
@Override
protected final void refreshBeanFactory() throws BeansException {
   //判断是否之前也有容器
   //如果有就销毁掉
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      //创建一个新的工厂
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      customizeBeanFactory(beanFactory);
      //读取Bean对象的定义
      //这里也是使用的委派设计模式
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

这里创建了新的容器工厂，同时将新的工厂传入了loadBeanDefinitions()方法中，下面来看一下在loadBeanDefinitions方法中具体做了什么操作。

AbstractXmlApplicationContext的 loadBeanDefinitions(DefaultListableBeanFactory beanFactory)方法

在AbstractRefreshableApplicationContext类的refreshBeanFactory方法中，调用了loadBeanDefinitions方法，但是这个方法它的一个抽象方法，具体实现应由子类去实现，我们在程序启动时，使用的ClassPathXmlApplicationContext类。根据文章开头的类图可以知道，这里会调用子类AbstractXmlApplicationContext的loadBeanDefinitions方法去完成本次加载

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
   // Create a new XmlBeanDefinitionReader for the given BeanFactory.
   //使用默认的beanFactory去创建 XmlBeanDefinitionReader
   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

   // Configure the bean definition reader with this context's
   // resource loading environment.
   //设置资源的加载环境
   beanDefinitionReader.setEnvironment(this.getEnvironment());
    //设置资源读取器
   beanDefinitionReader.setResourceLoader(this);
    //设置实体解析器
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

   // Allow a subclass to provide custom initialization of the reader,
   // then proceed with actually loading the bean definitions.
    //初始化 bean对象定义读取器
   initBeanDefinitionReader(beanDefinitionReader);
	//使用初始化完成的读取器，调用loadBeanDefinitions方法
   loadBeanDefinitions(beanDefinitionReader);
}

总的来说，这里只干了一件事，那就是初始化配置

//设置资源读取器
beanDefinitionReader.setResourceLoader(this);
//初始化 bean对象定义读取器
initBeanDefinitionReader(beanDefinitionReader);

设置资源读取器，这里设置的资源读取器就是当前这个对象本身

通过类图我们可以发现我们这个类的顶级父类ApplicationContext，继承自DefaultResourceLoader这个类，该类实现了ResourceLoader接口，说明这个类的实例化对象本身是具有资源读取器的功能的
初始化bean对象定义读取器，这里设置xml文件的校验方式

下面我们继续看**loadBeanDefinitions(XmlBeanDefinitionReader reader)**方法

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
   //从子类对象中获取到资源定位
   Resource[] configResources = getConfigResources();
   if (configResources != null) {
      //XmlBeanDefinitionReader 读取器调用其父类的
      reader.loadBeanDefinitions(configResources);
   }
   String[] configLocations = getConfigLocations();
   if (configLocations != null) {
      reader.loadBeanDefinitions(configLocations);
   }
}

先看这一行

//这行代码的具体实现是由子类完成的，通过类图可以知道AbstractXmlApplicationContext的子类为ClassPathXmlApplicationContext
//这里主要将我们最开始在构造方法中设置好的配置文件进行返回
Resource[] configResources = getConfigResources();

再看这一行

//如果返回的配置文件不为空，就将返回的已经封装好的资源文件进行读取，   
if (configResources != null) {
      //XmlBeanDefinitionReader 读取器调用其父类的
      reader.loadBeanDefinitions(configResources);
   }

至此。资源文件定位过程已经加载完成。后续就是读取和注册。整个IOC容器加载过程中最重要的是读取过程，我们可以从刚刚的定位过程来看，虽然叫定位过程，但是其实就是一个配置文件读取器的初始化过程，这个过程会设置相关的解析策略以及校验策略。最终读取器生成后，就可以将我们早早设置好的配置文件载入然后进行读取。

味无味_

关注

26
点赞
踩
42

收藏

觉得还不错? 一键收藏
20
评论
Spring源码分析之 Spring IOC容器初始化过程（一）资源定位过程

Spring IOC容器初始化过程（一）资源定位过程最近复习了一遍Spring IOC容器的初始化过程，结合书籍《Spring源码深度解析》总结了一下，IOC容器的初始化过程，大概分为以下三点：定位资源定位相关的配置文件，扫描相关注解加载资源将配置信息加载到内存中注册根据载入的配置信息，初始化对象，并将其装载至容器中整体加载的时序图工程目录POM文件<?xml version="1.0" encoding="UTF-8"?><project x
复制链接

扫一扫