我的自定义Spring框架 | 自定义Spring IoC功能

Posted 2021-11-03 李阿昀

分析完与Spring IoC功能相关的接口之后，接下来我们就要来自定义Spring IoC功能了。

首先，我们先来看一下需求：现要对下面的配置文件进行解析，并自定义Spring框架的IoC功能对涉及到的对象进行管理。

<?xml version="1.0" encoding="UTF-8"?>
<beans>

    <bean id="userDao" class="com.meimeixia.dao.impl.UserDaoImpl">
        <property name="username" value="zhangsan"></property>
        <property name="password" value="123456"></property>
    </bean>

    <bean id="userService" class="com.meimeixia.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

</beans>

要想完成这一需求，可不是件容易的事情，我们得分如下几部分来进行定义。

1. 定义bean相关的pojo类。
2. 定义注册表相关的类。
3. 定义解析器相关的类。
4. 定义IoC容器相关的类。

下面，我们先来定义bean相关的pojo类。

定义bean相关的pojo类

首先，我们先使用IDEA来创建一个Maven工程，工程名字你可以取为liayun_spring，然后再来创建相应的包，这里为了让大家清楚地看到我都创建了哪些包，干脆我把最终Maven工程的结构给大家展示出来吧！

PropertyValue类

在这一部分，我们会创建不同的类，第一个类就是PropertyValue，该类的作用就是用来封装bean的属性的。看一下一开始的配置文件，最终我们是要解析该配置文件的，所以严格来说，PropertyValue这个类是用来封装<bean>标签的<property>子标签中的属性的。由于<property>子标签中有name、ref、value等属性，因此PropertyValue类里面至少得有name、ref、value这三个属性。

package com.meimeixia.framework.beans;

/**
 * 用来封装bean标签下的property标签的属性，属性有这些：
 *      name属性
 *      ref属性
 *      value属性：给基本数据类型及String类型的数据赋值
 * @author liayun
 * @create 2021-09-20 9:41
 */
public class PropertyValue {

    private String name;
    private String ref;
    private String value;

    public PropertyValue() {

    }

    public PropertyValue(String name, String ref, String value) {
        this.name = name;
        this.ref = ref;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRef() {
        return ref;
    }

    public void setRef(String ref) {
        this.ref = ref;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

}

MutablePropertyValues类

创建完PropertyValue类之后，接下来我们再来创建第二个类，那就是MutablePropertyValues。为什么要创建这个类呢？因为一个<bean>标签可以有多个<property>子标签，而每一个<property>子标签都会被封装成一个PropertyValue对象，对于多个PropertyValue对象我们就要进行存储以及管理了，所以在这里我们就要创建一个MutablePropertyValues类，用来存储并管理多个PropertyValue对象了。

注意，在创建该类时，我们需要用到迭代器模式，所以该类得去实现Iterable接口。至于为什么这儿要用到迭代器模式，我不说，相信大家也知道，因为MutablePropertyValues类是用来存储并管理多个PropertyValue对象的，所以它必须是可以迭代的。

package com.meimeixia.framework.beans;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 用于存储和管理多个PropertyValue对象
 * @author liayun
 * @create 2021-09-20 10:15
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {

    // 定义List集合对象，用来存储PropertyValue对象
    private final List<PropertyValue> propertyValueList; // 如果用final修饰的话，那么就意味着它只能被赋值一次

    // 以下构造方法是用来为以上成员变量赋值的
    public MutablePropertyValues() {
        this.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对象。注意，该方法的返回值类型是MutablePropertyValues，目的是为了能实现链式编程
    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; // 返回当然对象（即MutablePropertyValues类型的对象），目的就是实现链式编程
            }
        }
        this.propertyValueList.add(pv); // 如果没有重复的，那么就直接添加进集合里面去
        return this; // 返回当然对象（即MutablePropertyValues类型的对象），目的就是实现链式编程
    }

    // 判断是否有指定name属性值的PropertyValue对象，有的话返回true，没有的话返回false
    public boolean contains(String propertyName) {
        return getPropertyValue(propertyName) != null;
    }

    // 获取迭代器对象
    @Override
    public Iterator<PropertyValue> iterator() {
        /*
         * 获取迭代器对象的这个方法应该如何来实现呢？
         *
         * 由于PropertyValue对象是存储在一开始定义的List集合里面的，所以这里我们直接调用其获取迭代器的方法（即iterator）即可。
         */
        return propertyValueList.iterator();
    }

}

