【Spring源码】IOC容器实现(2)--BeanDefinition的Resource定位

柔光的暖阳◎ 2022-05-20 04:55 195阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/thinking-in-spring][https_github.com_yihonglei_thinking-in-spring]

# 一 IOC容器初始化过程概述 #

IOC容器初始化是由上文提到的refresh()方法来启动的，这个方法标志着IOC容器正式启动。

IOC容器初始化过程分为三个过程：

**1）BeanDefinition的Resource定位过程。**

这个Resource定位是指BeanDefinition资源定位，它由ResourceLoader通过统一的Resource

接口完成。这个定位过程就是容器寻找数据的过程，就像水桶要装水首先需要找到水一样。

**2）BeanDefinition的载入和解析过程。**

这个过程就是根据上一步定位的Resource资源文件，把用户定义好的Bean表示成IOC容器内部的

BeanDefinition数据结构。BeanDefinition实际就是POJO对象在IOC容器中的抽象，通过BeanDefinition

定义数据结构，使IOC容器能够方便地对POJO对象也就是Bean进行管理。

**3）向IOC容器注册BeanDefinition的过程。**

这个过程是通过调用BeanDefinitionRegistry接口的实现来完成的，把载入过程生成的BeanDefinition向

IOC容器注册。最终在IOC容器内部将BeanDefinition注入到一个HashMap中，IOC容器就是通过这个

HashMap来持有这些BeanDefinition数据的。

**注意：**

这里需要注意的是，上面谈到的只是IOC容器的初始化过程，这个过程一般不包含Bean依赖注入的实现。

Bean的定义和依赖注入是两个独立的过程。依赖注入一般发生在第一次getBean()向容器索要Bean的时候，

但是如果配置了lazyinit，则初始化的时候这样的Bean已经触发了依赖注入。

这里先分析IOC容器的第一个过程，**BeanDefinition的Resource定位过程。**

# 二 **BeanDefinition的Resource定位过程** #

一般我们通常使用的IOC容器有FileSystemXmlApplicationContext、ClassPathXmlApplicationContext、

XmlWebApplicationContext、WebApplicationContext、AnnotationConfigApplicationContext等。

注解方式AnnotationConfigApplicationContext前置读取资源跟Xml方式容器有区别，

注解方式AnnotationConfigApplicationContext是读取指定扫描包下的.class，组装成元数据，然后解析每个类，

判断是否有@Component注解（@Service含@Component注解）进行BeanDefinition数据结构读取，

Xml方式则是解析Spring配置的applicationContext.xml的文件，读取BeanDefinition数据结构，

但是最后都走AbstractApplicationContext\#refresh()模板方法，理解了Xml实现方式容器的核心，

注解方式就比较好理解。

因为Xml实现方式理解IOC容器会更直观些，以Xml方式实现进行IOC容器源码解读。

下面以FileSystemXmlApplicationContext为例，分析Resource的定位过程。

**FileSystemXmlApplicationContext应用：**

// 根据配置文件创建IOC容器
    ApplicationContext context =
         new FileSystemXmlApplicationContext("classpath:applicationContext.xml");
    // 从容器中获取Bean
    ConferenceServiceImpl conferenceService = (ConferenceServiceImpl)context.getBean("conferenceService");
    // 调用Bean方法
    conferenceService.conference();

**FileSystemXmlApplicationContext类图：**

**![70][]**

"实线"代表extends，"虚线"代表implements。从类图可以看到继承了ApplicationContext，而ApplicationContext

又继承了BeanFactory，所以FileSystemXmlApplicationContext具备了IOC的基本规范和一些高级特性。

在类图的最右上方可以看到继承了ResourceLoader，用以读入以Resource定义的BeanDefinition的能力。

**FileSystemXmlApplicationContext源码：**

