事务模板

Jul 10, 2017 10:38:44 AM

为什么提供事务模板

截至到现在为止，除非你使用 dao.execute(Sql …) ，一次执行多个 SQL，是事务安全的，其他的情况均是事务不安全的，比如如下代码：

  1. Pet pet1 = dao.fetch(Pet.class,"XiaoBai");
  2. Pet pet2 = dao.fetch(Pet.class,"XiaoHei");
  4. pet1.setNickname("BaiBai");
  5. pet2.setNickname("HeiHei");
  7. dao.update(pet1);
  8. dao.update(pet2);

尤其是请关注最后两句:

  1. dao.update(pet1);
  2. dao.update(pet2);

当第二句话抛出异常的时候，第一句话不能被回滚。这两条调用就是不事务安全的。如果我想让 pet1 和 pet2的更新操作是原子性的，它们必须一同成功，一同失败，怎么办呢？

使用事务模板

Nutz.Dao 提供了简单的解决办法： 事务模板

一段示例代码

上一节的例子可以修改为:

  1. final Pet pet1 = dao.fetch(Pet.class,"XiaoBai");
  2. final Pet pet2 = dao.fetch(Pet.class,"XiaoHei");
  4. pet1.setNickname("BaiBai");
  5. pet2.setNickname("HeiHei");
  6. // Begin transaction        
  7. Trans.exec(new Atom(){
  8.     public void run() {
  9.         dao.update(pet1);
  10.         dao.update(pet2);
  11.     }
  12. });
  13. // End transaction

提供一个 org.nutz.trans.Atom 接口的匿名实现，在里面执行的所有的 Dao 操作都是原子性的，因为它们在同一个 “原子 (Atom)” 里。

事务的关键就是原子的界定

事务最核心的是原子的界定，在 Nutz.Dao中，界定原子的方法出奇的简单，借助匿名类，你可以随时将一段代码用你的原子实现包裹住。而 Trans.exec() 方法接受数目可变的原子，每个原子都是事务性的。

Trans.exec 的函数声明

  1. public static void exec(Atom... atoms);

被原子实现包裹住的代码就是事务安全的，无论它同时操作了多少个 DataSource。Nutz.Dao 提供的原子接口非常简单，实际上它就是 java.lang.Runnable 的一个别名，下面就是这个接口的全部代码：

  1. package com.zzh.trans;
  2. public interface Atom extends Runnable {}

这几乎是我写过的最简单的 Java 类了，正是因为它简单，所以才有无限的威力。你如果查看过 Nutz 的源代码包，在和数据库操作的地方，你总会和 Atom 不期而遇。很多朋友曾经很不适应匿名类的写法，是的，我在早期写 Java 的时候也比较讨厌匿名类，但是熟悉了以后，你会真正喜欢上这个东西，就像你写 Javascript 的一段时候以后，多数人都会喜欢上“闭包”一样。你可以把匿名类当作 Java 给你的闭包。

采用事物模板的来界定事物有一个缺点，这是 Java 语言带来的限制：你有可能需要将一些相关的变量声明成 final 的。并且在 run 函数中，你只能向外抛 RuntimeException 或其子类。

设置事务的级别

在 JDBC 的 java.sql.Connection 接口中定义的 setTransactionIsolation 函数可以设置事务的级别Nutz.Dao 也提供另外一个静态函数，允许你设置事务的级别:

Trans.exec 的函数声明

  1. public static void exec(int level, Atom... atoms);

这里的第一个参数 level 和 java.sql.Connection 接口中的 setTransactionIsolation 规定的 level 是一样的。下面是在 java.sql.Connection 里面关于 level 参数的 JDoc 说明：

它可以是下列常量中的任意一个值：

  • Connection.TRANSACTION_READ_UNCOMMITTED
  • Connection.TRANSACTION_READ_COMMITTED
  • Connection.TRANSACTION_REPEATABLE_READ
  • Connection.TRANSACTION_SERIALIZABLE
    注意： 不能使用常量 Connection.TRANSACTION_NONE，因为它的意思是“不支持事务”

