Java：在范围退出时自动调用函数（如 c++ 析构函数）

Question

对于 mysql 连接，我有一个连接对象并使用事务机制 connection.startTransaction()、connection.commitTransaction()、connection.rollbackTransaction()。

对于每个startTransaction()，必须始终调用commitTransaction() 或rollbackTransaction()。错过这样一个电话或同时拨打这两个电话会破坏我的交易系统。

所以我按以下方式使用它们：

boolean i_am_in_a_transaction=true;
try {
    connection.startTransaction();
    ...
    i_am_in_a_transaction=false;
    connection.commitTransaction();
} finally {
    if(i_am_in_a_transaction) {
        connection.rollbackTransaction();
    }
}

这确保了声明的调用顺序，但它很费力，因为我必须在使用事务的任何地方都写这行。

在 C++ 中，如果调用了 commit() 函数，我将使用一个事务对象检查其析构函数，否则调用 rollback()：

class Transaction {
    public:
        Transaction()
            :am_in_transaction(false) {
        }

        ~Transaction() {
            if(_am_in_transaction) {
                rollback();
            }
        }

        void startTransaction() {
            _am_in_transaction=true;
            ...start Transaction...
        }

        void commit() {
            _am_in_transaction=false;
            ...commit Transaction...
        }

        void rollback() {
            _am_in_transaction=false;
            ...rollback Transaction...
        }

    private:
        bool _am_in_transaction;
}

这样我就可以在一个地方实现逻辑并且可以非常简单地使用它：

Transaction my_transaction;
my_transaction.startTransaction;
...
my_transaction.commit();

这段代码比上面带有 try/finally 块的 java 代码要简单得多。

有没有办法在 java 中实现这种行为，而无需将逻辑专用于调用者并让他实现 try/finally 块？

在范围退出时自动调用函数之类的方法会对我有所帮助。

Answer 1

与 C++ 中的析构函数类似（非常重要）的是方法finalize()。不同之处在于无法保证垃圾收集器何时真正调用它，因此不建议依赖它。

否则，你能做的最好的就是try/finally 块。

Answer 2

Java 没有析构函数。 但是有几个“标准”解决方案可以帮助您。

1.使用名为“模板方法”的模式。

abstract class Base {
    public query() {
         openTransaction();
         doQuery();
         closeTransaction();
    }
    protected abstract doQuery();
}

现在您应该在您创建的每个子类中实现doQuery()，并通过从基类调用“query()”来使用它。

2.使用面向方面的编程

3.使用装饰器（包装器）模式。

4. 使用一种流行的 ORM 框架（Hibernate、iBatis 等）为您解决所有这些问题，并且完全不处理低级 JDBC 的东西。

Answer 3

想到了几个解决方案...

正如@Dark Falcon 指出的那样，这对于try with resources 调用将是一个很好的用例，它将在尝试结束时自动清理您的资源。不幸的是，这仅在 Java 7 中可用。

Java 类确实定义了一个 finalize() 方法，当对象被垃圾回收时可以调用该方法，但重写此方法几乎从来都不是正确的做法。

如果你迷上了“在函数返回时执行代码”这个想法，我认为你唯一的选择就是使用Aspect Oriented Programming。如果您阅读了诸如AspectJ 之类的一些包或查看使用AOP with Spring，您可以做一些配置魔术，通过拦截调用来获取函数返回时执行的代码。这是 an example 在函数返回时使用 Spring AOP 执行其他代码。

Answer 4

如果可以选择更新到 java 7，则新的 try with resources 将在 Closable 实现中执行方法 close。

Answer 5

我只有一种方法，而且只做一次。

public static void update(Connection connection, String updateSQL) {
    PreparedStatement update = null;
    try {
      try {
        connection.startTransaction();
        update = connection.prepareStatement(updateString);
        update.executeUpdate();
      } finally {
        connection.rollbackTransaction();
      }
    connection.commitTransaction();
    } finally {
        if(update != null) update.close();
    }
}

稍后

update(connection, updateSQL1);
update(connection, updateSQL2);
// etc.

Answer 6

我知道这是一个老问题，但为了他人的利益：

您可以使用实现接口的匿名内部类来完成这项工作，类似于 Java 比较器和列表排序机制的工作方式。这允许您将内部类视为执行范围。

例如修改你原来的例子：

class Transaction
{
   boolean i_am_in_a_transaction=false;

   interface AutoRollback
   {
       void runQueries() throws Throwable;
   }

    void startTransaction() {
        i_am_in_a_transaction=true;
        ...start Transaction...
    }

    void commit() {
        i_am_in_a_transaction=false;
        ...commit Transaction...
    }

    void rollback() {            
        i_am_in_a_transaction=false;
        ...rollback Transaction...
    }

   public void execute(AutoRollback work)
   {
      try {
          work.runQueries();
      } catch ( Throwable t ) {
          rollback();
          throw t;
      }
   }
}

然后是如何使用它的示例：

void test() throws WhateverException
{
    Transaction my_transaction;
    my_transaction.startTransaction();

    my_transaction.execute( new AutoRollback() { public void runQueries() throws Throwable {

     ... perform your queries: can be more than one, complex code, etc. ...
     ... local variables from the enclosing scope can be used as long as they are final... 

    }});

    my_transaction.commit();
}

如果您有 Java 8，使用 lambdas 会变得更漂亮，因为它保存了 new AutoRollback 语法。

如果您没有 Java 8 并且过多的标点符号仍然困扰着您，您应该能够使用注解处理器和代码注入使其读起来更漂亮。 编译时注解设置为 LOCAL_VARIABLE 的目标是您想要的，然后将其应用于my_transaction。

...假设您的工作场所允许使用 apt 或预处理器等注释处理器，并且您希望为语法糖做那么多工作。