Rollback transazioni su SQLException utilizzando il nuovo blocco try-with-resources

Question

Ho un problema con try-with-resources e sto chiedendo solo per essere sicuro. Posso usarlo, se devo reagire all'eccezione, e ho ancora bisogno della risorsa nel blocco catch? Esempio dato è questo:

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 
} 

temo che sto ancora condannato a usare il vecchio try-catch-finally, in questo caso, anche in base alla documentazione Oracle - "blocchi catch e infine in un try-con-risorse dichiarazione, ogni blocco catch o finally viene eseguito dopo che le risorse dichiarate sono state chiuse. "

Answer 1

In base alle specifiche della lingua, la connessione verrà chiusa prima dell'esecuzione della clausola di cattura (http://docs.oracle.com/javase/specs/jls/se7/html/jls-14.html#jls-14.20.3.2).

Una possibile soluzione è quella di nidificare istruzioni try-con-risorse:

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); 
} 

Speriamo che illustra il punto. Questo dovrebbe essere migliorato un po 'se si pensa di usarlo nel codice di produzione.

Ad esempio, se si utilizza un pool di connessioni, è necessario restituire la connessione così come è stata ottenuta, quindi con.setAutoCommit (true); dovrebbe essere fatto in una clausola finale. Ciò significherebbe che il tentativo esterno con le risorse dovrebbe essere un tradizionale tentativo di cattura-finalmente.

Answer 2

Nell'esempio sopra, penso che sia meglio inserire con.commit() all'interno di nidificazione try-catch perché può anche generare SQLException.

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); 
     } 
    } 

Abbiamo avuto un tale problema nel nostro ambiente di produzione con sessioni non chiuse.

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

Nel codice si sta rilevando "SQLException" per eseguire il reset autoCommit. Qualsiasi tipo di eccezione di runtime (ad esempio un'eccezione di puntatore nullo) si bolla dal codice senza reimpostare il commit automatico.

La sintassi try-with-resource fa sì che il compilatore generi un codice meraviglioso per coprire tutti i percorsi di esecuzione e per tenere il passo con tutte le eccezioni soppresse attraverso le chiusure. Con un paio di classi di supporto è possibile inserire commit/rollback e ripristinare-autocommit nel processo di generazione del codice:

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); 
    } 

} 

Ora è possibile controllare il rollback e autocommit con la "prova con risorsa" la sintassi del genere:

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

     // Do stuff 

     tm.commit(); 
    }