package org.springframework.context.support;
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.core.io.FileSystemResource;
    import org.springframework.core.io.Resource;
    
    public class FileSystemXmlApplicationContext extends AbstractXmlApplicationContext {
    	public FileSystemXmlApplicationContext() {
    	}
    	public FileSystemXmlApplicationContext(ApplicationContext parent) {
    		super(parent);
    	}
    	/**
    	 * 根据用户定义的Bean XML文件路径，载入BeanDefinition，自动创建IOC容器
    	 */
    	public FileSystemXmlApplicationContext(String configLocation) throws BeansException {
    		this(new String[] {configLocation}, true, null);
    	}
    	/**
    	 * 根据用户定义的多个Bean XML文件路径，载入BeanDefinition，自动创建IOC容器
    	 */
    	public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {
    		this(configLocations, true, null);
    	}
    	/**
    	 * 根据用户定义的多个Bean XML文件路径，载入BeanDefinition，自动创建IOC容器，允许指定自己的双亲IOC容器
    	 */
    	public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
    		this(configLocations, true, parent);
    	}
    	/**
    	 * 是否允许自动刷新上下文
    	 */
    	public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
    		this(configLocations, refresh, null);
    	}
    	/**
    	 * 在对象初始化的过程中，调用refresh()方法启动载入BeanDefinition过程
    	 */
    	public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    			throws BeansException {
    		super(parent);
    		setConfigLocations(configLocations);
    		if (refresh) {
    			refresh();
    		}
    	}
    	/**
    	 * 根据用户的xml构建Resource对象，这是一个模板方法，
    	 * 在BeanDefinitionReader的loadBeanDefinition()方法中被调用。
    	 */
    	@Override
    	protected Resource getResourceByPath(String path) {
    		if (path != null && path.startsWith("/")) {
    			path = path.substring(1);
    		}
    		return new FileSystemResource(path);
    	}
    }

FileSystemXmlApplicationContext中有很多构造函数，实现了对参数configLocation进行处理，以XML文件方式

存在的BeanDefinition能够得到有效处理。比如，实现了getResourceByPath()方法，这个是一个模板方法，是为

读取Resource服务的。在初始化FileSystemXmlApplicationContext的过程中，通过refresh()来启动整个调用，

进入AbstractApplicationContext的refresh()方法。

**AbstractApplicationContext.refresh()方法源码：**

@Override
    public void refresh() throws BeansException, IllegalStateException {
    	synchronized (this.startupShutdownMonitor) {
    		// Prepare this context for refreshing.
    		// 调用容器准备刷新的方法，设置容器的启动时间为当前时间，容器关闭状态为false，同时给容器设置同步标识
    		prepareRefresh();
    
    		// Tell the subclass to refresh the internal bean factory.
    		// 告诉子类启动refreshBeanFactory()方法，
    		// Bean定义资源文件的载入从子类的refreshBeanFactory()方法启动[***重点***]
    		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    		// Prepare the bean factory for use in this context.
    		// 为BeanFactory配置容器特性，例如类加载器、事件处理器等
    		prepareBeanFactory(beanFactory);
    
    		try {
    			// Allows post-processing of the bean factory in context subclasses.
    			// 为容器的某些子类指定特殊的BeanPost事件处理器，进行后置处理
    			postProcessBeanFactory(beanFactory);
    
    			// Invoke factory processors registered as beans in the context.
    			// 调用BeanFactory的后置处理器，这些后置处理器是在Bean定义中向容器注册的
    			invokeBeanFactoryPostProcessors(beanFactory);
    
    			// Register bean processors that intercept bean creation.
    			// 为BeanFactory注册BeanPost事件处理器，BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件
    			registerBeanPostProcessors(beanFactory);
    
    			// Initialize message source for this context.
    			// 初始化信息源，和国际化相关
    			initMessageSource();
    
    			// Initialize event multicaster for this context.
    			// 初始化容器事件传播器
    			initApplicationEventMulticaster();
    
    			// Initialize other special beans in specific context subclasses.
    			// 调用子类的某些特殊Bean初始化方法
    			onRefresh();
    
    			// Check for listener beans and register them.
    			// 检查监听Bean并且将这些Bean向容器注册
    			registerListeners();
    
    			// Instantiate all remaining (non-lazy-init) singletons.
    			// 初始化所有剩余的(non-lazy-init)单态Bean
    			finishBeanFactoryInitialization(beanFactory);
    
    			// Last step: publish corresponding event.
    			// 初始化容器的生命周期事件处理器，并发布容器的生命周期事件，结束refresh过程
    			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();
    		}
    	}
    }

上面refresh()方法的源码，是整个IOC容器初始化的过程。咱们这里讨论的是BeanDefinition的Resource资源的定位，

重点关注refresh()方法中的obtainFreshBeanFactory()方法，该方法也位于AbstractApplicationContext类中。

