JDBC: `con.rollback()` ha effetto solo se`con.commit` non è riuscito?

Question

Sono nuovo di JDBC Java e ho sviluppato un'applicazione per database di piccole dimensioni. Sto imparando da
O'Reilly - Programmazione del database con JDBC e Java 2nd Edition.

con.rollback() ha effetto solo se con.commit non è riuscito?

In realtà, suppongo che chiamare con.rollback() abbia effetto anche se con.commit() è riuscito. Ciò significa utilizzarlo come azione "Annulla".

Ho provato a chiamare con.rollback() dopo il con.commit() riuscito, ma non funziona come ho indovinato. Quindi va bene/previsto?

Questo esempio è tratto dal libro che ho citato sopra:

con.rollback() sia commentata. è vicino alla fine prima dello con.close(). Prova a commentarlo. con.rollback() non esegue il rollback dopo il con.commit() riuscito.

import java.sql.*; 
import java.util.logging.Level; 
import java.util.logging.Logger; 

public class UpdateLogic 
{ 

    public static void main(String args[]) 
    { 
     Connection con = null; 

     try 
     { 
      String driver = "com.mysql.jdbc.Driver"; 
      Class.forName(driver).newInstance(); 
      String url = "jdbc:mysql://localhost:3306/Company"; 
      Statement s; 
      con = DriverManager.getConnection(url, "root", ""); 
      con.setAutoCommit(false); // make sure auto commit is off! 
      s = con.createStatement();// create the first statement 
      s.executeUpdate("INSERT INTO employee VALUES ('1', 'employee 1', '22','00-1234')"); 

      s.close(); // close the first statement 
      s = con.createStatement(); // create the second statement 
      s.executeUpdate("INSERT INTO employee VALUES ('2', 'employee 2', '21','00_4321')"); 

      con.commit(); // commit the two statements 
      System.out.println("Insert succeeded."); 
      s.close(); // close the second statement 
     } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) 
     { 
      Logger.getLogger(UpdateLogic.class.getName()).log(Level.SEVERE, null, ex); 
     } catch (SQLException e) 
     { 
      if (con != null) 
      { 
       try 
       { 
        con.rollback(); 
       } // rollback on error 
       catch (SQLException i) 
       { 
       } 
      } 
      e.printStackTrace(); 
     } finally 
     { 
      if (con != null) 
      { 
       try 
       { 
        //con.rollback(); 
        con.close(); 
       } catch (SQLException e) 
       { 
        e.printStackTrace(); 
       } 
      } 
     } 
    } 
} 

Answer 1

Quando si chiama commit(), si completa/chiude la transazione corrente. Pertanto, poiché rollback() annulla qualsiasi modifica nella transazione corrente (come per javadoc), non farà nulla in modo efficace.

Answer 2

is con.rollback() ha effetto solo se con.com non ha avuto successo?

SI e ha anche effetto se si chiama prima di con.commit. E prerequisito è che la modalità autocommit di connessione deve essere false utilizzando con.setAutoCommit(false)
Qualsiasi transazione effettuata nel database utilizzando DML query SQL mediante JDBC con con.setAutoCommit(false) non si impegna a database fino con.commit() si chiama. L'ultima transazione eseguita dall'utente nel database funge da savepoint per quella connessione. Quando si chiama con.rollback() tutte le transazioni effettuate dopo tale savepoint vengono annullate. Inoltre, se si verifica qualche eccezione durante la chiamata a con.commit(), significa che le transazioni non vengono salvate nel database. È buona norma chiamare con.rollback() nell'istruzione catch se con.commit() non riesce.