Design patterns 编写groovy闭包或某种模式来处理事务

我想在groovy中编写某种类型的闭包或方法模板模式，在一个地方处理DB事务

我想要的是这样的东西。。。 伪码

def txMethod(codeOrSetStatementsToExecute){
    //begin transaction
    execute given - codeOrSetStatementsToExecute
    //end transaction by commit or rollback
}

def createSomething(args){
    txMethod({
        -create1statement(args)
        -create2statement
    });
}

def deleteSomething(){
    txMethod({
        -delete1statement()
        -doSomethingElse
   });
}

---

不久前，我用JPA写了一些类似的东西。IIRC，它变成了这样：

class DB<T> {
    void save(T t) {
        transactional {
            em.persist(t)
            em.flush()
        }
    }

    void delete(T t) {
        transactional {
            em.remove(t)
        }
    }

    void update(T t) {
        transactional {
            em.merge(t)
            em.flush()
        }
    }

    protected UserTransaction getTransaction() {
        // get transaction from JPA/Context/Younameit
    }

    protected void transactional(Closure<?> closure) {
        def utx = getTransaction();

        try {
            utx.begin();
            closure.call();
            em.flush();
        } catch (Throwable t) {
            utx.setRollbackOnly()
            throw t;
        } finally {
            utx.commit();
        }
    }
}

classdb{
无效保存（T）{
交易的{
em.persist（t）
em.flush（）
}
}
无效删除（T）{
交易的{
em.remove（t）
}
}
无效更新（T）{
交易的{
em.merge（t）
em.flush（）
}
}
受保护的UserTransaction getTransaction（）{
//从JPA/Context/Younameit获取事务
}
受保护的无效事务（关闭）{
def utx=getTransaction（）；
试一试{
utx.begin（）；
closure.call（）；
em.flush（）；
}捕获（可丢弃的t）{
utx.setRollbackOnly（）
掷t；
}最后{
提交（）；
}
}
}