Java Web框架——自己动手实现一个简化版的Spring IOC框架

 一、序

　　只要是Java Web的开发者，相信没有不知道大名鼎鼎的Spring框架的。作为一个优秀的开源框架，Spring包含9大组件，如果想要通过源码去理解每一个组件，复杂度和所花费的时间都容易让人望而却步——笔者平时习惯阅读源码，但是在学习Spring这种级别的框架面前显然不是一个好选择。但是问题又来了，不阅读源码，如何深入理解Spring呢？笔者在搜索学习资料的时候在github找到了一个优秀的repo——https://github.com/code4craft/tiny-spring，通过参考其思路，自己动手实现一个简化版的Spring框架（这里只实现核心IOC部分，后续会有文章实现其他部分）。本文假设读者已经对Spring有了大致的理解，不会花太多篇幅介绍Spring，重点在实现上。

二、设计

　　首先花几分钟简单看一下Spring3.x的架构，虽然现在Spring都5.x了，但是我们现在是理解核心思路，看以前版本的架构图反而更清晰，下图转自网络：

　　Spring含有十几个组件，核心的只有3个——Core，Context和Bean，那么这次我们就实现相对来说比较重要的Bean和Core，Context主要是一个起封装功能的作用，影响不大，放到以后完善。首先设计好我们的架构，首先我们需要一个Resource来存储我们需要的Bean信息来源和链接到我们需要的类，也需要一个BeanDefiinition对Bean进行描述和操作，还需要有一个BeanFactory来管理Bean。为了职责分明，再添加一个ResourceLoader对Resource存储的Bean信息进行读取，以及一个对BeanDefinition进行读取的BeanDefinitionReader，大致如下图：

三、实现

　　

　　1、首先写Resource接口，只规定了一个通过流获取资源getInputStream()方法，方便实现不同的获取资源的方式：

package com.joe.io;

import java.io.InputStream;

public interface Resource {
    InputStream getInputStream() throws Exception;
}

　　

　　2、通过具体的类UrlResource实现Resource接口：

package com.joe.io;

import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

public class UrlResource implements Resource {
    
    private URL url;
    
    public UrlResource(URL url) {
        this.url = url;
    }
    
    public InputStream getInputStream() throws Exception {
        URLConnection urlConnection = url.openConnection();
        urlConnection.connect();
        return urlConnection.getInputStream();
    }
}

　　这里底层用了java.net包的URL以及相关类去操作资源的获取，核心方法就一个getInputStream()，这里通过URLConnection去获取资源，读者想了解底层细节可以自行google。那么作为入参的URL是由谁传入的呢？自然是我们接下来要介绍的ResourceLoader。

　　

　　3、负责读取Resource的资源加载器ResourceLoader类:

package com.joe.io;

import java.net.URL;

public class ResourceLoader {
    
    public Resource getResource(String location) {
        URL url = this.getClass().getClassLoader().getResource(location);
        return new UrlResource(url);
    }
}

　　这里很清晰地看到，getResource()方法把接收到的String作为参数，通过获取当前的类加载器，调用ClassLoader.getResource(String location)方法将返回的URL传递给我们的Resource（同上，ClassLoader相关api原理和本文关系不大，想学习的读者的自行google），至此资源加载器的功能就完成了。

　　

　　4、描述Bean的BeanDefinition类：

package com.joe;

public class BeanDefinition {
    private Object bean;// 对象实例
    
    private Class beanClass;//bean的类型
    
    private String beanClassName;//类名
    
    private PropertyValues propertyValues; 

    public Object getBean() {
        return bean;
    }

    public void setBean(Object bean) {
        this.bean = bean;
    }

    public Class getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(Class beanClass) {
        this.beanClass = beanClass;
    }

    public String getBeanClassName() {
        return beanClassName;
    }

    public void setBeanClassName(String beanClassName) {
        this.beanClassName = beanClassName;
        try {
            this.beanClass = Class.forName(beanClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public PropertyValues getPropertyValues() {
        if (propertyValues == null) {
            propertyValues = new PropertyValues();
        }
        return propertyValues;
    }

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

　　BeanDefinition为了对Bean进行描述和初始化，所以需要持有以下变量：

　　1) Object bean，用来存储Bean，也就是具体的对象实例；

　　2) Class beanClass，用来存储bean的Class类型；

　　3) Class beanClassName，用来存储bean的具体类名；

　　4) PropertyValues propertyValues，用来随着bean一起注入IOC容器的类变量。

