【Spring源码】IOC容器实现(1)--IOC容器结构体系

系统管理员 2022-05-19 23:17 291阅读 0赞

# 前言 #

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

# 一 什么是IOC/DI #

依赖反转表示的是依赖对象的获得被反转了，也叫做依赖注入(DI)。

如果合作对象的引用或依赖关系的管理由具体对象来完成，会导致代码的高耦合和可测试性降低，

对于复杂的面向对象设计非常不利。可以把传统对象依赖注入交由IOC容器来完成，这种从具体对象

手中交出控制的做法就是依赖反转，也就是对象的控制权被反转了，以前是**对象--》对象**，

现在是**对象--》容器--》对象**，对象与对象之间不直接依赖注入，而是通过容器控制依赖注入。

这种实现方式可以解耦代码，同时提高代码的可测试性。

而IOC(Invesion Of Control)容器是依赖反转这种思想的一个具体实现，是Spring框架的核心。

# 二 Spring IOC结构 #

## 1、 Spring IOC容器序列 ##

在Spring IOC容器设计中，主要有两个容器序列，一个是实现BeanFactory接口的简单容器序列，

这个容器是最基本的容器，因为只是实现了容器最基本的功能；另外一个容器是ApplicationContext

引用上下文，这是一个高级形态容器，因为它实现了具有更多功能的接口，功能更丰富。

BeanFactory和ApplicationContext是容器的具体表现形式。深入Spring中可以看到各种各样的实现，

代表着各种各样的容器产品，各有特色。就像生活中的水桶一样，有金属的、塑料的等等，各色各样，

但这些水桶都具备一个特征，就是能装水，只要能装水，它就是一只可以用来售卖的水桶。在Spring中

也一样，Spring实现了各种各样的容器，供用户选择和使用。用什么样的容器，取决于用户需要。

但是在使用前，了解容器的基本情况，对我们理解和使用容器都有很大的帮助。就像买水桶一样，货比三家，

多看看桶的情况，才能买到物美价廉的水桶。只有了解Spring容器，才能得心应手，恰到好处的使用容器。

## 2、Spring IOC容器设计 ##

在深入理解IOC容器实现前，需要先了解下**IOC容器重要的接口设计图。**

![70][]

以一下对这些接口进行简单说明。

1）从接口BeanFactory到HierarchicalBeanFactory，再到ConfigurableBeanFactory，是一条主要的BeanFactory设计路径。

在这条接口设计路径中，BeanFactory定义了基本的IOC容器规范。

**BeanFactory接口**

该接口中包含了getBean()这样的IOC容器的基本方法；

**HierarchicalBeanFactory接口**

该接口继承了BeanFactory接口，增加了getParentBeanFactory()方法，使BeanFactory具备了双亲IOC的管理功能。

**ConfigurableBeanFactory接口**

该接口继承了HierarchicalBeanFactory，主要定义了一些对BeanFactory的配置功能，比如通过setParentBeanFactory()

设置双亲IOC容器，通过addBeanPostProcessor()配置Bean的后置处理器等等。通过这些接口设计的叠加，定义了

BeanFactory就是简单IOC容器的基本功能。

2）以ApplicationContext为核心的接口设计，为第二条接口设计路线，主要涉及接口从BeanFactory到ListableBeanFactory，

再到ApplicationContext，再到WebApplicationContext或者ConfigurableApplicationContext接口。

ApplicationContext源码：

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
    		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    		......
    }

在这个接口体系中，ListableBeanFactory和HierarchicalBeanFactory两个接口，连接BeanFactory接口和

ApplicationContext接口定义。ListableBeanFactory细化了BeanFactory接口功能，比如getBeanDefinitionNames（）

获取bean数组。同时，ApplicationContext接口继承了MessageSource等，增加了很多高级特性。

3）这里涉及的是主要的接口关系，而具体的IOC容器都是在这些接口下实现的，比如DefaultListableBeanFactory，

这个接口间接实现了ConfigurableBeanFactory接口，从而成为一个简单IOC容器实现。可以理解为主要接口定义了

IOC的骨架，相应IOC容器去做实现。

4）这个接口体系以BeanFactory和ApplicationContext为核心。

BeanFactory为IOC容器最基本的接口，ApplicationContext为IOC容器的高级形态接口。

