JOOQ & Transaktionen

Ich ve wurde Lesen über Transaktionen & jooq aber ich kämpfen, um zu sehen, wie die Umsetzung in der Praxis.

Let ' s sagen, die ich mit JOOQ eine benutzerdefinierte ConnectionProvider was geschieht, eine Verbindung zu verwenden pool mit autocommit auf false gesetzt.

Die Umsetzung ist in etwa so:

@Override public Connection acquire() throws DataAccessException {
    return pool.getConnection();
}

@Override public void release(Connection connection) throws DataAccessException {
    connection.commit();
    connection.close();
}

Wie würde ich mich über die Verpackung zwei jooq-Abfragen in einer einzigen Transaktion?

Ist es leicht mit der DefaultConnectionProvider, weil es nur eine Verbindung - aber mit einem pool bin ich mir nicht sicher wie Sie gehen über es.

InformationsquelleAutor assylias | 2013-11-18

jOOQ 3.4 Transaction API

Mit jOOQ 3.4 transaction API wurde Hinzugefügt, um Abstrakt über JDBC, Spring, oder JTA Transaktion Manager. Dieses API verwendet werden kann, die mit Java 8 als solche:

DSL.using(configuration)
   .transaction(ctx -> {
       DSL.using(ctx)
          .update(TABLE)
          .set(TABLE.COL, newValue)
          .where(...)
          .execute();
   });

Oder mit pre-Java 8-syntax

DSL.using(configuration)
   .transaction(new TransactionRunnable() {
       @Override
       public void run(Configuration ctx) {
           DSL.using(ctx)
              .update(TABLE)
              .set(TABLE.COL, newValue)
              .where(...)
              .execute();
       }
   });

Die Idee ist, dass der lambda-Ausdruck (oder eine anonyme Klasse) bilden die Transaktions-code:

Verpflichtet, auf normale Beendigung
Rollt sich zurück auf Ausnahme

Den org.jooq.TransactionProvider SPI kann verwendet werden, um das überschreiben der default-Verhalten, das die nestbare Transaktionen, die über JDBC mit Sicherungspunkt.

Eine Feder Beispiel

Die aktuelle Dokumentation zeigt ein Beispiel bei Verwendung von Spring für die transaktionsbearbeitung:

http://www.jooq.org/doc/latest/manual/getting-started/tutorials/jooq-with-spring/

Diesem Beispiel im wesentlichen darauf an, die mithilfe einer Feder TransactionAwareDataSourceProxy

<!-- Using Apache DBCP as a connection pooling library.
     Replace this with your preferred DataSource implementation -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
    init-method="createDataSource" destroy-method="close">
    <property name="driverClassName" value="org.h2.Driver" />
    <property name="url" value="jdbc:h2:~/maven-test" />
    <property name="username" value="sa" />
    <property name="password" value="" />
</bean>

<!-- Using Spring JDBC for transaction management -->
<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

<bean id="transactionAwareDataSource"
    class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy">
    <constructor-arg ref="dataSource" />
</bean>

<!-- Bridging Spring JDBC data sources to jOOQ's ConnectionProvider -->
<bean class="org.jooq.impl.DataSourceConnectionProvider" 
      name="connectionProvider">
    <constructor-arg ref="transactionAwareDataSource" />
</bean>

Einem ausgeführten Beispiel ist von GitHub hier:

https://github.com/jOOQ/jOOQ/tree/master/jOOQ-examples/jOOQ-spring-example

Ein Spring und Guice Beispiel

Obwohl ich persönlich würde es nicht empfehlen, einige Benutzer haben Erfolg gehabt, ersetzen einen Teil der Frühling s DI von Guice und Transaktionen mit Guice. Es ist auch ein integration-geprüft Beispiel auf GitHub für diesen use-case:

https://github.com/jOOQ/jOOQ/tree/master/jOOQ-examples/jOOQ-spring-guice-example

Vielen Dank für deine Antwort - hast du etwas dagegen, die Kommentare auf die von mir vorgeschlagenen Lösung? (abgesehen von der Tatsache, dass es ist eine schnelle und hässliche fix!)

InformationsquelleAutor Lukas Eder

Dies ist wahrscheinlich nicht der beste Weg, aber es scheint zu funktionieren. Der Nachteil ist, dass es nicht die release aber die commit - Methode schließt die Verbindung und gibt Sie an den pool, der ist ziemlich verwirrend und könnte zu Problemen führen, wenn ein code "vergisst" zu Begehen...

So dass der client-code sieht wie folgt aus:

