分析完与Spring IoC功能相关的接口之后，接下来我们就要来自定义Spring IoC功能了。
首先，我们先来看一下需求：现要对下面的配置文件进行解析，并自定义Spring框架的IoC功能对涉及到的对象进行管理。
要想完成这一需求，可不是件容易的事情，我们得分如下几部分来进行定义。
- 定义bean相关的pojo类。
- 定义注册表相关的类。
- 定义解析器相关的类。
- 定义IoC容器相关的类。
下面，我们先来定义bean相关的pojo类。
定义bean相关的pojo类首先，我们先使用IDEA来创建一个Maven工程，工程名字你可以取为liayun_spring，然后再来创建相应的包，这里为了让大家清楚地看到我都创建了哪些包，干脆我把最终Maven工程的结构给大家展示出来吧！
PropertyValue类在这一部分，我们会创建不同的类，第一个类就是PropertyValue，该类的作用就是用来封装bean的属性的。看一下一开始的配置文件，最终我们是要解析该配置文件的，所以严格来说，PropertyValue这个类是用来封装
package com.meimeixia.framework.beans;
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。为什么要创建这个类呢？因为一个
注意，在创建该类时，我们需要用到迭代器模式，所以该类得去实现Iterable接口。至于为什么这儿要用到迭代器模式，我不说，相信大家也知道，因为MutablePropertyValues类是用来存储并管理多个PropertyValue对象的，所以它必须是可以迭代的。
package com.meimeixia.framework.beans; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class MutablePropertyValues implements Iterable{ // 定义List集合对象，用来存储PropertyValue对象 private final List propertyValueList; // 如果用final修饰的话，那么就意味着它只能被赋值一次 // 以下构造方法是用来为以上成员变量赋值的 public MutablePropertyValues() { this.propertyValueList = new ArrayList (); } public MutablePropertyValues(List propertyValueList) { if (propertyValueList == null) { this.propertyValueList = new ArrayList (); } 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 iterator() { return propertyValueList.iterator(); } }
相信大家可以看到，我们在以上MutablePropertyValues类中定义了很多方法，这些方法我也写了一些比较详细的注释，相信大家都能看懂。
BeanDefinition类接下来，我们再来创建bean相关的pojo类里面的最后一个类，也是最重要的一个类，叫BeanDefinition。其实，之前我们在分析Spring IoC功能的相关接口时，就见过类似这玩意，只不过它是接口，而在这里我们是直接将其定义成类了，主要是为了简单，图省事。
BeanDefinition类主要是用来封装bean信息的，主要包含id（即bean对象的名称）、class（需要交由Spring管理的类的全类名）及子标签
package com.meimeixia.framework.beans;
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;
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;
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {
// 定义一个Map集合，用来存储BeanDefinition对象
private Map beanDefinitionMap = new HashMap(); // 注意，在这里我们选择创建的是双列集合，因为我们不仅要存储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的信息的，所以我们应在它里面定义如下两个规范。
- 获取注册表的功能，让外界可以通过该对象获取注册表对象。
- 加载配置文件，并注册bean数据。
根据以上分析，我们创建出来的eanDefinitionReader接口就应该是下面这个样子的。
package com.meimeixia.framework.beans.factory.support;
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;
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 {
// 使用dom4j进行XML配置文件的解析
SAXReader reader = new SAXReader();
// 获取类路径下的配置文件。注意，这里我们只实现类路径下的配置文件的加载
InputStream is = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
document document = reader.read(is);
// 根据document对象获取根标签对象（根标签很明显就是标签）
Element rootElement = document.getRootElement();
// 获取根标签下所有的子标签对象
List 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();
// 获取标签下所有的子标签对象
List 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);
}
// 将MutablePropertyValues对象封装到BeanDefinition对象中
beanDefinition.setPropertyValues(mutablePropertyValues);
// 将BeanDefinition对象注册到注册表中
registry.registerBeanDefinition(id, beanDefinition);
}
}
}
注意，由于我们要在XmlBeanDefinitionReader类的loadBeanDefinitions方法中使用dom4j进行XML配置文件的解析，所以我们应在工程的pom.xml文件里面导入对应的jar包的坐标，如下所示。
定义IoC容器相关的类dom4j dom4j 1.6.1
。。。
