7.3Spring IOC模拟

spring的核心是IOC，控制反转，也叫DI依赖注入，意思就是以前类的实例化由自己控制，什么时候需要什么时候就new一个，现在改了，new的动作交由spring来管理，spring使用BeanFactory来实例化、配置和管理对象，但是它只是一个接口，里面有一个getBean()方法。我们一般都不直接用BeanFactory，而是用它的实现类ApplicationContext，这个类会自动解析我们配置的applicationContext.xml，然后根据我们配置的bean来new对象，将new好的对象放进一个Map中，键就是我们bean的id,值就是new的对象。
原理听起来比较清晰，下面就模拟一个具体实现。

整个工程的结构图如下所示：

工程结构图

pom.xml添加解析xml的依赖，用最简单的即可。

 <dependency>
       <groupId>org.jdom</groupId>
       <artifactId>jdom</artifactId>
       <version>2.0.2</version>
 </dependency>

定义一个model，User.java

public class User {
    private int id;
    private String name;
    //get set省略
}

定义接口UserDao.java

public interface UserDao {
    /**
     * 新增用户
     * @param user
     */
    public void add(User user);
}

定义UserDao的实现类UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    @Override
    public void add(User user) {
        System.out.println("新增用户成功");
    }
}

定义接口UserService.java

public interface UserService {
    /**
     * 新增用户
     * @param user
     */
    public void add(User user);
}

定义UserService接口的实现类UserServiceImple.java

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void add(User user) {
        userDao.add(user);
        System.out.println("Service执行新增用户。。。");
    }
}

这里面定义Userdao，并加入set方法。这里是模拟spring，主要模拟spring中的IOC功能，所以在此我们一样要在service层中定义dao的实例，当然不用new出来，我们就通过spring的IOC把这里的dao层注入进来。不要忘了对dao提供set get方法，因为IOC的底层其实就是利用反射机制实现的，他把dao注入进来，其实底层就是通过反射set进来的。

核心配置文件Beans.xml

<beans>
    <bean id="userDao" class="com.critc.dao.UserDaoImpl"/>
    <bean id="userService" class="com.critc.service.UserServiceImpl">
        <property name="userDao" bean="userDao"/>
    </bean>
</beans>

Bean工厂接口BeanFactory.java

public interface BeanFactory {
    public Object getBean(String id);
}

里面就一个方法，就是根据id来获取Bean

ClassPathXmlApplicationContext 来实现BeanFactory

public class ClassPathXmlApplicationContext implements BeanFactory {
    private Map<String, Object> beans = new HashMap<String, Object>();

    public ClassPathXmlApplicationContext() throws Exception, Exception {
        SAXBuilder sb = new SAXBuilder();
        Document doc = sb.build(this.getClass().getClassLoader()
                .getResourceAsStream("beans.xml")); // 构造文档对象
        Element root = doc.getRootElement(); // 获取根元素HD
        List list = root.getChildren("bean");// 取名字为bean的所有元素

        for (int i = 0; i < list.size(); i++) {
            Element element = (Element) list.get(i);
            String id = element.getAttributeValue("id");
            String clazz = element.getAttributeValue("class");
            Object o = Class.forName(clazz).newInstance();
            System.out.print("bean id is " + id);
            System.out.println(", clazz is " + clazz);
            beans.put(id, o);
            // 遍历property
            for (Element propertyElement : (List<Element>) element.getChildren("property")) {
                String name = propertyElement.getAttributeValue("name");// userDAO
                String bean = propertyElement.getAttributeValue("bean");// u
                Object beanObject = beans.get(bean);// UserDAOImpl instance

                // 构造setter方法
                String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
                System.out.println("setter method name = " + methodName);

                Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
                m.invoke(o, beanObject);
            }
        }
    }

    @Override
    public Object getBean(String id) {
        return beans.get(id);
    }
}

定义模拟的ClassPathXmlApplicationContext类，通过他，在我们new出他的对象的时候，他来加载配置文件，然后把我们的dao操作注入到我们的service层，在spring中，ClassPathXmlApplicationContext类实现了BeanFactory接口，在此我们也定义一个BeanFactory接口，其实这个接口没什么具体的作用，我们就是为了来模拟spring。

这一段代码是核心，解释一下：

首先我们定义了一个容器Map<String, Object> beans，这个容器的作用就是用来装我们从配置文件里解析来的一个个bean，为什么要用map类型，很简单就能想到，整个工程中的bean id一定要唯一，不能冲突，我们配置文件中每一个bean都有一个id来作为自己的唯一身份。我们把这个id存到map的key里面，然后value就装我们的具体bean对象。

说完这个容器之后，下面我们在来看一下ClassPathXmlApplicationContext的构造方法，这个构造方法是我们spring管理容器的核心，这个构造方法的前半部分是利用的jdom解析方式，把xml里面的bean一个个的解析出来，然后把解析出来的bean在放到我们bean容器里。后半部分主要是在对配置文件进行解析出bean的同时去查看一下这个bean中有没有需要注射bean的，如果有的话，他就去通过这些里面的property属性获取他要注射的bean名字，然后构造出set方法，然后通过反射，调用注入bean的set方法，这样我们所需要的bean就被注入进来了。

  最后我们就来看一下实现接口的getBean放了，其实这个方法很简单，就是根据提供的bean的id，从bean容器内把对应的bean取出来。

我们所需的东西都定义好了，下面我们据来测试一下，看看模仿的spring到底能不能自动把我们所需要的dao层给我们注入进来。

Test.java测试IOC

public class Test {
    public static void main(String[] args)throws  Exception {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();
        User user = new User();
        UserService userService = (UserService) context.getBean("userService");
        userService.add(user);
    }
}

打印出

打印结果

整个的原理就是这些，不过Spring的BeangongFactory实现要比这复杂的多，还要涉及注解、多种注入方式等等，不过原理就是这些。

源码下载

本工程详细源码