**AbstractApplicationContext.obtainFreshBeanFactory()方法源码：**

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    	refreshBeanFactory();
    	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    	if (logger.isDebugEnabled()) {
    		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    	}
    	return beanFactory;
    }

在上面的obtainFreshBeanFactory()方法中可以看到refreshBeanFactory()方法，是AbstractApplicationContext中的

一个抽象方法，委托给子类具体实现，方法签名如下：

protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

方法的具体实现在AbstractRefreshableApplicationContext中。

**AbstractRefreshableApplicationContext.refreshBeanFactory()源码：**

@Override
    protected final void refreshBeanFactory() throws BeansException {
    	// 判断如果已经建立了BeanFactory，则销毁并关闭BeanFactory
    	if (hasBeanFactory()) {
    		destroyBeans();
    		closeBeanFactory();
    	}
    	try {
    	       // 创建IoC容器，这里使用的是DefaultListableBeanFactory
    		DefaultListableBeanFactory beanFactory = createBeanFactory();
    		// 对IoC容器进行定制化，如设置启动参数，开启注解的自动装配等
    		beanFactory.setSerializationId(getId());
    		customizeBeanFactory(beanFactory);
    		/**
    		 * 启动对BeanDefinition的载入，这里使用了一个委派模式，
    		 * 在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器
    		 */
    		loadBeanDefinitions(beanFactory);
    		synchronized (this.beanFactoryMonitor) {
    			this.beanFactory = beanFactory;
    		}
    	}
    	catch (IOException ex) {
    		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    	}
    }

在refreshBeanFactory()方法中，可以看到loadBeanDefinitions()是AbstractRefreshableApplicationContext中的

一个抽象方法，委托给子类具体实现，方法签名如下：

protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
    			throws BeansException, IOException;

loadBeanDefinitions()抽象方法有多个实现：

![70 1][]

从FileSystemXmlApplicationContext类图，可以知道选择AbstractXmlApplicationContext中的实现，

因为另外三个与FileSystemXmlApplicationContext没有关系。

**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.
    	// 使用此上下文的资源加载环境配置Bean定义读取器
    	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(beanDefinitionReader);
    }

继续调用loadBeanDefinitions()，咱们现在目标就是定位BeanDEfinition的Resource看下方法源码：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) 
    	throws BeansException, IOException {
    	// 以Resource的方式获得配置文件的资源位置
    	Resource[] configResources = getConfigResources();
    	if (configResources != null) {
    		reader.loadBeanDefinitions(configResources);
    	}
    	// 以String的形式获得配置文件位置
    	String[] configLocations = getConfigLocations();
    	if (configLocations != null) {
    		reader.loadBeanDefinitions(configLocations);
    	}
    }

对于FileSystemXmlApplicationContext会走第二个if判断， 接着看源码。

**AbstractBeanDefinitionReader.loadBeanDefinitions()方法源码：**

@Override
    public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
    	// 如果locations为空，则停止Resource资源定位
    	Assert.notNull(locations, "Location array must not be null");
    	int counter = 0;
    	for (String location : locations) {
    		// 根据路径载入信息
    		counter += loadBeanDefinitions(location);
    	}
    	return counter;
    }

