关于DB事务管理的两种解决方案

 

    我最近一直在思考一个问题，当自己不使用任何管理事务框架的时候，自己应该如何控制事务。

 

    如果我每次操作数据库，都是一个事务，每次都打开事务，关闭事务，那是一件很麻烦的事情，比如有以下方法

 

public class LoginDao { public void insert() { 打开事务 DB更删改查 关闭事务 } public void update() { 打开事务 DB更删改查 关闭事务 } } public class TestDao { public void insert() { 打开事务 DB更删改查 关闭事务 } public void update() { 打开事务 DB更删改查 关闭事务 } } 

    如果我有很多很多的数据表，很多很多的DB操作，那我就需要写很多的打开事务，关闭事务的语句，这样很可能有所遗漏，而且以后很难找出因此发生错误的原因和地方，基于上面的原因，有了这篇文章。

 

    昨天晚上和朋友讨论了这个问题，他现在做的一个项目来说，是自己写代码自行控制事务，什么时候打开，什么时候关闭，都是自己决定，之所以采用这种方式，是因为他的项目是多数据源的，对于事务控制来说，是相当复杂的，人为的控制事务带来了一定的灵活性，当然其中也存在着一些风险，也会出现一些不可以预料的bug，因为你不得不对事务进行配对，有打开，就必须有关闭等等。

 

    目前，我只想到两种解决方案，我想这一定不是最好的，只是一种处理的方法，希望看到此博客的大侠们指点一二。

 

    事务管理方案一：

          此方案，也就是借鉴了spring中的AOP技术，使用代理模式，生成目标对象的代理对象，通过代理对象，对目标对象的方法执行进行控制。代码如下：

 

public class DaoFactory { private static Map<String, Object> daos = new HashMap<String, Object>(); static { BeanFactory.init("dao.properties"); } /** * 获取Dao * @param <T> * @param name * @return */ @SuppressWarnings("unchecked") public static <T> T getDao(String name) { AOPFactory aop = new AOPFactory(); return (T)aop.createProxyIntance(BeanFactory.getBean(daos, name)); } public static <T> T getDao(Class<?> clazz) { return getDao(clazz.getSimpleName()); } } class AOPFactory implements InvocationHandler { // 目标对象 private Object targetObject; public Object createProxyIntance(Object targetObject) { this.targetObject = targetObject; // 代理会实现目标对象的接口中所有方法 return Proxy.newProxyInstance(this.targetObject.getClass() .getClassLoader(), this.targetObject.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; // 打开事务 openTransaction(); //执行目标对象方法 result = method.invoke(targetObject, args); // 关闭事务 closeTransaction(); return result; } } LoginDao loginDao = DaoFactory.getBean("LoginDao"); 

凡是获取Dao类，对DB进行CRUD操作，就是用DaoFactory.getBean("LoginDao");来获取，这个时候，就会给这个Dao创建一个代理类，在取得了Dao以后，调用Dao中的任何方法，都是通过Dao的代理类来执行的，也就是说，执行了AOPFactory 中public Object invoke(Object proxy, Method method, Object[] args) throws Throwable；方法，比如，我需要调用更新方法

 

loginDao.update(); 

这个时候的执行结果就是：

 

     打开事务

     执行DB操作

     关闭事务

 

 

 

 

 事务管理方案二：

       使用注解的方式，具体实现方法是使用java的反射技术，生成一个统一对象方法调用接口，只要是调用一个对象中的方法，那么我们就用统一的模式。说起来比较绕口抽象，看如下代码：

//Excutor.java

//Excutor.java public class Excutor { /** * 方法统一执行API * * @param obj * @param methodName * @param args * @return */ public static Object invoke(Object obj, String methodName, Object... args) { Method[] methods = obj.getClass().getDeclaredMethods(); T retObj = null; for (Method method : methods) { if (method.getName().equals(methodName)) { Transaction transaction = method .getAnnotation(Transaction.class); try { if (null != transaction) { System.out.println("打开事务"); openTransaction(); } retObj = (T) method.invoke(obj, args); if (null != transaction) { System.out.println("关闭事务"); closeTransaction(); } } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } } return retObj; } } 

 

// Transaction.java

/** * @author Administrator * */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Transaction { } 

 

//Register.java

public class Register { /** * 注册用户 */ @Transaction public void register(BaseDto dto) { //DB的CRUD操作 create(); update(); delete(); } } 

 

这个时候我们需要调用Register中的方法，那么我们就是用上面的Excutor中的invoke方法

Register reg = new Register(); Excutor.invoke(reg, "register"); 

这样，我们就可以在需要事务的方法上面加上@Transaction注解，就可以实现事务的管理了，也就是说register方法中任何更删改查操作有一个失败，那就都失败，数据库回滚至调用register方法之前的状态。

 

其实还有一个很笨的方法，那就是在业务层，创建一个抽象类，其中有一个抽象方法，凡是实现业务层的类，都继承该抽象类，实现其中的抽象方法，这样，就可以做到在业务层对事务的统一管理了，不需要每次写一个更删改查都需要打开事务，关闭事务了