SpringFramework学习-(3)我的IOC容器

上一篇文章helloworld中展示了SpringIOC容器的效果，那么是怎么实现的呢？
在不看源码的前提下，我们先猜测IOC容器初始化都做了些什么：

ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring-helloworld.xml"});

ApplicationContext ac = new FileSystemXmlApplicationContext(new String[]{"E:\\MavenWorkSpacePrivate\\spring-study-03\\resources\\spring-helloworld.xml"});

Spring提供了两个比较高级的实现，FileSystemXmlApplicationContext和ClassPathXmlApplicationContext。
ClassPathXmlApplicationContext顾名思义就是从classpath下面去寻找配置文件；
FileSystemXmlApplicationContext 顾名思义就是从文件系统中寻找配置文件。
由此可知，初始化IOC容器的第一步应该是资源定位。
Spring在得到资源文件之后接下来应该就是加载解析配置文件了。
加载完成的bean会存放在哪里呢，是否需要将这些加载好的bean，注册到某个容器中供使用者调用呢？由getBean(beanName)我们判别加载后的bean应该是存放在了某种Map集合中。

按照上面的猜想和分析，我们按照1）资源定位；2）加载解析；3）注册bean三个步骤来实现以下自己的IOC容器。

创建存储解析后bean的容器
MyBeanDefinition

package com.myspring1.common;

public class MyBeanDefinition {

    private String id;

    private String className;

    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 MyBeanDefinition(String id, String className) {
        this.id = id;
        this.className = className;
    }

}

创建上下文
MyClassPathXmlApplicationContext

package com.myspring1.common;

import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * 
 * 自定义xml文件加载<br>
 * 分两步：<br>
 * 1)this.getClass().getClassLoader().getResource(xmlFileName)加载xml文件，使用SAX解析xml文件的配置。然后将id，class属性加入到beanDefinition中<br>
 * 2)Class.forName(全类名)实例化解析的bean，并将bean放入到一个map中
 * 
 * @author tang
 * 
 */
public class MyClassPathXmlApplicationContext {

    private List<MyBeanDefinition> myBeanDefines=new ArrayList<MyBeanDefinition>();//用来存储所有的beans

    private Map<String, Object> mySigletons =new HashMap<String, Object>();//用来存储实例化后的bean

    public MyClassPathXmlApplicationContext(String xmlFileName) throws InstantiationException, IllegalAccessException, ClassNotFoundException{

        //1.读取spring配置文件
        this.readXml(xmlFileName);

        //2.实例化beans
        this.instanceBeans();


    }

    /***
     * 读取配置文件，同时将配置文件中的bean都放入到一个集合中
     * @param xmlFileName
     */
    public void readXml(String xmlFileName){
        SAXReader saxReader = new SAXReader();
        Document document = null;
        try {
            //获取要读取的文件的路径
            URL xmlPath = this.getClass().getClassLoader().getResource(xmlFileName);

            document = saxReader.read(xmlPath);

            Element rootElement = document.getRootElement();

            for (Iterator iterator = rootElement.elementIterator(); iterator.hasNext();) {

                Element element = (Element)iterator.next();

                String id = element.attributeValue("id");

                String clazz = element.attributeValue("class");

                MyBeanDefinition myBeanDefinition = new MyBeanDefinition(id, clazz);


                myBeanDefines.add(myBeanDefinition);

            }


        } catch (DocumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /***
     * 实例化beans
     * @throws ClassNotFoundException 
     * @throws IllegalAccessException 
     * @throws InstantiationException 
     */
    public void instanceBeans() throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        if(myBeanDefines != null && myBeanDefines.size() > 0){
            for (MyBeanDefinition myBeanDefinition : myBeanDefines) {
                if(myBeanDefinition.getClassName() != null && !"".equals(myBeanDefinition.getClass())){
                    mySigletons.put(myBeanDefinition.getId(), Class.forName(myBeanDefinition.getClassName()).newInstance());
                    System.out.println("id为"+myBeanDefinition.getId()+"的bean实例化成功");
                }
            }
        }
    }

    /**
     * 获取bean
     * @param beanName
     * @return
     */
    public Object getBean(String beanName){
        return mySigletons.get(beanName);
    }   
}

创建需要实例化的bean
UserServiceImpl

package com.myspring1.service;

public interface UserService {

    String findUserById();
}

package com.myspring1.service.impl;

import com.myspring1.service.UserService;

public class UserServiceImpl implements UserService{

    @Override
    public String findUserById() {
        return "myid";
    }   
}

创建配置文件
mySpring1Bean.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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">

    <bean id="userService" class="com.myspring1.service.impl.UserServiceImpl">

    </bean>

</beans>

创建测试类

package com.myspring1.test;

import com.myspring1.common.MyClassPathXmlApplicationContext;
import com.myspring1.service.UserService;

public class SpringTest {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {

        MyClassPathXmlApplicationContext myClassPathXmlApplicationContext = new MyClassPathXmlApplicationContext("mySpring1Bean.xml");

        UserService userService = (UserService)myClassPathXmlApplicationContext.getBean("userService");
        String userId = userService.findUserById();
        System.out.println(userId);
    }
}

测试结果

id为userService的bean实例化成功
myid

实现步骤说明：
1）传入配置文件，定位配置文件的位置，这里使用的获取classpath的方式进行获取的，如果使用文件系统方式需要通过获取文件系统路径进行获取。

URL xmlPath = this.getClass().getClassLoader().getResource(xmlFileName);

2）解析配置文件，加载bean到临时容器中
调用readXml(filename)方法，通过SAX解析器对配置文件进行解析（解析方式是根据xml的约束进行的，所以如果要定义自己的IOC容器，需要先建立自己的dtd约束），然后将将所有的bean都放入到一个叫myBeanDefines的集合中。

this.readXml(xmlFileName);

3）注册bean。如果只是将bean放在myBeanDefines容器中，使用者是无法调用，所以需要将bean注册到map中。id作为key，实例作为value。
这里使用的是反射的机制，通过全类名获取实例。

mySigletons.put(myBeanDefinition.getId(), Class.forName(myBeanDefinition.getClassName()).newInstance());

通过上面的实现，模拟了Spring的实现步骤，但是Sping提供的并没有这么的简单。这是只是展示了简单的实现，依赖注入解耦等等很多的问题也没有考虑进去。

如果想深入的理解SpringIOC，请期待下一篇源码级的解析。