手动模拟IOC容器

   引言

   最近在看一些关于IOC原理的东西，比较理论,所以还是自己动手模拟一个IOC，这样会对原理理解的更加深一些。

   首先我们把我们需要用的dao、service、entity定义出来：

   Student.java

   

public class Student {
	private int id;
	private String name;
	private String address;

        这省略set  get方法

}

  StudentDaoImp.java

public class StudentDaoImp implements StudentDao {

	@Override
	public void add(Student stu) {
		System.out.println("stu is saved");   
		
	}

}

 StudentServiceImp.java

public class StudentServiceImp implements StudentService {
	
	private StudentDao stuDao =null;
	
	
	public StudentDao getStuDao() {
		return stuDao;
	}


	public void setStuDao(StudentDao stuDao) {
		this.stuDao = stuDao;
	}


	@Override
	public void add(Student stu) {
		
		stuDao.add(stu);
		
	}

}

  这里我们是模拟spring IOC的功能，所以我们需要在service层中定义Dao的实例，我们通过spring的IOC容器把这里的dao层注入进来，不要忘了对dao提供set get方法，因为IOC底层其实就是利用反射机制实现的，他把dao注入进来，其实底层就是通过反射set进来的。

  定义好上面这些比较简单的代码，下一步就是需要定义我们自己的ClassPathXmlApplicationContext类了，通过他，在我们new出他的对象的时候，他来加载我们的配置文件，然后把我们的dao操作注入到service层，通过源码我们知道，在spring中ClassPathXmlApplicationContext实现了一个BeanFactory接口，在此我们也定义一个接口，其实这个接口中就是来模拟spring 的，主要用来获得bean的

public interface BeanFactory {

	public Object getBean(String id);
}

 

 下面来看一下关于bean的配置文件:Beans.xml

<beans>
	<bean id="stuDao" class="com.dmsd.ioc.dao.StudentDaoImp" />
	<bean id="stuService" class="com.dmsd.ioc.service.StudentServiceImp" >
		<property name="stuDao" bean="stuDao"/>
	</bean>
</beans>

   下面就是我们核心类ClassPathXmlApplicationContext.java的实现了
    
   

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class ClassPathXmlApplicationContext implements BeanFactory {

	// 定义一个容器，这个容器就是用来装载我们一个个bean的
	private Map<String, Object> beans = new HashMap<String, Object>();

	public ClassPathXmlApplicationContext() throws Exception {
		SAXBuilder sb = new SAXBuilder();
		//构造文档对象
		Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));
		Element root = doc.getRootElement();//获取根元素
		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.println("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");
				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 nmae =" + 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);
	}

  首先我们定义了一个容器Map<String, Object> beans，这个容器的作用就是用来装我们从配置文件里解析来的一个个bean，为什么要用map类型，我想大家也差不多能猜到吧，我们配置文件中每一个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取出来。

  关于代码中构造setter方法的代码，大家可以戳这了解细节

  下面创建一个测试类看看是否成功：

  

public static void main(String[] args) throws Exception {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();
		Student stu = new Student();
		StudentService service = (StudentService) context.getBean("stuService");
		service.add(stu);
	}

  运行结果：

  

bean id isstuDao
, clazz is com.dmsd.ioc.dao.StudentDaoImp
bean id isstuService
, clazz is com.dmsd.ioc.service.StudentServiceImp
setter method nmae =setStuDao
stu is saved

  到这我们关于spring容器的解析就算完了，其实我们从自己动手模拟IOC来看，整个容器的核心就两部分：先解析xml配置文件，然后通过反射得到bean。但是这种思想确实非常巧妙的，有了sprig容器StudentServiceImp不再依赖StudentdaoImp，而是通过Spring提供服务的方式，将StudentServiceImp和StudentdaoImp联系在一起，而且这种依赖关系是在程序运行时才确定的。
StudentServiceImp独立了，独立意味着简单灵活，所以IoC延迟注入的思想，在进行面向对象开发中必不可少的利器