final PostgresConnectionProvider postgres =
            new PostgresConnectionProvider("localhost", 5432, params.getDbName(), params.getUser(), params.getPass())

private static DSLContext sql = DSL.using(postgres, SQLDialect.POSTGRES, settings);

//execute some statements here
sql.execute(...);

//and don't forget to commit or the connection will not be returned to the pool
PostgresConnectionProvider p = (PostgresConnectionProvider) sql.configuration().connectionProvider();
p.commit();

Und der ConnectionProvider:

public class PostgresConnectionProvider implements ConnectionProvider {
    private static final Logger LOG = LoggerFactory.getLogger(PostgresConnectionProvider.class);

    private final ThreadLocal<Connection> connections = new ThreadLocal<>();
    private final BoneCP pool;

    public PostgresConnectionProvider(String serverName, int port, String schema, String user, String password) throws SQLException {
        this.pool = new ConnectionPool(getConnectionString(serverName, port, schema), user, password).pool;
    }

    private String getConnectionString(String serverName, int port, String schema) {
        return "jdbc:postgresql://" + serverName + ":" + port + "/" + schema;
    }

    public void close() {
        pool.shutdown();
    }

    public void commit() {
        LOG.debug("Committing transaction in {}", Thread.currentThread());
        try {
            Connection connection = connections.get();
            if (connection != null) {
                connection.commit();
                connection.close();
                connections.set(null);
            }
        } catch (SQLException ex) {
            throw new DataAccessException("Could not commit transaction in postgres pool", ex);
        }
    }

    @Override
    public Connection acquire() throws DataAccessException {
        LOG.debug("Acquiring connection in {}", Thread.currentThread());
        try {
            Connection connection = connections.get();
            if (connection == null) {
                connection = pool.getConnection();
                connection.setAutoCommit(false);
                connections.set(connection);
            }
            return connection;
        } catch (SQLException ex) {
            throw new DataAccessException("Can't acquire connection from postgres pool", ex);
        }
    }

    @Override
    //no-op => the connection won't be released until it is commited
    public void release(Connection connection) throws DataAccessException {
        LOG.debug("Releasing connection in {}", Thread.currentThread());
    }
}

Ich sehe. Ich glaube nicht, dass Ihre Lösung wirklich ein "hack" wie du es ausgedrückt hast. Erste Verbindung Lebenszyklen und Transaktions-management der rechten Seite ist ein nicht-triviales problem. Vielleicht könnten Sie fügen Sie einige logging-code in der finalizer von der PostgresConnectionProvider, die erkennen würde, wenn es eine unerwidert Verbindung? Ich werde darüber nachdenken, über diese Dinge ein bisschen mehr auf meiner Seite. Ich habe ein paar Ideen, die ich erklärte in diesem thread auf die user-group
Ja, gute Idee. Und danke für den link: ich hatte gesehen, wie ein paar Diskussionen, aber nicht, dass man.

InformationsquelleAutor assylias

Einfachste Weg,(habe ich gefunden) zu nutzen Spring, Transaktionen mit jOOQ, ist hier gegeben: http://blog.liftoffllc.in/2014/06/jooq-and-transactions.html

Im Grunde implementieren wir eine ConnectionProvider verwendet org.springframework.jdbc.datasource.DataSourceUtils.doGetConnection(ds) Methode zu finden, und wieder die DB-Verbindung, die hält Transaktion erstellt von Frühling.

Erstellen Sie eine TransactionManager Bohne für Ihre DataSource Beispiel unten gezeigt:

  <bean
   id="dataSource"
   class="org.apache.tomcat.jdbc.pool.DataSource"
   destroy-method="close"

   p:driverClassName="com.mysql.jdbc.Driver"
   p:url="mysql://locahost:3306/db_name"
   p:username="root"
   p:password="root"
   p:initialSize="2"
   p:maxActive="10"
   p:maxIdle="5"
   p:minIdle="2"
   p:testOnBorrow="true"
   p:validationQuery="/* ping */SELECT 1"
  />

  <!-- Configure the PlatformTransactionManager bean -->
  <bean
   id="transactionManager"
   class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
   p:dataSource-ref="dataSource"
  />
  <!-- Scan for the Transactional annotation -->
  <tx:annotation-driven/>

Nun können Sie kommentieren alle Klassen oder Methoden, die verwendet jOOQ ist DSLContext mit

@Transactional(rollbackFor = Exception.class)

Und während der Erstellung der DSLContext Objekt jOOQ nutzen der Transaktion erstellt von Frühling.

InformationsquelleAutor CodePredator

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.