　　前三个变量没什么好说的，PropertyValues主要用来存储类变量，我们稍后对其进行实现。

　　

　　5、定义好了描述Bean，为了职责分明，我们还需要对一个其进行读取的BeanDefinitonReader接口:

　　

package com.joe;

public interface BeanDefinitionReader {
    void loadBeanDefinitions(String location) throws Exception;
}

　　定义一个方法供IOC容器在初始化的时候从location指定的位置进行资源以及Bean的加载，在这里我们只实现xml加载方式。

　　6、AbstractBeanDefinitionReader，在我们实现具体的通过xml进行Bean加载器之前，为了通用性（实际场景，不可能只通过xml去解析Bean资源），我们实现一个抽象的Bean加载器类：

　

package com.joe;

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

import com.joe.io.ResourceLoader;

public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader {
    
    private Map<String, BeanDefinition> registry;
    
    private ResourceLoader resourceLoader;
    
    public AbstractBeanDefinitionReader(ResourceLoader resourceLoader) {
        this.registry = new HashMap<String, BeanDefinition>();
        this.resourceLoader = resourceLoader;
    }

    public Map<String, BeanDefinition> getRegistry() {
        return registry;
    }

    public ResourceLoader getResourceLoader() {
        return resourceLoader;
    }
}

　　抽象类除了持有Map<String, BeanDefinition>以方便Bean的注册外，还持有一个我们之前实现的资源加载器ResourceLoader，稍后介绍资源加载器的作用。

　　

　　7、XmlBeanDefinitionReader，这部分内容涉及比较多的细节，比如dom解析文件节点等操作，可以选择性跳过，理解思路即可：

package com.joe.xml;

import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.joe.AbstractBeanDefinitionReader;
import com.joe.BeanDefinition;
import com.joe.BeanReference;
import com.joe.PropertyValue;
import com.joe.io.ResourceLoader;

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {

    public XmlBeanDefinitionReader(ResourceLoader resourceLoader) {
        super(resourceLoader);
    }

    public void loadBeanDefinitions(String location) throws Exception {
        InputStream inputStream = getResourceLoader().getResource(location).getInputStream();
        doLoadBeanDefinitions(inputStream);
    }

    protected void doLoadBeanDefinitions(InputStream inputStream) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        Document doc = docBuilder.parse(inputStream);
        // 解析bean
        registerBeanDefinitions(doc);
        inputStream.close();
    }

    public void registerBeanDefinitions(Document doc) {
        Element root = doc.getDocumentElement();

        parseBeanDefinitions(root);
    }

    protected void parseBeanDefinitions(Element root) {
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                processBeanDefinition(ele);
            }
        }
    }

    protected void processBeanDefinition(Element ele) {
        String name = ele.getAttribute("id");
        String className = ele.getAttribute("class");
        BeanDefinition beanDefinition = new BeanDefinition();
        processProperty(ele, beanDefinition);
        beanDefinition.setBeanClassName(className);
        getRegistry().put(name, beanDefinition);
    }

    private void processProperty(Element ele, BeanDefinition beanDefinition) {
        NodeList propertyNode = ele.getElementsByTagName("property");
        for (int i = 0; i < propertyNode.getLength(); i++) {
            Node node = propertyNode.item(i);
            if (node instanceof Element) {
                Element propertyEle = (Element) node;
                String name = propertyEle.getAttribute("name");
                String value = propertyEle.getAttribute("value");
                if (value != null && value.length() > 0) {
                    beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, value));
                } else {
                    String ref = propertyEle.getAttribute("ref");
                    if (ref == null || ref.length() == 0) {
                        throw new IllegalArgumentException("Configuration problem: <property> element for property '"
                                + name + "' must specify a ref or value");
                    }
                    BeanReference beanReference = new BeanReference(ref);
                    beanDefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, beanReference));
                }
            }
        }
    }
}

　　这个代码稍微多点，大致上就干了这么几件事：