关于 level 参数的更多说明，请参看java.sql.Connection 的文档)

不同的数据库，对于 JDBC 事务级别的规范，支持的力度不同。请参看相应数据库的文档，已 确定你设置的数据库事务级别是否被支持。

事务的嵌套

Nutz 的事务模板可以嵌套吗？ 答案是肯定的。事实上，Nutz 支持事务模板的无限层级嵌套。

这里，如果每一层嵌套，指定的事务级别有所不同，不同的数据库，可能引发不可预知的错误。所以，嵌套的事务模板的事务，将以最顶层的事务为级别为标准。就是说，如果最顶层的事务级别为 'TRANSACTION_READ_COMMITTED'，那么下面所包含的所有事务，无论你指定什么样的事务级别，都是 'TRANSACTION_READ_COMMITTED'， 这一点，由抽象类 Transaction 来保证。其 setLevel 当被设置了一个大于 0 的整数以后，将不再 接受任何其他的值。

你可以通过继承 Transaction 来修改这个默认的行为，当然，这个行为修改一般是没有必要的。

另外，你还可能需要知道，通过 Trans.setup 方法，能让整个虚拟机的 Nutz 事务操作都使用你的 Transaction 实现

下面我给出两个例子:

最外层模板决定了整个事务的级别:

  1. Trans.exec(Connection.TRANSACTION_READ_COMMITTED, new Atom(){
  2.     public void run(){
  3.         dao.update(xxx);
  4.         dao.update(bbb);
  6.         // 在下层模板，虽然你指定了新的事务级别，但是这里的事务级别还是
  7.         // 'TRANSACTION_READ_COMMITTED'。在一个事务中，级别一旦设定就不可更改
  8.         Trans.exec(Connection.TRANSACTION_SERIALIZABLE, new Atom(){
  9.             public void run(){
  10.                 dao.update(CCC);
  11.                 dao.update(EEE);
  12.             }
  13.         });
  14.     }
  15. });

让整个函数都是事务的:

  1. public void updatePet(final Pet pet){
  2.     Trans.exec(new Atom(){
  3.         public void run(){
  4.             dao.update(pet);
  5.             dao.update(pet.getMaster());
  6.         }
  7.     });
  8. }
  10. // 在另外一个函数里，可以这么使用
  11. public void updateDogAndCat(final Pet dog, final Pet cat){
  12.     Trans.exec(new Atom(){
  13.         public void run(){
  14.             updatePet(dog);
  15.             updatePet(cat);
  16.         }
  17.     });
  18. }

扩展实现

org.nutz.trans.Trans 类的 exec()方法，接受数目可变的 Atom 实例，足够方便了吧。 但是它默认只能支持在一台机器上保证事务性，就是在一个 JVM 里保证代码的事务性。如果跨越多个JVM一起组合的 Service，如何保证事务性呢，很抱歉，Nutz.Dao 的第一版的实现里不包括跨越多个JVM依然保证事务性的功能，但是你如果真的需要这个功能也没关系，你可以自己写一个 org.nutz.trans.Transaction 的实现，然后在你的应用启动时，通过

  1. org.nutz.trans.Trans.setup(你的实现类)

替换 Nutz.Dao 的默认实现。

总结一下 Nutz.Dao 事务

  • org.nutz.trans.Trans 类提供了两个函数 exec
    • 一个接受数目可变的 Atom 对象
    • 一个接受一个整型值用以界定本事务的级别，以及一个数目可变的 Atom 对象
  • Atom 类就是 java.lang.Runnable 的一个别名
  • 在一个 Atom 里，无论同时操作多少 DataSource，都是事务安全的(由于不是使用XADataSource,无法100%保证)
  • 你可以通过实现自己的 Transaction 实现类，扩展 Nutz.Dao 对于事务的支持

本页面的文字允许在知识共享 署名-相同方式共享 3.0协议和GNU自由文档许可证下修改和再使用。

原文: http://nutzam.com/core/dao/transaction.html