以下分别去分析BeanFactory和ApplicationContext。

## 3、BeanFactory ##

### 3.1 BeanFactory应用场景 ###

BeanFactory接口定义了IOC容器最基本的形式，并且提供了IOC容器所应该遵守的最基本的服务契约和

最基本的编程规范，这些接口勾画出IOC的基本轮廓。

**BeanFactory如何定义IOC容器的基本接口？**

用户使用容器时，可以通过转义符"&"来得到FactoryBean本身，用来区分通过容器来获取FactoryBean产生的对象

和获取FactoryBean本身。

关于BeanFactory和FactoryBean区别参考：[Spring中BeanFactory和FactoryBean区别][Spring_BeanFactory_FactoryBean]

**先看下BeanFactory的源代码：**

package org.springframework.beans.factory;
    import org.springframework.beans.BeansException;
    import org.springframework.core.ResolvableType;
    public interface BeanFactory {
    	String FACTORY_BEAN_PREFIX = "&";
    	/**
    	 * 根据Bean的名字从IOC容器获取Bean。
    	Object getBean(String name) throws BeansException;
    	/**
    	 * 根据Bean的名字和Bean的Class类型从IOC容器获取Bean。
    	 */
    	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
    	/**
    	 * 根据Bean的Class类型从IOC容器获取Bean。
    	 */
    	<T> T getBean(Class<T> requiredType) throws BeansException;
    	/**
    	 * 根据Bean的名字和Bean构造器参数类型从IOC容器获取Bean。
    	 */
    	Object getBean(String name, Object... args) throws BeansException;
    	/**
    	 * 根据Bean的Class类型和Bean构造器参数类型从IOC容器获取Bean。
    	 */
    	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    	/**
    	 * 根据Bean的名字判断IOC容器是否含有该Bean。
    	 */
    	boolean containsBean(String name);
    	/**
    	 * 根据Bean的名字判断是否是Singleton类型。
    	 */
    	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    	/**
    	 * 根据Bean的名字判断是否是Prototype类型。
    	 */
    	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    	/**
    	 * 根据Bean的名字和Bean的泛型类型，判断Bean是否是指定的Class类型。
    	 */
    	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    	/**
    	 * 根据Bean的名字和Bean的Class类型，判断Bean是否是指定的Class类型。
    	 */
    	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    	/**
    	 * 根据Bean的名字获取Class类型。
    	 */
    	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    	/**
    	 * 根据Bean的名字获取Bean对应的所有别名。
    	 */
    	String[] getAliases(String name);
    }

BeanFactory接口方法勾画了IOC容器的基本特性。通过这一序列的BeanFactory接口，可以使用不同的Bean的检索

方法，很方便的从IOC容器中得到需要的Bean，这些检索方法代表了IOC最基本的容器入口。

### **3.2 BeanFactory容器设计原理** ###

BeanFactory接口提供了使用IOC容器的规范。在这个基础上提供了一系列的容器实现供使用。

这里以XmlBeanFactory为例，设计关系图如下：

![70 1][]

**XmlBeanFactory源码：**

package org.springframework.beans.factory.xml;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.support.DefaultListableBeanFactory;
    import org.springframework.core.io.Resource;
    @Deprecated
    @SuppressWarnings({"serial", "all"})
    public class XmlBeanFactory extends DefaultListableBeanFactory {
    	private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
    	public XmlBeanFactory(Resource resource) throws BeansException {
    		this(resource, null);
    	}
    	public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
    		super(parentBeanFactory);
    		this.reader.loadBeanDefinitions(resource);
    	}
    }

**XmlBeanFactory创建过程：**

1）基于将要读取的xml文件，构建一个Resource对象作为XmlBeanFactory的构造器参数创建XmlBeanFactory。

ClassPathResource res = new ClassPathResource("beans.xml");
    XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(res);

2）通过XmlBeanDefinitionReader的loadBeanDefinitions()调用处理从Resource中载入BeanDefinitions的过程，

loadBeanDefinitions是IOC容器初始化的重要组成部分，最后IOC容器会基于BeanDefinitions完成容器初始化和

依赖注入的过程，这里只是简单介绍下，以下会深入源码分析IOC容器的初始化和依赖注入细节。

**IOC容器建立的基本步骤：**

先看下通过编程式方式使用IOC容器过程:

