spring 依赖注入xml配置原理解析

本文实现了对spring的xml配置依赖注入的功能，也许并不是跟spring的实现一模一样，但是原理大致相同，本文旨在提供一种思路.....

1.添加相应的依赖包:

        <dependency>
  		<groupId>dom4j</groupId>
		<artifactId>dom4j</artifactId>
		<version>1.6.1</version>
  	</dependency>
  	<dependency>
  		<groupId>jaxen</groupId>
		<artifactId>jaxen</artifactId>
		<version>1.1.1</version>
  	</dependency><dependency>
	  	<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.16</version>
  	</dependency>
  	<dependency>
  		<groupId>junit</groupId>
  		<artifactId>junit</artifactId>
  		<version>4.11</version>
  	</dependency>

2.使用dom4j解析xml文档，通过反射获取相应的实例

public class Dom4jUtil {
	
	//单例
	private static final Dom4jUtil util = new Dom4jUtil();
	
	private SAXReader reader;
	
	private Document document;
	
	
	
	private Dom4jUtil(){
		reader = new SAXReader();
	}
	
	public static Dom4jUtil getInstance(){
		return util;
	}
	
	
	//保存bean的id和class，id为key，value为反射获得的实例
	private Map<String,Object> beans = new HashMap<String,Object>();
	
	//保存bean的id和其需要注入的property的name和ref，id为外层map的key，name和ref分别为内层map的key，value
	private Map<String,Map<String,String>> propertys = new HashMap<String,Map<String,String>>();
	
	/**
	 * 根据路径获取document对象
	 * @param xmlPath
	 * @return
	 * @throws DocumentException
	 */
	public Map<String,Object> parseXml(String xmlPath) throws DocumentException{
		document = reader.read(new File(xmlPath));
		this.parseBean(document);
		return this.getBeansMap(document);
	}
	
	/**
	 * 解析xml文档中的bean节点
	 * @param document
	 */
	@SuppressWarnings("unchecked")
	public void parseBean(Document document){
		if(document==null){
			return;
		}
		//获取根元素beans
		Element ele = document.getRootElement();
		//使用xpath表达式查找所有的bean节点
		List<Element> beanElements = ele.selectNodes("//beans/bean");
		//保存bean里面的property节点
		List<Element> propElements = null;
		//保存property的name和ref，name为key,ref为value
		Map<String,String> props = null;
		//保存bean的id属性
		String id = null;
		//保存bean的class属性
		String classpath = null;
		//获取的class
		Class<?> clz = null;
		for(Element beanElement:beanElements){
			id = beanElement.attributeValue("id");
			classpath = beanElement.attributeValue("class");
			if(classpath==null||"".equals(classpath)){
				throw new RuntimeException("The class attribute must be not null or ''");
			}
			//如果没写id属性，默认id就是类名小写
			if(id==null||"".equals(id)){
				//截取类名
				id = classpath.substring(classpath.lastIndexOf(".")+1);
				//类名首字母小写
				id = id.replace(id.charAt(0), Character.toLowerCase(id.charAt(0)));
			}
			try {
				clz = Class.forName(classpath);
			} catch (ClassNotFoundException e) {
				throw new RuntimeException("The class "+classpath+ " is not found");
			}
				id = classpath.substring(classpath.lastIndexOf(".")+1);
				//类名首字母小写
				id = id.replace(id.charAt(0), Character.toLowerCase(id.charAt(0)));
			}
			try {
				clz = Class.forName(classpath);
			} catch (ClassNotFoundException e) {
				throw new RuntimeException("The class "+classpath+ " is not found");
			}
			//判断该类是否已经被实例化
			if(beans.containsKey(id)){
				throw new RuntimeException("The class "+classpath+ " has already been instantiated");
			};
			try {
				//将bean进行保存
				beans.put(id, clz.newInstance());
			} catch (InstantiationException e) {
				throw new RuntimeException("The class "+classpath+" must be have default constructor");
			} catch (IllegalAccessException e) {
				throw new RuntimeException("The class "+classpath+" must be have default constructor");
			}
			//查找某个bean节点下的所有property节点
			propElements = beanElement.selectNodes("property");
			props = new HashMap<String,String>();
			for(Element propElement:propElements){
				props.put(propElement.attributeValue("name"), propElement.attributeValue("ref"));
			}
			//判断某个bean下是否有property，有就加到propertys里面
			if(!props.isEmpty()){				
				propertys.put(id, props);
			}
		}
	}
	
	//注入bean,在调用改方法前需调用上面parseBean方法完成文档的解析
	public Map<String,Object> getBeansMap(Document document){
		if(beans==null){
			return null;
		}
		//如果propertys为空,说明没有属性要注入,直接返回beans
		if(propertys.isEmpty()){
			return beans;
		}
		//迭代解析好的bean(这些bean还没有完成属性注入)
		Set<String>  idSet = propertys.keySet();
		for(String id:idSet){
			Object obj = this.injectProperty(id);
			//将注入好的bean重新放到beans里面
			beans.put(id, obj);
		} 
		return beans;
	} 
	
	//注入bean的属性
	private Object injectProperty(String id){
		Map<String,String> props = null;
		Set<String> names = null;
		props = propertys.get(id);
		//迭代某个bean的property节点
		names = props.keySet();
		Object obj = beans.get(id);
		try {
			//name为property节点的name属性,props.get(name)为property节点的ref属性
			for(String name:names){
				//获取bean的所有属性描述
				PropertyDescriptor[] pds = Introspector.getBeanInfo(obj.getClass()).getPropertyDescriptors();
				for(PropertyDescriptor pd:pds){
					Method method = pd.getWriteMethod();
					if(method!=null){
						//判断变量名称是否和bean需要注入的name属性值是否一样
						if(!pd.getName().equals(name)){
							throw new RuntimeException("the class "+obj.getClass().getName()+" does not have such property '"+name+"'");
						}
						//判断变量的类型和注入的类型是否有父子关系
						if(!pd.getPropertyType().isAssignableFrom(beans.get(props.get(name)).getClass())){
							throw new RuntimeException("the class "+obj.getClass().getName()+" can not be cast to "+pd.getPropertyType().getName()+"");
						};
						method.invoke(obj, beans.get(props.get(name)));
					}
				}
			}
		} catch (IntrospectionException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return obj;
	} 
}

3.需注入的dao,service

public interface IUserDao {
	void addUser();
}

public class UserDao implements IUserDao{

	@Override
	public void addUser() {
		System.out.println("进行了新增操作");
	}

}

public interface IUserService {
	void addUser();
}

public class UserService implements IUserService{
	
	private IUserDao userDao;
	
    //添加set方法进行注入
	public void setUserDao(IUserDao userDao) {
		this.userDao = userDao;
	}

	@Override
	public void addUser() {
		userDao.addUser();
	}
}

4.配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean class="cn.edu.hbut.zw.spring.dao.impl.UserDao"></bean>
	<bean class="cn.edu.hbut.zw.spring.service.impl.UserService">
		<property name="userDao" ref="userDao"/>
	</bean>
</beans>

5.测试

public class SpringTest {
	@Test
	public void testXml(){
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		IUserService us = (IUserService) context.getBean("userService");
		us.addUser();
	}
}