模拟Spring阐述依赖注入的思想以及spring的内部的实现原理（读取配置文件，通过反射进行装配和依赖注入）...

<?xml version="1.0" encoding="UTF-8"?>
<HD><disk name="C"><capacity>8G</capacity><directories>200</directories><files>1580</files></disk><disk name="D"><capacity>10G</capacity><directories>500</directories><files>3000</files></disk>
</HD> 

写解析jdom的方法：

import java.util.List;import org.jdom.*;
import org.jdom.input.SAXBuilder;public class sample1 {public static void main(String[] args) throws Exception{ SAXBuilder sb=new SAXBuilder();//构造文档对象Document doc=sb.build(ClassLoader().getResourceAsStream(&#l")); //获取根元素HDElement root&#RootElement(); //取名字为disk的所有元素List list&#Children("disk");//通过集合遍历所有元素,一个disk其实就是一个元素for(int i=0;i<list.size();i++){Element element = (Element) (i);String name = AttributeValue("name");//获取属性为name的值String capacity&#ChildText("capacity");//取disk子元素capacity的内容String directories&#ChildText("directories");String files&#ChildText("files");System.out.println("磁盘信息:");System.out.println("分区盘符:"+name);System.out.println("分区容量:"+capacity);System.out.println("目录数:"+directories);System.out.println("文件数:"+files);System.out.println("-----------------------------------");}  }
}

运行结果：
　    
磁盘信息:
分区盘符:C
分区容量:8G
目录数:200
文件数:1580
-----------------------------------
磁盘信息:
分区盘符:D
分区容量:10G
目录数:500
文件数:3000
-----------------------------------

2.使用反射的思想和jdom解析XML文件模拟Spring容器初始解析配置文件的过程，以及搞明白什么是IOC/DI

在不用Spring的时候，我们在Service调用DAO,需要在UserService里面把new Dao层的对象。例如private UserDao userDAO = new UserDAOImpl();有了容器后容器帮我们把DAO层注入到Service层。怎么注入的？我们看下面的代码：

下面是我的整个项目工程：

这里给出部分代码：

DAO层：

package com.lp.dao;import del.User;
//UserDao负责把对象存到不同的数据库中去，考虑为什么写成接口，而不写成一个类？
//答案是：为了实现跨数据库，面向抽象的编程
public interface UserDao {public void save(User user);
}

package com.lp.dao.impl;import com.lp.dao.UserDao;
import del.User;
//UserDAOImpl负责和不同的数据库打交道，为了实现跨数据库，我们可以多写几个UserDao的实现
//例如mysql的连接就写一个UsermysqlDAO的实现，其它数据库的实现就写其他数据库的实现
public class UserDAOImpl implements UserDao {public void save(User user) {//这里写不同的数据库连接的实现//Hibernate//JDBC//XML//NetWorkSystem.out.println("user saved!");}}

Service层：

package com.lp.service;import com.lp.dao.UserDao;
import del.User;
import com.lp.dao.impl.UserDAOImpl;

public class UserService {//private UserDao userDAO = new UserDAOImpl();private UserDao userDAO;//有了配置文件就不用向上面的那样new了，public UserDao getUserDAO() {return userDAO;}public void setUserDAO(UserDao userDAO) {this.userDAO = userDAO;}//向数据库中添加一个用户，只要通过调用UserDAO，然后通过调用save()方法就能实现public void add(User user){userDAO.save(user);}}

 模拟Spring里面的l在src下面放置要解析的配置文件l,代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans><!-- 把 UserDAOImpl读出来放到DAO里面去，也就是new一个Class的对象为u的--><bean id="u" class="com.lp.dao.impl.UserDAOImpl"/><bean id="userService" class="com.lp.service.UserService"><!-- 在userService有一个属性，这个属性就是userDAO，更准确点就是setUserDAO方法，也就是说spring可以把userService下面的userDAO注入进来，装配到一块。--><property name = "userDAO" bean="u"></property></bean>
</beans>

跟上面读取配置文件一样。这个类实现了一个接口叫做BeanFactory。叫做bean工厂。

package com.lp.spring;
/** 存放各种各样的DAO的工厂*/
public interface BeanFactory {public Object getBean(String name);//每个bean都有一个名字通过id指定
}

    为了模拟spring怎样读取配置文件还需要读取配置文件的类，这里我们自己创建一个包叫Com.lp.spring这里存放了spring里面的类：这里ClassPathXmlApplicationContext类：ClassPathXmlApplicationContext：使用这个类来读取l的配置文件,实现BeanFactory，实现里面获取bean对象的方法：

    package com.lp.spring;import flect.Method;import java.util.*;import org.jdom.*;import org.jdom.input.SAXBuilder;/** ClassPathXmlApplicationContext是模拟spring的类*/public class ClassPathXmlApplicationContext implements BeanFactory {//用Map容器存储bean的名字和值private Map<String , Object> beans = new HashMap<String, Object>();//IOC Inverse of Control DI Dependency Injectionpublic ClassPathXmlApplicationContext() throws Exception {SAXBuilder sb=new SAXBuilder();//解析l文件Document doc=sb.Class().getClassLoader().getResourceAsStream(&#l")); //构造文档对象//获取根元素beansElement root&#RootElement(); List list&#Children("bean");//取名字为bean的所有的小孩存放到List集合当中for(int i=0;i<list.size();i++){Element element=((i);String id&#AttributeValue("id");//取出属性值为id的值String clazz&#AttributeValue("class");//取出属性值为class的值//把class="com.lp.dao.impl.UserDAOImpl"生成一个对象 o Object o = Class.forName(clazz).newInstance();//System.out.println(id);//System.out.println(clazz);beans.put(id, o);//然后把id和对应的对象放到容器里面//用了反射思想for(Element propertyElement : (List<Element>)Children("property")) {String name = AttributeValue("name"); //userDAOString bean = AttributeValue("bean"); //uObject beanObject = (bean);//UserDAOImpl instance
                   String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);//通过这句话构造setUserDAO()方法System.out.println("method name = " + methodName);Method m = o.getClass().getMethod(methodName, Class().getInterfaces()[0]);//setUserDAO(UserDao.class)
                   m.invoke(o, beanObject);}}  }/*** 从容器中把这个对象取出来*/public Object getBean(String id) {(id);}}