相信大家可以看到，我们在以上MutablePropertyValues类中定义了很多方法，这些方法我也写了一些比较详细的注释，相信大家都能看懂。

BeanDefinition类

接下来，我们再来创建bean相关的pojo类里面的最后一个类，也是最重要的一个类，叫BeanDefinition。其实，之前我们在分析Spring IoC功能的相关接口时，就见过类似这玩意，只不过它是接口，而在这里我们是直接将其定义成类了，主要是为了简单，图省事。

BeanDefinition类主要是用来封装bean信息的，主要包含id（即bean对象的名称）、class（需要交由Spring管理的类的全类名）及子标签<property>中的数据。

package com.meimeixia.framework.beans;

/**
 * 用来封装bean标签数据，包含：
 *      id属性
 *      class属性
 *      property子标签中的数据
 * @author liayun
 * @create 2021-09-20 11:06
 */
public class BeanDefinition {

    private String id;
    private String className;
    private MutablePropertyValues propertyValues;

    public BeanDefinition() {
        this.propertyValues = new MutablePropertyValues();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public MutablePropertyValues getPropertyValues() {
        return propertyValues;
    }

    public void setPropertyValues(MutablePropertyValues propertyValues) {
        this.propertyValues = propertyValues;
    }

}

可以看到，虽然这个类特别重要，但是创建起来还是比较简单的。

定义注册表相关的类

BeanDefinitionRegistry接口

定义完bean相关的pojo类之后，接下来我们就要来定义注册表相关的类了。当然，这一部分就不仅仅是有类了，还有接口，说白了，在这一部分，我们会创建一个接口及其子实现类。至于接口的话，我们就命名为BeanDefinitionRegistry了，下面我们就来看一下该接口需要定义哪些功能？

BeanDefinitionRegistry接口应定义注册表的相关操作，所以需要定义如下功能：

• 注册BeanDefinition对象到注册表中。
• 从注册表中删除指定名称的BeanDefinition对象。
• 根据名称从注册表中获取BeanDefinition对象。
• 判断注册表中是否包含指定名称的BeanDefinition对象。
• 获取注册表中BeanDefinition对象的个数。
• 获取注册表中所有的BeanDefinition对象的名称。

以上这些功能，相信大家应该很熟悉，因为之前我们在分析Spring源码里面的BeanDefinitionRegistry接口时就看到过，BeanDefinitionRegistry接口也定义了以上这些功能。

根据以上分析，我们创建出来的BeanDefinitionRegistry接口就应该是下面这个样子的。

package com.meimeixia.framework.beans.factory.support;

import com.meimeixia.framework.beans.BeanDefinition;

/**
 * 注册表对象所属接口
 * @author liayun
 * @create 2021-09-20 11:16
 */
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();
}

BeanDefinitionRegistry接口创建完毕之后，接下来我们就要来创建它的子实现类了，注意，这里我们只创建一个子实现类。

SimpleBeanDefinitionRegistry类

我们在创建该类时，要让该类去实现BeanDefinitionRegistry接口，并去重写它里面所有的抽象方法。注意，在该类里面我们还得定义一个Map集合，让其作为注册表容器。

package com.meimeixia.framework.beans.factory.support;

import com.meimeixia.framework.beans.BeanDefinition;

import java.util.HashMap;
import java.util.Map;

/**
 * 注册表接口的子实现类
 * @author liayun
 * @create 2021-09-20 11:23
 */
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {
    // 定义一个Map集合，用来存储BeanDefinition对象
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>(); // 注意，在这里我们选择创建的是双列集合，因为我们不仅要存储BeanDefinition对象，还要存储其名称

    @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]);
    }
}

定义解析器相关的类

接下来，我们就来定义解析器相关的接口和类。相信大家也都知道了，我们均是参照Spring里面的接口和类来定义的，所以在这一部分我们就将接口命名为BeanDefinitionReader，既然它是一个接口的话，那么它里面定义的便是最基本的功能规范了。还有，我们还得为该接口创建一个子实现类，名字不妨就叫做XmlBeanDefinitionReader。

为什么我们还要创建BeanDefinitionReader接口呢？之前我带着大家分析Spring IoC功能相关的接口时，你也看到了，针对于不同的配置文件，Spring会提供不同的子类来进行解析，例如，解析properties格式的配置文件用的是PropertiesBeanDefinitionReader类，解析XML格式的配置文件用的是XmlBeanDefinitionReader。大家要是能够去看一下BeanDefinitionReader接口的继承体系的话，你会发现这俩类都是其子实现类。当然了，这里我们在自定义Spring IoC功能时，只会针对XML格式的配置文件来创建解析类。