**loadBeanDefinitions()方法继续深入：**

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    	// 这里得到当前定义的ResourceLoader,默认的使用DefaultResourceLoader
    	ResourceLoader resourceLoader = getResourceLoader();
    	if (resourceLoader == null) {
    		throw new BeanDefinitionStoreException(
    				"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    	}
    	/**
    	  * 这里对Resource的路径模式进行解析，得到需要的Resource集合，
    	  * 这些Resource集合指向了我们定义好的BeanDefinition的信息，可以是多个文件。
    	  */
    	if (resourceLoader instanceof ResourcePatternResolver) {
    		// Resource pattern matching available.
    		try {
    			// 调用DefaultResourceLoader的getResources完成具体的Resource定位
    			Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
    			int loadCount = loadBeanDefinitions(resources);
    			if (actualResources != null) {
    				for (Resource resource : resources) {
    					actualResources.add(resource);
    				}
    			}
    			if (logger.isDebugEnabled()) {
    				logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
    			}
    			return loadCount;
    		}
    		catch (IOException ex) {
    			throw new BeanDefinitionStoreException(
    					"Could not resolve bean definition resource pattern [" + location + "]", ex);
    		}
    	}
    	else {
    		// Can only load single resources by absolute URL.
    		// 通过ResourceLoader来完成位置定位
    		Resource resource = resourceLoader.getResource(location);
    		int loadCount = loadBeanDefinitions(resource);
    		if (actualResources != null) {
    			actualResources.add(resource);
    		}
    		if (logger.isDebugEnabled()) {
    			logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
    		}
    		return loadCount;
    	}
    }

ResourceLoader是一个接口类，其getResource()方法具体实现在DefaultResourceLoader，对于取得Resource的具体过程，

我们可以看下DefaultResourceLoader中getResource()方法的实现。

**DefaultResourceLoader.getResource()源码：**

public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
        Iterator var2 = this.protocolResolvers.iterator();
    
        Resource resource;
        do {
            if (!var2.hasNext()) {
    			// 处理所有/标识的Resource
                if (location.startsWith("/")) {
                    return this.getResourceByPath(location);
                }
    			// 处理所有带有classpath标识的Resource
                if (location.startsWith("classpath:")) {
                    return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader());
                }
    
                try {
    				// 处理URL标识的Resource定位
                    URL url = new URL(location);
                    return new UrlResource(url);
                } catch (MalformedURLException var5) {
                    return this.getResourceByPath(location);
                }
            }
    
            ProtocolResolver protocolResolver = (ProtocolResolver)var2.next();
            resource = protocolResolver.resolve(location, this);
        } while(resource == null);
    
        return resource;
    }

在getResources()方法中，最显眼的是getResourceByPath()方法，在一开始的时候提到过，它是一个模板方法，

**DefaultResourceLoader.getResourceByPath()源码：**

protected Resource getResourceByPath(String path) {
    	return new ClassPathContextResource(path, getClassLoader());
    }

**DefaultResourceLoader.****getResourceByPath****()实现类：**

**![70 2][]**

其中一个实现类就是FileSystemXmlApplicationContext，其方法签名如下：

@Override
    protected Resource getResourceByPath(String path) {
    	if (path != null && path.startsWith("/")) {
    		path = path.substring(1);
    	}
    	return new FileSystemResource(path);
    }

通过该方法，返回一个FileSystemResource对象，该对象扩展自Resource，而Resource扩展自InputStreamSource。

**FileSystemResource构造器：**

public FileSystemResource(String path) {
        Assert.notNull(path, "Path must not be null");
        this.file = new File(path);
        this.path = StringUtils.cleanPath(path);
    }

**FileSystemResource类图：**

![70 3][]

**getResourceByPath方法调用过程：**

**![70 4][]**

通过FileSystemResource对象，**Spring可以进行相关的I/O操作，完成BeanDefinition的Resource定位过程**。

这里只是分析了FileSystemXmlApplicationContext的容器下Resource定位过程，

如果是其他的ApplicationContext，那么对应生成其他的Resource，比如ClassPathResource、

ServletContextResource等。关于Spring中Resource的种类，继承关系如下：

![70 5][]

这些接口对应不同的Resource实现代表着不同的一样。

以FileSystemXmlApplicationContext容器实现原理为例，上面只是分析了BeanDefinition的Resource定位过程，

这个时候可以通过Resource对象来进行BeanDefinition的载入了。这里完成了水桶装水找水的过程，下一篇分析一下

水桶装水的过程，也即[BeanDefinition的载入和解析过程][BeanDefinition]**。**

# **参考文献：** #

**1、《Spring技术内幕》**

**2、《Spring实战》**

**3、Spring官网API**

**4、Spring源码**

[https_github.com_yihonglei_thinking-in-spring]: https://github.com/yihonglei/thinking-in-spring
[70]: /images/20220520/d0ab772b66b84bda8198bc95655e3988.png
[70 1]: /images/20220520/8b966bd47eeb41749a73068f1fa16f65.png
[70 2]: /images/20220520/2112c3d5c6b6441a83a16fa9f5894b10.png
[70 3]: /images/20220520/3d1dec4423ee4406837d03505386cc18.png
[70 4]: /images/20220520/7a0b17952ef84b838c99c3578821dc0c.png
[70 5]: /images/20220520/4ce53e23692a45f1966dab964df410c2.png
[BeanDefinition]: https://blog.csdn.net/yhl_jxy/article/details/81027248