/*

 * 测试类专门写在另外一个source包里面，然后引入junit.jar文件，然后右键

 * 要测试的类，选择jUnitCase创建测试类

 * 使用bean容器

 */

package com.lp.service;
/** 测试类专门写在另外一个source包里面，然后引入junit.jar文件，然后右键* 要测试的类，选择jUnitCase创建测试类*/
import static org.junit.Assert.*;import org.junit.Test;import com.lp.dao.UserDao;
import del.User;
import com.lp.spring.BeanFactory;
import com.lp.spring.ClassPathXmlApplicationContext;public class UserServiceTest {@Testpublic void testAdd() throws Exception {//把容器给new出来BeanFactory factory = new ClassPathXmlApplicationContext();//思考怎样使UserService也不用new？答案就是交给工厂BeanFactory，从配置文件里面读出来//UserService service = new UserService();UserService service = (UserService) Bean("userService");/*UserDao userdao = (UserDao) Bean("u");service.setUserDAO(userdao);//把这个对象注入到service中
*/        User u = new User();service.add(u);}
}

运行结果：

method name = setUserDAO
user saved!

以前要写的代码与在容器中配置的文件对应关系：

<bean id="userService" class="com.lp.service.UserService"><property name = "userDAO" bean="u"></property></bean>

这段代码的意识：userService中调用userDao:

  相当于

    UserService service = new UserService();

    service.setUserDAO(userdao);

   这两句代码。

   意思：通过配置文件把userdao和service 这两个对象的关系设定好了，不用硬性的编码，也就是把userDao装配到service里面了。

IOC/DI原理：IOC(inverse of controll)控制反转：通过上面的例子可以看出，以前Service层中想调用Dao层中的方法，需要在Service层中new出来，是由自己控制的，而现在由Spring容器控制创建初始化bean（对象），维护bean与bean之间的关系，权利从程序中转移到了Spring容器，而程序本身不需要再维护。

DI(dependency injection)依赖注入：实际上和IOC是一个概念，为了更准确的描述Spring的核心技术，对象之间的关系是相互依赖的，一些通用的bean组件可以依赖容器注入进来。原理：也可以说成反射注入，通过使用解析XML技术，以及反射的机制，构造真实实例对象，构造set方法把userDAO这个bean注入到userService中。

好处：耦合性大大的降低，用配置文件注入bean，修改起来方便，不用硬性的修改代码。

转载于:.html