创建自己的IOC和事务管理(下)

上节使用了工厂模式、单例模式和动态代理创建了IOC和事务管理，为了更加灵活地管理bean，本节将对上节的代码进行改进， bean与 bean之间的依赖关系被放在配置文件里组织，而不是写在代码里，通过配置文件动态管理bean，可使对象与对象之间的依赖关系从代码里分离出来。

修改bean.xml文件的配置,添加<property name="userDao" ref="userDao"/>：

<?xml version="1.0" encoding="UTF-8"?>
<beans>
   <!-- 数据库的配置 -->
	<config>
		<db-info>
			<driver-name>com.mysql.jdbc.Driver</driver-name>
			<url>jdbc:mysql://localhost:3306/jdbctest</url>
			<username>root</username>
			<password>111</password>
		</db-info>
	</config>

   <bean-service>
      <bean id="userDao" class="com.lrh.dao.UserDaoImpl">

      </bean>
   </bean-service>

   <bean-dao> 
      <bean id="userService" class="com.lrh.service.UserServiceImpl">
         <property  name="userDao"  ref="userDao"/>
     </bean>
   </bean-dao>

   <aop-config>
       <aop-pointcut expression="com.lrh.service"/>
   </aop-config>
   <tx-advice>
     	<tx-attributes>
		       <tx-method name="add*"/>
		       <tx-method name="delete*"/>
		       <tx-method name="modify*"/>
		       <tx-method name="*"/>
    	 </tx-attributes>
   </tx-advice>

</beans>

对BeansFactory类进行改进，修改后的BeansFactory类的代码如下：

package com.lrh.utils;

import java.io.FileInputStream;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.lrh.service.EmployeeService;
import com.lrh.service.UserService;
import com.lrh.utils.ProxyHandler;
/**
 * 用来管理bean的工厂类
 * @author jenhui
 *
 */
public class BeansFactory {

	private static BeansFactory instance=null;
	private  Document document=null; 
	private  Map map=new HashMap();
	private BeansFactory(){

		Object object=null;
		try{
			SAXReader reader=new SAXReader();
			document=reader.read(new FileInputStream("D:/workspace/beans.xml"));
			List beanEles=document.selectNodes("//bean");      //获取所有的bean标签
			for(Iterator iter=beanEles.iterator();iter.hasNext();){
				Element beanEle=(Element)iter.next();
				String idValue=beanEle.attributeValue("id");
				String className=beanEle.attributeValue("class");
			   	object=Class.forName(className).newInstance();
			   	map.put(idValue, object);
			}
			for(Iterator iter=beanEles.iterator();iter.hasNext();){
				Element beanEle=(Element)iter.next();       //利用索引器逐个获取bean标签
				String idValue=beanEle.attributeValue("id");
				String className=beanEle.attributeValue("class");
			//	Object idBean=Class.forName(className).newInstance(); //创建实现了接口的类的对象
				Object idBean=map.get(idValue);       //根据id的值到map中找到对应的对象
				Iterator propertyIter=beanEle.elementIterator();      //依次获取bean标签下的所有property标签
		    	for(;propertyIter.hasNext();){
		    		Element propertyEle=(Element)propertyIter.next();
		    		String refValue=propertyEle.attributeValue("ref");
		    		if(map.containsKey(refValue)){      //查找property标签的ref所引用的对象是否存在
			    		Object bean=map.get(refValue); 
			    		Method[] methods=idBean.getClass().getMethods();
			    		for(Method m:methods){
			    			refValue =refValue.replaceFirst(refValue.substring(0, 1),refValue.substring(0, 1).toUpperCase());
			    			String methodName="set"+refValue;
			    			if(methodName.equals(m.getName())){
			    				m.invoke(idBean,bean);    //注入对象bean到idBean中
			    			}
			    		}

		    		}

		    	}

			}

		}catch(Exception e){
			e.printStackTrace();
		}

	}
	public synchronized static BeansFactory getInstance(){
		if(instance==null){
			instance=new BeansFactory();
		}
		return instance;
	}

	public Document getDocument(){
		return document;
	}

	public Object getBeanObject(String beanId){
		Object obj=null;
		if(map.containsKey(beanId)){
		    obj= map.get(beanId);
			Element daoEle=(Element)document.selectSingleNode("//bean[@id=\""+beanId+"\"]");
			String className=daoEle.attributeValue("class");
			Element aopEle=(Element)document.selectSingleNode("/beans/aop-config/aop-pointcut");
	    	String expression=aopEle.attributeValue("expression");
	    	String packName=className.substring(0, className.lastIndexOf("."));

	    	if(expression.equals(packName)){
	    	  ProxyHandler proxyHandler=new ProxyHandler();
	    	  obj=proxyHandler.createProxyInstance(obj);
	    	}

		}

		return obj;
	}

}

为UserServiceImpl类添加userDao属性并提供set方法，以便设值注入。

package com.lrh.service;

import com.lrh.dao.UserDao;
import com.lrh.orm.User;
import com.lrh.utils.BeansFactory;
/**
 * 
 * @author jenhui
 *
 */
public class UserServiceImpl implements UserService {

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

	public void addUser(User user) {
		userDao.addUser(user);
	}

}

最后写个测试类来测试：

package com.lrh.web;

import com.lrh.orm.User;
import com.lrh.service.EmployeeService;
import com.lrh.service.UserService;
import com.lrh.utils.BeansFactory;
/**
 * 
 * @author jenhui
 *
 */

public class Client {

	public static void main(String[] args){		
		UserService userService=(UserService)BeansFactory.getInstance().getBeanObject("userService");

		User user=new User();
		user.setId("QQ");
		user.setPassword("QQ1259111695");
		user.setName("kelly");
		userService.addUser(user);
	}

}

时间不早了，先到此结束吧。