常用公共代码三对象的管理(仿Spring IOC和AOP)

在项目中，我们经常会写到一些公共的代码，来让开发人员调用，减少代码重复，下面，我就将一些常用到的公共类贴出来和大家分享！！

在我们的项目中，经常会出现dao、daoImpl、service、serviceImpl这样操作数据库的类出现，然而我们在使用它们的时候都会在相应的类中通过new关键字生成其对象，然后调用里面相应的操作方法，这样有一个弊端出现，对象不好管理，程序的拓展性能比较差，当我们要修改相应的实现类的时候还要在类中进行修改，不好维护，所以我们将这些类中定义在一个XML配置文件中，程序员只要写好相应的类进行配置，然后调用公共类我们的对象就帮你生成好了，代码实现如下：

1、编写相应的Dao类和实现类：

package com.common.beanmanage;

public interface Dao {
	public void addUser();
	public void addUserCount();
}

package com.common.beanmanage;
public class DaoImpl implements Dao {

	@Override
	public void addUser() {
		System.out.println("增加用户");
	}

	@Override
	public void addUserCount() {
		System.out.println("增加用户账单");
	}

}

package com.common.beanmanage;
public interface Service {
	public void add();
}
package com.common.beanmanage;
public class ServiceImpl implements Service{
	private Dao dao;
	public ServiceImpl(){
		this.dao=(DaoImpl)BeanFactory.getInstance().getDaoObject(Dao.class);
	}

	@Override
	public void add() {
		dao.addUser();
		dao.addUserCount();
	}
}


2、在配置文件中进行配置：beans.xml（相当于Spring中的依赖注入）

<?xml version="1.0" encoding="UTF-8"?>

<beans>

 <bean id="com.common.beanmanage" class="com.common.beanmanage.DaoImpl"></bean>

 <bean id="com.common.beanmanage.Dao" class="com.common.beanmanage.DaoImpl"></bean>

 <bean id="com.common.beanmanage.Service" class="com.common.beanmanage.ServiceImpl"></bean>

</beans>

3、编写生成实例的工厂类：
package com.common.beanmanage;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

/**
 * 创建Bean对象的管理类，对Bean对象进行管理
 * 运用到的设计模式：单例模式和工厂模式
 * @author Administrator
 *
 */
public class BeanFactory {
	
	private Document doc=null;
	private Map daoMap=new HashMap();//将class和创建好的对象放在Map中
	private Map serviceMap=new HashMap();//将class和创建好的对象放在Map中
	private static BeanFactory instance=new BeanFactory();//创建单例
	//构造函数，解析XML
	private BeanFactory(){
		try {
			doc=new SAXReader().read(Thread.currentThread().getContextClassLoader().getResourceAsStream("beans.xml"));
		} catch (DocumentException e) {
			e.printStackTrace();
		}
	}
	
        //生成dao的实例，不需要进行事物封装
	public synchronized Object getDaoObject(Class c){
		if(daoMap.containsKey(c.getName())){
			return daoMap.get(c.getName());
		}
		Element root = doc.getRootElement();
		List<Element> list=root.elements("bean");
		String className=null;
		Object obj=null;
		for(Element e:list){
			if(e.attribute("id").getStringValue().equals(c.getName())){
				className=e.attributeValue("class");
				break;
			}
		}
		if(className!=null){
			try {
				obj=Class.forName(className).newInstance();
				daoMap.put(c.getName(), obj);
			} catch (InstantiationException e1) {
				e1.printStackTrace();
			} catch (IllegalAccessException e1) {
				e1.printStackTrace();
			} catch (ClassNotFoundException e1) {
				e1.printStackTrace();
			}
		}
		return obj;
	}

	//生成service的实例，需要进行事物的封装
	public synchronized Object getServiceObject(Class c){
		if(serviceMap.containsKey(c.getName())){
			return serviceMap.get(c.getName());
		}
		Element root = doc.getRootElement();
		List<Element> list=root.elements("bean");
		String className=null;
		Object obj=null;
		for(Element e:list){
			if(e.attribute("id").getStringValue().equals(c.getName())){
				className=e.attributeValue("class");
				break;
			}
		}
		if(className!=null){
			try {
				obj=Class.forName(className).newInstance();
				//当业务逻辑有事务需要处理的时候，对对象进行一层封装
				TransactionHandler handler=new TransactionHandler();
				obj=handler.newProxyInstance(obj);
				serviceMap.put(c.getName(), obj);
			} catch (InstantiationException e1) {
				e1.printStackTrace();
			} catch (IllegalAccessException e1) {
				e1.printStackTrace();
			} catch (ClassNotFoundException e1) {
				e1.printStackTrace();
			}
		}
		return obj;
	}
	
	public static BeanFactory getInstance(){
		return instance;
	}
}

4、如果有事务要进行处理，我们还可以使用动态代理模式对事务进行封装处理，交给程序去处理，用户不用自己在方法中添加事务开启、提交或者回滚操作，使用代理模式实现

相当于Spring中的AOP，面向切面编程，一般在service方法里面对其进行封装，如上面的生成service实例
package com.common.beanmanage;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;

import com.common.db.ConnectionManager;
import com.common.db.DbUtil;

/**
 * 采用代理模式封装对事务的处理
 * 
 * @author Administrator
 * 
 */
public class TransactionHandler implements InvocationHandler {
	private Object targetObject;

	public Object newProxyInstance(Object targetObject) {
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
				targetObject.getClass().getInterfaces(), this);
	}

	@Override

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Connection conn = null;
		Object ret = null;
		try {
			//从ThreadLocal中取得Connection
			conn = ConnectionManager.getConnection();
			if (method.getName().startsWith("add") ||
				method.getName().startsWith("del") ||
				method.getName().startsWith("modify")) {
				//手动控制事务提交
				DbUtil.beginTransaction(conn);
				System.out.println("开启事物");
			}	
			//调用目标对象的业务逻辑方法
			ret = method.invoke(targetObject, args);
			if (!conn.getAutoCommit()) {
				//提交事务
				DbUtil.commitTransaction(conn);
				System.out.println("提交事物");
			}
//		}catch(ApplicationException e) {
//			if (!conn.getAutoCommit()) {
//				//回滚事务
//				ConnectionManager.rollbackTransaction(conn);
//			}
//			throw e;
		}catch(Exception e) {
			e.printStackTrace();
			if (e instanceof InvocationTargetException) {
				InvocationTargetException ete = (InvocationTargetException)e;
				throw ete.getTargetException();
			}
			if (!conn.getAutoCommit()) {
				//回滚事务
				System.out.println("出现异常，不能提交");
				DbUtil.rollbackTransaction(conn);
			}
			//throw new ApplicationException("操作失败！");
		}finally {
			DbUtil.close(conn);
		}
		return ret;
	}

}

5、编写我们的测试类
package com.common.beanmanage;

public class Client {
	private static Service service;
	static{
		service=(Service)BeanFactory.getInstance().getServiceObject(Service.class);
	}
	public static void main(String[] args) {
		//service=(Service)BeanFactory.getInstance().getServiceObject(Service.class);
		service.add();
	}

}


这样，我们在程序里面不用通过new关键字来实现对象的生成，而是通过配置文件，由程序解析配置文件帮我们实现了，并且在service的实现类中，我们不用考虑事务的操作了，

只要编写我们的业务逻辑的实现即可，通过动态代理模式帮我们把事务给处理好了，在这个里面，我们实际上模仿了Spring中的AOP和IOC的基本实现！大家可以思考一下，

灵活运用。