混合JOOQ查询与JDBC事务

Question

我有一个用例，我想将jdbc事务与jooq上下文混合使用。

JDBC代码如下所示：

  public void inTransaction(InTransaction lambda) {
    DataSource ds = dataSource.get();
    try (Connection connection = ds.getConnection()) {
      try {
        logger.info("set autocommit to false");
        connection.setAutoCommit(false);
        try (Statement statement = connection.createStatement()) {
          lambda.execute(statement);
          logger.info("commiting transaction");
          connection.commit();
        }
      } catch (RuntimeException e) {
        logger.info("rolling back transaction");
        connection.rollback();
        throw e;
      } finally {
        logger.info("set autocommit to true");
        connection.setAutoCommit(true);
      }
    } catch (SQLException e) {
      throw new TilerException(e);
    }
  }

  @FunctionalInterface
  public interface InTransaction {
    void execute(Statement statement) throws SQLException;
  }

我希望lambda参数能够同时使用jdbc和jooq。

对于jdbc来说，使用语句非常简单。例如，像这样的图托拉尔：

 inTransaction(stmt -> {
   String SQL = "INSERT INTO Employees  " +
                "VALUES (106, 20, 'Rita', 'Tez')";
   stmt.executeUpdate(SQL);
   String SQL = "INSERTED IN Employees  " +
                "VALUES (107, 22, 'Sita', 'Singh')";
   stmt.executeUpdate(SQL);
 });

为了在同一事务上执行jooq查询，我必须获得一个上下文。我找到了一个api来从数据源/连接获取DSLContext
我不清楚的是，是否/如何从语句创建jooqDSLContext？

Answer 1

如果要从jOOQ获取查询字符串，可以调用

String sqlString = query.getSQL()

然后在语句中使用此字符串：

stmt.executeUpdate(sqlString);

Answer 2

您可以使用jOOQ的事务API完成所有这一切：

// Create this ad-hoc, or inject it, or whatever
DSLContext ctx = DSL.using(dataSource, dialect);

然后：

public void inJDBCTransaction(InJDBCTransaction lambda) {
    ctx.transaction(config -> {
        config.dsl().connection(connection -> {
            try (Statement statement = connection.createStatement()) {
                lambda.execute(statement);
            }
        });
    });
}

public void inJOOQTransaction(InJOOQTransaction lambda) {
    ctx.transaction(config -> lambda.execute(config.dsl()));
}

@FunctionalInterface
public interface InJDBCTransaction {
    void execute(Statement statement) throws SQLException;
}

@FunctionalInterface
public interface InJOOQTransaction {
    void execute(DSLContext ctx);
}

您的最终代码：

inJDBCTransaction(stmt -> {
    String SQL = "INSERT INTO Employees  " +
                 "VALUES (106, 20, 'Rita', 'Tez')";
    stmt.executeUpdate(SQL);
    String SQL = "INSERTED IN Employees  " +
                 "VALUES (107, 22, 'Sita', 'Singh')";
    stmt.executeUpdate(SQL);
});

inJOOQTransaction(ctx -> {
    ctx.insertInto(EMPLOYEES).values(106, 20, "Rita", "Tez").execute();
    ctx.insertInto(EMPLOYEES).values(107, 22, "Sita", "Singh").execute();
});

我不太相信jOOQ和JDBC需要这种抽象。jOOQ从不向您隐藏JDBC。当使用DSLContext.connection（）方法时，您总是可以访问JDBC API，如上所示。所以，如上所示：

• jOOQ事务API做的正是您计划做的事情。在事务性上下文中包装lambda，成功时提交，失败时回滚（版本的回滚不起作用，因为它捕获了错误的异常）。
• 如果需要JDBC逃生舱口，jOOQ可以提供

在许多RDBMS中，您不希望在静态JDBC语句上运行查询。您将希望使用准备语句来代替，因为：

• 您将受益于执行计划缓存（并减少缓存上的争用）