　　1）加载xml：初始化时，把指定的xml文件（这里是xml，也可以是其他资源）加载进IOC容器，转化成流inputStream后存储到org.w3c.dom.Document，这里用到的org.w3c包里的对象比较多，分别有Document，Element，Node等。谁负责加载呢？自然就是我们之前定义的资源加载器ResourceLoader了，这时候，之前提到的抽象资源加载器类AbstractBeanDefinitionReader持有的ResourceLoader就发挥作用了，正是通过这个ResourceLoader完成一系列上述操作，忘了的读者可以回去看其实现。

　　2）获取xml中的各个节点：由1中获取到的Document对象中获得其Element元素，Element描述了xml文件的各个定义bean的节点，也可以说是一个Element代表了一个xml中bean相关的标签，形如<bean id="...", class="...">以及其包括的内容。

　　3）注入bean：对各个Element元素遍历，获取标签中定义为id和class的内容，存储为name和className，name在5中讲解，className为完整描述了包路径的类名。

　　4）注入类变量：针对每个Element创建一个BeanDefinition，遍历Element包含的所有<property>标签（此标签定义了类变量），获取到类变量名以及希望注入的值，添加到BeanDefinition持有的PropertyValues中去。如果类变量是引用类型，则进行另外的处理，这里就不展开讲了，有兴趣的读者自行阅读源码。

　　5）初始化BeanDefiniton部分属性：完成变量的注入后，我们对BeanDefinition持有的其他类变量进行初始化，这里就用到3）中存储的类名name，通过Class.forName(name)获取到其类型，这样BeanDefiniton的beanClassName和beanClass也得到了初始化（还有bean的初始化呢？请带着疑问接着看下去），这里把name和BeanDefiniton注册到抽象资源加载器类AbstractBeanDefinitionReader持有的Map中。至此，资源加载器初始化完成，可以供bean工厂获取了。那么接下来要实现的自然是bean工厂。

　　8、BeanFactory接口：

package com.joe.factory;

import com.joe.BeanDefinition;

public interface BeanFactory {
    
    Object getBean(String name);
    
    void registerBeanDefinition(String name, BeanDefinition beanDefinition) throws Exception;     
}

　　一个获取Bean的getBean()，一个负责从资源加载器中获取并注册Bean的registerBeanDefinition()。

　　

　　9、同样的考虑了通用性，实现了其抽象类：

package com.joe.factory;

import java.util.concurrent.ConcurrentHashMap;

import com.joe.BeanDefinition;

public abstract class AbstractBeanFactory implements BeanFactory {
    
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

    public Object getBean(String name) {
        return beanDefinitionMap.get(name).getBean();
    }

    public void registerBeanDefinition(String name,
            BeanDefinition beanDefinition) throws Exception {
        // 何时设置beanDefinition的其他属性beanClass,beanClassName？——在BeanDefinitionReader加载xml文件的时候set（初始化的时候）
        //测试用例指定要获取的beanClassName
        Object bean = doCreateBean(beanDefinition);//beanDefinition.getBeanClass().newInstance()
        beanDefinition.setBean(bean);
        beanDefinitionMap.put(name, beanDefinition);
    }

    abstract Object doCreateBean(BeanDefinition beanDefinition) throws Exception;
    
}

　　抽象类持有负责存储注册bean的ConcurrentHashMap，关于ConcurrentHashMap的内容也不展开了，读者自行google关于它的内容。这个map的键为String的类名，值为BeanDefinition对象。这里创建类实例（交给实现类实现doCreateBean()去做），并且设置到BeanDefiniton中，至此，BeanDefiniton的所有属性都初始化完毕。可以注册到BeanDefinition工厂中了，beanDefinitonMap.put()方法注册完成后，bean工厂的初始化也正式宣告完成，可以等待代码获取bean了（工厂可以正式开始量产“对象”）。

　　

　　10、AutowiredCapableBenafactory，第9中提到的如何创建类实例，我们通过实现doCreateBean()自行决定如何创建：

package com.joe.factory;

import java.lang.reflect.*;

import com.joe.*;

public class AutowiredCapableBeanFactory extends AbstractBeanFactory {

