Spring IOC ：相关接口分析手写简易 Spring IOC
Posted Henrik-Yao
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring IOC ：相关接口分析手写简易 Spring IOC相关的知识，希望对你有一定的参考价值。
文章目录
Spring IOC 相关接口分析
1.BeanFactory
Spring 中 Bean 的创建是典型的工厂模式，这一系列的 Bean 工厂，即 IOC 容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在 Spring 中有许多 IOC 容器的实现供用户选择，其相互关系如下图所示
其中，BeanFactory 作为最顶层的一个接口，定义了 IOC 容器的基本功能规范，BeanFactory 有三个重要的子接口：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory，但是从类图中可以发现最终的默认实现类是DefaultListableBeanFactory，它实现了所有的接口
每个接口都有它的使用场合，主要是为了区分在 Spring 内部操作过程中对象的传递和转化，对对象的数据访问所做的限制
- ListableBeanFactory 接口表示这些Bean可列表化
- HierarchicalBeanFactory 表示这些Bean 是有继承关系的，也就是每个 Bean 可能有父 Bean
- AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则
BeanFactory 源码
public interface BeanFactory
String FACTORY_BEAN_PREFIX = "&";
//根据bean的名称获取IOC容器中的的bean对象
Object getBean(String name) throws BeansException;
//根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
//判断容器中是否包含指定名称的bean对象
boolean containsBean(String name);
//根据bean的名称判断是否是单例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
在 BeanFactory 里只对 IOC 容器的基本行为做了定义，根本不关心 Bean 是如何定义及怎样加载的，也就是说只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的
BeanFactory 有一个很重要的子接口，就是 ApplicationContext 接口，该接口主要来规范容器中的 Bean 对象是非延时加载，即在创建容器对象的时候就对象 Bean 进行初始化，并存储到一个容器中
要知道工厂是如何产生对象的，需要看具体的 IOC 容器实现，Spring 提供了许多 IOC 容器实现，比如：
- ClasspathXmlApplicationContext : 根据类路径加载 xml 配置文件，并创建 IOC 容器对象
- FileSystemXmlApplicationContext ：根据系统路径加载 xml 配置文件，并创建 IOC 容器对象
- AnnotationConfigApplicationContext ：加载注解类配置，并创建 IOC 容器
2.BeanDefinition
Spring IOC 容器管理我们定义的各种 Bean 对象及其相互关系，而 Bean 对象在 Spring 实现中是以 BeanDefinition 来描述的
3.BeanDefinitionReader
Bean 的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。Bean 的解析主要就是对 Spring 配置文件的解析。这个解析过程主要通过 BeanDefinitionReader 来完成
BeanDefinitionReader源码
public interface BeanDefinitionReader
//获取BeanDefinitionRegistry注册器对象
BeanDefinitionRegistry getRegistry();
@Nullable
ResourceLoader getResourceLoader();
@Nullable
ClassLoader getBeanClassLoader();
BeanNameGenerator getBeanNameGenerator();
/*
下面的loadBeanDefinitions都是加载bean定义，从指定的资源中
*/
int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
4.BeanDefinitionRegistry
BeanDefinitionReader 用来解析 Bean 定义，并封装 BeanDefinition 对象，而配置文件中定义了很多 Bean 标签，所以就有一个问题，解析的 BeanDefinition 对象存储到哪儿？答案就是 BeanDefinition 的注册中心，而该注册中心顶层接口就是 BeanDefinitionRegistry
BeanDefinitionRegistry 源码
public interface BeanDefinitionRegistry extends AliasRegistry
//往注册表中注册bean
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
//从注册表中删除指定名称的bean
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//获取注册表中指定名称的bean
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//判断注册表中是否已经注册了指定名称的bean
boolean containsBeanDefinition(String beanName);
//获取注册表中所有的bean的名称
String[] getBeanDefinitionNames();
int getBeanDefinitionCount();
boolean isBeanNameInUse(String beanName);
5. 创建容器
ClassPathXmlApplicationContex t对 Bean 配置资源的载入是从 refresh() 方法开始的。refresh() 方法是一个模板方法，规定了 IOC 容器的启动流程，有些逻辑要交给其子类实现。它对 Bean 配置资源进行载入，ClassPathXmlApplicationContext 通过调用其父类 AbstractApplicationContext的refresh() 方法启动整个 IOC 容器对 Bean 定义的载入过程
自定义 Spring IOC
现要对下面的配置文件进行解析，并自定义 Spring 框架的 IOC 对涉及到的对象进行管理
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userService" class="com.henrik.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.henrik.dao.impl.UserDaoImpl"></bean>
</beans>
1.定义 Bean 相关的 pojo 类
PropertyValue类
用于封装 Bean 的属性，就是封装 Bean 标签的子标签 property 标签数据
package com.henrik.framework.beans;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
// 用于封装 Bean 标签下的 property 标签的属性
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PropertyValue
private String name;
private String value;
private String ref;
MutablePropertyValues
一个bean标签可以有多个 property 子标签，所以再定义一个 MutablePropertyValues 类，用来存储并管理多个 PropertyValue 对象
package com.henrik.framework.beans;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
// 用来存储和管理多个 PropertyValue 对象
// 使用迭代器模式
public class MutablePropertyValues implements Iterable<PropertyValue>
// 定义 list 集合对象，用于存储 PropertyValue 对象
private final List<PropertyValue> propertyValueList;
public MutablePropertyValues()
propertyValueList = new ArrayList<PropertyValue>();
public MutablePropertyValues(List<PropertyValue> propertyValueList)
if(propertyValueList == null)
this.propertyValueList = new ArrayList<PropertyValue>();
else
this.propertyValueList = propertyValueList;
// 获取所有的 PropertyValue 对象，返回以数组的形式
public PropertyValue[] getPropertyValues()
// 将集合转化为数组并返回
return propertyValueList.toArray(new PropertyValue[0]);
// 根据 name 属性值获取 PropertyValue 对象
public PropertyValue getPropertyValue(String propertyName)
// 遍历集合对象
for (PropertyValue propertyValue : propertyValueList)
if (propertyValue.getName().equals(propertyName))
return propertyValue;
return null;
// 判断集合是否为空
public boolean isEmpty()
return propertyValueList.isEmpty();
// 添加 PropertyValue 对象
// 返回当前对象的目的是实现链式编程
public MutablePropertyValues addPropertyValue(PropertyValue pv)
// 判断集合中存储的 PropertyValue 对象是否和传递进来的重复
for (int i = 0; i < propertyValueList.size(); i++)
// 获取集合中每一个 PropertyValue 对象
PropertyValue currentPv = propertyValueList.get(i);
if (currentPv.getName().equals(pv.getName()))
propertyValueList.set(i, pv);
return this;
this.propertyValueList.add(pv);
return this;
// 判断是否有指定 name 属性值的对象
public boolean contains(String propertyName)
return getPropertyValue(propertyName) != null;
// 获取迭代器对象
@Override
public Iterator<PropertyValue> iterator()
return propertyValueList.iterator();
BeanDefinition
BeanDefinition 类用来封装 Bean 信息的，主要包含 id（即 Bean 对象的名称）、class（需要交由 spring 管理的类的全类名）及子标签 property 数据
package com.henrik.framework.beans;
import lombok.AllArgsConstructor;
import lombok.Data;
// 用来封装 Bean 信息的，主要包含 id（即Bean对象的名称）、class（需要交由 spring 管理的类的全类名）及子标签 property 数据
@Data
@AllArgsConstructor
public class BeanDefinition
private String id;
private String className;
private MutablePropertyValues propertyValues;
public BeanDefinition()
propertyValues = new MutablePropertyValues();
2.定义注册表相关类
BeanDefinitionRegistry 接口
BeanDefinitionRegistry 接口定义了注册表的相关操作，定义如下功能：
- 注册 BeanDefinition 对象到注册表中
- 从注册表中删除指定名称的 BeanDefinition 对象
- 根据名称从注册表中获取 BeanDefinition 对象
- 判断注册表中是否包含指定名称的 BeanDefinition 对象
- 获取注册表中 BeanDefinition 对象的个数
- 获取注册表中所有的 BeanDefinition 的名称
package com.henrik.framework.beans.factory.support;
import com.henrik.framework.beans.BeanDefinition;
// 注册表对象
public interface BeanDefinitionRegistry
//注册BeanDefinition对象到注册表中
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
//从注册表中删除指定名称的BeanDefinition对象
void removeBeanDefinition(String beanName) throws Exception;
//根据名称从注册表中获取BeanDefinition对象
BeanDefinition getBeanDefinition(String beanName) throws Exception;
boolean containsBeanDefinition(String beanName);
int getBeanDefinitionCount();
String[] getBeanDefinitionNames();
SimpleBeanDefinitionRegistry 类
该类实现了BeanDefinitionRegistry接口，定义了Map集合作为注册表容器
package com.henrik.framework.beans.factory.support;
import com.henrik.framework.beans.BeanDefinition;
import java.util.HashMap;
import java.util.Map;
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry
// 定义一个容器，用来存储 BeanDefinition 对象
private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
beanDefinitionMap.put(beanName, beanDefinition);
@Override
public void removeBeanDefinition(String beanName) throws Exception
beanDefinitionMap.remove(beanName);
@Override
public BeanDefinition getBeanDefinition(String beanName) throws Exception
return beanDefinitionMap.get(beanName);
@Override
public boolean containsBeanDefinition(String beanName)
return beanDefinitionMap.containsKey(beanName);
@Override
public int getBeanDefinitionCount()
return beanDefinitionMap.size();
@Override
public String[] getBeanDefinitionNames()
return beanDefinitionMap.keySet().toArray(new String[0]);
3.定义解析器相关类
BeanDefinitionReader 接口
BeanDefinitionReader 是用来解析配置文件并在注册表中注册 Bean 的信息。定义了两个规范：
- 获取注册表的功能，让外界可以通过该对象获取注册表对象
- 加载配置文件，并注册 Bean 数据
package com.henrik.framework.beans.factory.support;
// 用于解析配置文件，定义规范
public interface BeanDefinitionReader
//获取注册表对象
BeanDefinitionRegistry getRegistry();
//加载配置文件并在注册表中进行注册
void loadBeanDefinitions(String configLocation) throws Exception;
XmlBeanDefinitionReader 类
XmlBeanDefinitionReader 类是专门用来解析 xml 配置文件的。该类实现 BeanDefinitionReader 接口并实现接口中的两个功能
package com.henrik.framework.beans.factory.xml;
import com.henrik.framework.beans.BeanDefinition;
import com.henrik.framework.beans.MutablePropertyValues;
import com.henrik.framework.beans.PropertyValue;
import com.henrik.framework.beans.factory.support.BeanDefinitionReader;
import com.henrik.framework.beans.factory.support.BeanDefinitionRegistry;
import com.henrik.framework.beans.factory.support.SimpleBeanDefinitionRegistry;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.util.List;
public class XmlBeanDefinitionReader implements BeanDefinitionReader
// 声明注册表对象
private BeanDefinitionRegistry registry;
public XmlBeanDefinitionReader()
registry = new SimpleBeanDefinitionRegistry();
@Override
public BeanDefinitionRegistry getRegistry()
return registry;
@Override
public void loadBeanDefinitions(String configLocation) throws Exception
// 使用 dome4j 进行 xml 配置文件的解析
SAXReader reader = new SAXReader();
// 获取类路径下的配置文件
InputStream is = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
Document document = reader.read(is);
// 根据 Document 对象获取标签对象（Beans）
Element rootElement = document.getRootElement();
// 获取根标签下所有的 Bean 标签对象
List<Element> beanElements = rootElement.elements("bean");
// 遍历集合
for (Element beanElement : beanElements)
// 获取 id 属性
String id = beanElement.attributeValue("id");
// 获取 class 属性
String className = beanElement.attributeValue("class");
// 封装到 BeanDefinition
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setId(id);
beanDefinition.setClassName(className);
// 创建 mutableProper以上是关于Spring IOC ：相关接口分析手写简易 Spring IOC的主要内容，如果未能解决你的问题，请参考以下文章
Spring IOC ：相关接口分析手写简易 Spring IOC
手写实现自定义简易版Spring （实现IoC 和 AOP）