ClassPathResource res = new ClassPathResource("beans.xml");
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
    reader.loadBeanDefinitions(res);

参考代码可以看到使用IOC容器主要经历了以下几个步骤：

1）创建IOC配置文件的抽象资源，资源包含了BeanDefinition的定义信息。

2）创建一个BeanFactory，这里使用DefaultListableBeanFactory。

3）创建一个载入BeanDefinition的读取器，这里使用XmlBeanDefinitionReader来载入XML文件形式的BeanDefinition。

4）XmlBeanDefinitionReader解析资源，完成Bean的载入和注册，建立起IOC容器，这个时候就可用了。

## 4、ApplicationContext ##

### 4.1 ApplicationContext的应用场景 ###

ApplicationContext是必BeanFactory更高级形态的容器，提供了很多BeanFactory不具备的功能。

当你决定要自己实现一个IOC容器之前，先看看Spring容器树上有没有心仪的对象。

**ApplicationContext类结构图:**

![70 2][]

**基于类图，说明ApplicationContext新特性：**

1）支持不同的信息源。扩展了MessageSource接口，支持国际化的实现，为开发多语言版本提供服务。

2）访问资源。扩展了ResourcePatternResolver，而ResourcePatternResolver扩展自ResourceLoader，

而ResourceLoader含Resource属性，通过这两个类的支持，我们可以从不同的地方获取Bean定义资源。

3）支持应用事件。扩展了ApplicationEventPublisher，从而在上下文中引入了事件机制。这些事件机制

与Bean的生命周期的结合为Bean管理提供了便利。

ApplicationContext与BeanFactory相比，功能更丰富，应用开发中一般以ApplicationContext作为容器的

基本形式。

### 4.2 ApplicationContext容器的设计原理 ###

以ClassPathXmlApplicationContext为例应用：

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

ClassPathXmlApplicationContext源码：

package org.springframework.context.support;
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.core.io.Resource;
    import org.springframework.util.Assert;
    
    public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
    	private Resource[] configResources;
    
    	public ClassPathXmlApplicationContext() {
    	}
    
    	public ClassPathXmlApplicationContext(ApplicationContext parent) {
    		super(parent);
    	}
    
    	public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    		this(new String[] {configLocation}, true, null);
    	}
    
    	public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
    		this(configLocations, true, null);
    	}
    
    	public ClassPathXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException {
    		this(configLocations, true, parent);
    	}
    
    	public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
    		this(configLocations, refresh, null);
    	}
    
    	public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    			throws BeansException {
    
    		super(parent);
    		setConfigLocations(configLocations);
    		if (refresh) {
    			refresh();
    		}
    	}
    	
    	public ClassPathXmlApplicationContext(String path, Class<?> clazz) throws BeansException {
    		this(new String[] {path}, clazz);
    	}
    	
    	public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz) throws BeansException {
    		this(paths, clazz, null);
    	}
    	
    	public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, ApplicationContext parent)
    			throws BeansException {
    
    		super(parent);
    		Assert.notNull(paths, "Path array must not be null");
    		Assert.notNull(clazz, "Class argument must not be null");
    		this.configResources = new Resource[paths.length];
    		for (int i = 0; i < paths.length; i++) {
    			this.configResources[i] = new ClassPathResource(paths[i], clazz);
    		}
    		refresh();
    	}
    	
    	@Override
    	protected Resource[] getConfigResources() {
    		return this.configResources;
    	}
    }

构造器传入XML最后会调用到如下构造器：

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
    			throws BeansException {
    	super(parent);
    	setConfigLocations(configLocations);
    	if (refresh) {
    	    refresh();
    	}
    }

最后会调用refresh()方法，这个方法就是IOC容器启动的入口，IOC容器里面进行了一序列复杂的操作，

这也是通往IOC容器核心实现原理的入口。

[https_github.com_yihonglei_thinking-in-spring]: https://github.com/yihonglei/thinking-in-spring
[70]: /images/20220520/44c8c114d31741bbacc40b3c7edcd00e.png
[Spring_BeanFactory_FactoryBean]: https://blog.csdn.net/yhl_jxy/article/details/80991201
[70 1]: /images/20220520/20835fb284fa45a793bc979c984ca6ad.png
[70 2]: /images/20220520/921801b4f3a849e78305000055757a26.png