    @Override
    Object doCreateBean(BeanDefinition beanDefinition) throws Exception {
        Object bean = beanDefinition.getBeanClass().newInstance();
        beanDefinition.setBean(bean);
        applyPropertyValues(bean, beanDefinition);
        return bean;
    }
    
    void applyPropertyValues(Object bean, BeanDefinition mdb) throws Exception {
        for (PropertyValue propertyValue : mdb.getPropertyValues().getPropertyValues()) {
            Field field = bean.getClass().getDeclaredField(propertyValue.getName());
            field.setAccessible(true);
            field.set(bean, propertyValue.getValue());
        }
    }

}

　　doCreateBena通过反射相关API创建实例bean，并设置给BeanDefiniton的bean属性，然后通过遍历BeanDefiniton的变量ProperyValues，还是通过反射，为变量设置从xml文件注入的值（回忆下刚刚资源加载器从如何从xml解析各个节点元素的值）。

　　

　　11、之前提到用于描述类变量的PropertyValues和PropertyValue，注意两者的差别，两者配合使用，联系比较紧密，就两个类一起贴出来了。

package com.joe;

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

public class PropertyValues {
    
    private final List<PropertyValue> propertyValueList = new ArrayList<PropertyValue>();
    
    public PropertyValues() {}
    
    public void addPropertyValue(PropertyValue pv) {
        this.propertyValueList.add(pv);
    }
    
    public List<PropertyValue> getPropertyValues() {
        return this.propertyValueList;
    }
}


package com.joe;

public class PropertyValue {
    
    private final String name;
    
    public String getName() {
        return name;
    }

    public Object getValue() {
        return value;
    }

    private final Object value;
    
    public PropertyValue(String name, Object value) {
        this.name = name;
        this.value = value;
    }
}

　　12、为了读者能跑通UnitTest，也给出相关的其他类以及xml文件。

　　用于注入引用类型变量的BeanReference实现：

package com.joe;

public class BeanReference {

    private String name;

    private Object bean;

    public BeanReference(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public Object getBean() {
        return bean;
    }

    public void setBean(Object bean) {
        this.bean = bean;
    }
}

　　xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <bean id="helloWorldService" class="com.joe.HelloWorldServiceImpl">
        <property name="text" value="Hello Joe"></property>
    </bean>

</beans>

　

　　13：单元测试文件：

　　测试类BeanFactoryTest：

package com.joe;

import static org.junit.Assert.*;

import java.util.Map;

import org.junit.Test;

import com.joe.factory.AbstractBeanFactory;
import com.joe.factory.AutowiredCapableBeanFactory;
import com.joe.io.ResourceLoader;
import com.joe.xml.XmlBeanDefinitionReader;

public class BeanFactoryTest {

    @Test
    public void test() throws Exception {
        //初始化......
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(new ResourceLoader());
        xmlBeanDefinitionReader.loadBeanDefinitions("tinyioc.xml");
        
        AbstractBeanFactory beanFactory = new AutowiredCapableBeanFactory();
        for (Map.Entry<String, BeanDefinition> beanDefinitionEntry : xmlBeanDefinitionReader.getRegistry().entrySet()) {
            beanFactory.registerBeanDefinition(beanDefinitionEntry.getKey(), beanDefinitionEntry.getValue());
        }
        //初始化完毕，获取想要的bean
        HelloWorldService helloWorldService = (HelloWorldService)beanFactory.getBean("helloWorldService");
        helloWorldService.helloWorld();
    }

}

　　测试用服务类以及其接口（一起贴出来了）：

package com.joe;
public class HelloWorldServiceImpl implements HelloWorldService {

    private String text;

    public void setText(String text) {
        this.text = text;
    }

    @Override
    public void helloWorld() {
        System.out.println(text);
    }

}


package com.joe;
public interface HelloWorldService {

    void helloWorld();
}

四、总结

　　Spring作为一个通用的Web框架，其代码组织方式非常值得我们借鉴。接口、抽象类、实现类之间都很好的体现了开闭原则，各个类职责清晰，可以说是工厂模式，模板方法等等设计模式的一个很好的实践。这个简化版Spring，代码量虽然不大，但是也正因为这样，更适合新手理解和实践。