BeanDefinitionReader接口

由于BeanDefinitionReader是用来解析配置文件并在注册表中注册bean的信息的，所以我们应在它里面定义如下两个规范。

1. 获取注册表的功能，让外界可以通过该对象获取注册表对象。
2. 加载配置文件，并注册bean数据。

根据以上分析，我们创建出来的eanDefinitionReader接口就应该是下面这个样子的。

package com.meimeixia.framework.beans.factory.support;

/**
 * 用来解析配置文件的，而且该接口只是定义了规范，具体的应由子类来实现
 * @author liayun
 * @create 2021-09-20 11:49
 */
public interface BeanDefinitionReader {
    // 获取注册表对象
    BeanDefinitionRegistry getRegistry();

    // 加载配置文件，并在注册表中进行注册
    void loadBeanDefinitions(String configLocation) throws Exception;
}

XmlBeanDefinitionReader类

BeanDefinitionReader接口创建完毕之后，接下来我们就来创建其子实现类，名字上面我也说了，就叫XmlBeanDefinitionReader。

相信大家也知道了，XmlBeanDefinitionReader类是专门用来解析XML格式的配置文件的，而且创建该类时，不用我说，大家都应该知道该类得实现BeanDefinitionReader接口并去重写它里面的两个功能，如下所示。

package com.meimeixia.framework.beans.factory.xml;

import com.meimeixia.framework.beans.BeanDefinition;
import com.meimeixia.framework.beans.MutablePropertyValues;
import com.meimeixia.framework.beans.PropertyValue;
import com.meimeixia.framework.beans.factory.support.BeanDefinitionReader;
import com.meimeixia.framework.beans.factory.support.BeanDefinitionRegistry;
import com.meimeixia.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;

/**
 * 针对XML格式的配置文件进行解析的类
 * @author liayun
 * @create 2021-09-20 11:58
 */
public class XmlBeanDefinitionReader implements BeanDefinitionReader {
    /*
     * 声明注册表对象
     *
     * 为什么要在成员变量位置处声明注册表对象呢？大家不妨来想一下，XmlBeanDefinitionReader对象（即解析器）是
     * 专门用来解析XML格式的配置文件的，解析完之后，自然是会将配置文件里面的<bean>标签封装成BeanDefinition对
     * 象，那么这些BeanDefinition对象是存放在哪呢？是不是就是注册到了注册表对象里面呀？所以，我们就在这个位置声
     * 明了一个注册表对象。
     */
    private BeanDefinitionRegistry registry;

    public XmlBeanDefinitionReader() {
        registry = new SimpleBeanDefinitionRegistry();
    }

    /**
     * 获取注册表对象
     * @return 直接返回成员注册表对象
     */
    @Override
    public BeanDefinitionRegistry getRegistry() {
        return registry;
    }

    /**
     * 加载配置文件，并在注册表中进行注册
     * @param configLocation 类路径下配置文件的路径
     * @throws Exception
     */
    @Override
    public void loadBeanDefinitions(String configLocation) throws Exception {
        // 使用dom4j进行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");

            // 将id属性和class属性封装到BeanDefinition对象中
            // 1. 创建BeanDefinition对象
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            // 创建MutablePropertyValues对象
            MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();

            // 获取<bean>标签下所有的<property>子标签对象
            List<Element> propertyElements = beanElement.elements("property");
            for (Element propertyElement : propertyElements) {
                String name = propertyElement.attributeValue("name");
                String ref = propertyElement.attributeValue("ref");
                String value = propertyElement.attributeValue("value");
                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                mutablePropertyValues.addPropertyValue(propertyValue);
            }
        
以上是关于我的自定义Spring框架 | 自定义Spring IoC功能的主要内容，如果未能解决你的问题，请参考以下文章
 
 我的自定义Spring框架 | 回顾Spring框架的基本使用
 我的自定义Spring框架 | 回顾Spring框架的基本使用
 我的自定义Spring框架 | Spring核心功能结构
 我的自定义Spring框架 | Spring核心功能结构
 我的自定义Spring框架 | Spring IoC相关接口分析
 我的自定义Spring框架 | Spring IoC相关接口分析