Transaktion Rollback auf SQLException mit neuen Try-mit-Ressourcen Block

Question

Ich habe ein Problem mit Try-mit-Ressourcen und ich frage nur um sicher zu sein. Kann ich es verwenden, wenn ich auf eine Ausnahme reagieren muss, und ich brauche immer noch die Ressource im Catch-Block? Beispiel angegeben:

try (java.sql.Connection con = createConnection()) 
{ 
    con.setAutoCommit(false); 
    Statement stm = con.createStatement(); 
    stm.execute(someQuery); // causes SQLException 
} 
catch(SQLException ex) 
{ 
    con.rollback(); 
    // do other stuff 
} 

Ich fürchte, dass ich immer noch die alten try-catch-finally in diesem Fall, auch nach dem Oracle-Dokumentation zu verwenden, ist zum Scheitern verurteilt - „fangen und schließlich Blöcke in einer Try-mit-Ressourcen Anweisung wird jeder catch- oder finally-Block ausgeführt, nachdem die deklarierten Ressourcen geschlossen wurden. "

Answer 1

Je nach Sprachspezifikation wird die Verbindung geschlossen, bevor die catch-Klausel ausgeführt wird (http://docs.oracle.com/javase/specs/jls/se7/html/jls-14.html#jls-14.20.3.2).

Eine mögliche Lösung ist zu nisten try-with-Ressourcen Aussagen:

try (java.sql.Connection con = createConnection()) 
{ 
    con.setAutoCommit(false); 
    try (Statement stm = con.createStatement()) 
    { 
     stm.execute(someQuery); // causes SQLException 
    } 
    catch(SQLException ex) 
    { 
     con.rollback(); 
     con.setAutoCommit(true); 
     throw ex; 
    } 
    con.commit(); 
    con.setAutoCommit(true); 
} 

Hoffentlich, die den Punkt zeigt. Dies sollte verbessert werden, wenn Sie es im Produktionscode verwenden möchten.

Wenn Sie beispielsweise einen Verbindungspool verwenden, müssen Sie die Verbindung so zurückgeben, wie Sie sie erhalten haben, also con.setAutoCommit (true); sollte in einer finally-Klausel erfolgen. Dies würde bedeuten, dass die äußeren Try-with-resources eine traditionelle try-catch-finally sein sollten.

Answer 2

In dem obigen Beispiel denke ich, es ist besser, con.commit() in verschachtelten try-catch setzen, weil es auch SQLException werfen kann.

try (java.sql.Connection con = createConnection()) 
    { 
     con.setAutoCommit(false); 
     try (Statement stm = con.createStatement()) 
     { 
      stm.execute(someQuery); // causes SQLException 
      con.commit();   // also causes SQLException! 
     } 
     catch(SQLException ex) 
     { 
      con.rollback(); 
      throw ex; 
     }finally{ 
      con.setAutoCommit(true); 
     } 
    } 

Wir hatten solch ein Problem in unserer Produktionsumgebung mit nicht abgeschlossenen Sitzungen.

Answer 3

//try with resources 
    try(Connection conn = this.connectionProvider.getConnection()){//auto close BEFORE reach this , catch block, so we need a inner try block for statement 
     boolean oldAutoCommit=conn.getAutoCommit(); 
     conn.setAutoCommit(false);//auto commit to false 
     try(
      Statement stm = con.createStatement() 
     ){ 
      stm.execute(someQuery); // causes SQLException 
      conn.commit();//commit 
     } 
     catch (SQLException ex){ 
      conn.rollback();//error, rollback 
      throw ex;//If you need to throw the exception to the caller 
     } 
     finally { 
      conn.setAutoCommit(oldAutoCommit);//reset auto commit 
     } 
    } 

Answer 4

In Ihrem Code fangen Sie "SQLException" ab, um den AutoCommit-Reset durchzuführen. Jede Art von Laufzeitausnahme (wie eine Nullzeigerausnahme) wird aus Ihrem Code blasen, ohne die automatische Festschreibung zurückzusetzen.

Die Try-with-Resource-Syntax bewirkt, dass der Compiler einen wunderbaren Code generiert, der alle Ausführungspfade abdeckt und mit allen unterdrückten Ausnahmen durch die Closings Schritt hält. Mit ein paar Hilfsklassen können Sie einfügen Commit/Rollback und Reset-autocommit in den Codegenerierungsprozess:

import java.sql.SQLException; 
import java.sql.Connection; 

public class AutoRollback implements AutoCloseable { 

    private Connection conn; 
    private boolean committed; 

    public AutoRollback(Connection conn) throws SQLException { 
     this.conn = conn;   
    } 

    public void commit() throws SQLException { 
     conn.commit(); 
     committed = true; 
    } 

    @Override 
    public void close() throws SQLException { 
     if(!committed) { 
      conn.rollback(); 
     } 
    } 

} 

public class AutoSetAutoCommit implements AutoCloseable { 

    private Connection conn; 
    private boolean originalAutoCommit; 

    public AutoSetAutoCommit(Connection conn, boolean autoCommit) throws SQLException { 
     this.conn = conn; 
     originalAutoCommit = conn.getAutoCommit(); 
     conn.setAutoCommit(autoCommit); 
    } 

    @Override 
    public void close() throws SQLException { 
     conn.setAutoCommit(originalAutoCommit); 
    } 

} 

Jetzt können Sie Rollback-Steuerung und Autocommit mit dem „versuchen, mit Ressource“ Syntax wie folgt:

try(Connection conn = getConnection(), 
     AutoSetAutoCommit a = new AutoSetAutoCommit(conn,false), 
     AutoRollback tm = new AutoRollback(conn)) 
    { 

     // Do stuff 

     tm.commit(); 
    }