简略模拟spring di

简单模拟spring di
spring di(即依赖注入)的原理个人理解是这样子的，先读取配置文件，在通过解析xml将有用的信息扣取出来，再通过反射机制来实现类或方法的实例化。
今天我模拟了两种注入方式一种是注入bean，另一种是注入一个factory.对于工厂模式本人觉得还蛮好用的，只要搭建起了架构感觉管理起来挺容易的。还有bridge模式在开发中也是很便于管理的。所以我在这个小例子里面结合了bridge和factory模式。

下面是代码：
1，UserDao:接口

public interface UserDao {

	public boolean add();
	
}

2，ImplUserDaoMySql：实现UserDao接口的MySql数据库dao层

public class ImplUserDaoMySql implements UserDao {

	@Override
	public boolean add() {
		System.out.println("add MySql Dao!");
		return true;
	}

}

3，ImplUserDaoOracle：实现UserDao接口的Oracle数据库dao层

public class ImplUserDaoOracle implements UserDao {

	@Override
	public boolean add() {
		System.out.println("add Oracle Dao!");
		return true;
	}

}

上面两个就可以体现出桥模式的优点

4，DaoFactory：工厂模式类用于生产各种UserDao

public class DaoFactory {

	public static UserDao getUserDaoOracle(){
		return new ImplUserDaoOracle();
	}
	
	public static UserDao getUserDaoMySql(){
		return new ImplUserDaoMySql();
	}
}

5，AnalogApplicationContext：模拟di主程序

public class AnalogApplicationContext {
	private Map<String, Object> map = new HashMap<String, Object>();

	public AnalogApplicationContext(String configLocation) {
		// 解析配置文件，将信息放入map中
		SAXReader sax = new SAXReader();

		try {
			Document document = sax.read(AnalogApplicationContext.class
					.getResourceAsStream(configLocation));
			Element root = document.getRootElement();
			List<Element> elements = root.elements();
			for (int i = 0; i < elements.size(); i++) {
				Element element = elements.get(i);
				String idDI = element.attribute("id").getData().toString();
				String classDI = element.attribute("class").getData()
						.toString();
				String factoryMethodDI = "";
				if (element.attribute("factory-method") == null) {
					map.put(idDI, Class.forName(classDI).newInstance());
				} else {
					factoryMethodDI = element.attribute("factory-method")
							.getData().toString();
					Object obj = Class.forName(classDI).newInstance()
							.getClass().getDeclaredMethod(factoryMethodDI)
							.invoke(Class.forName(classDI).newInstance());
					map.put(idDI, obj);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public Object getBean(String id) {
		return map.get(id);
	}
}

6，applicationContext-di.xml：spring模拟配置文件，注意本模拟程序中applicationContext-di.xml必须和AnalogApplicationContext.java主模拟程序放在同一目录下，应为我获取applicationContext-di.xml文件路径是先通过AnalogApplicationContext.java来获取，当然这个也是可变的，自由发挥喽。

<?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"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
	
	<bean id="userDaoOracle" class="com.fairy.spring.di.impldao.ImplUserDaoOracle" />	
	<bean id="userDaoMySql" class="com.fairy.spring.di.daofactory.DaoFactory" factory-method="getUserDaoMySql" />
	
</beans>

7，TestDI：测试类，用来测试两种注入方式

public class TestDI {

	/**
	 * @测试模拟spring DI程序
	 */
	public static void main(String[] args) {
		/**
		 * 测试bean注入模式
		 */
		AnalogApplicationContext alAcOracle = new AnalogApplicationContext("applicationContext-di.xml");
		UserDao userdaoOracle = (UserDao)alAcOracle.getBean("userDaoOracle");
		userdaoOracle.add();
		/**
		 * 测试factory注入模式
		 */
		AnalogApplicationContext alAcMySql = new AnalogApplicationContext("applicationContext-di.xml");
		UserDao userdaoMySql = (UserDao)alAcMySql.getBean("userDaoMySql");
		userdaoMySql.add();
	}

}