Programa Java para hacer una reversión

Llamar a una operación de reversión deshace todos los efectos o modificaciones que ha realizado una Transacción (T i ) y finaliza la Ti y todas las variables obtienen sus valores anteriores almacenados. La reversión se llama principalmente cuando obtiene una o más de una excepción de SQL en las declaraciones de Transaction (T i ), luego T i se aborta y comienza de nuevo desde el principio. Esta es la única forma de saber qué se ha cometido y qué no. 
Una excepción de SQL simplemente indica que algo está mal en su declaración que ha escrito, pero no menciona qué y dónde se ha hecho mal. Entonces, la única opción que le queda es llamar a un método de reversión.

Procedimiento: Se trata principalmente de dos pasos. Primero, crea una base de datos y luego trata con las transacciones.

  1. crear una base de datos
  2. Ejecutar las transacciones para la reversión
    • Importar la base de datos
    • Cargue y registre los controladores si es necesario
    • Crear una nueva conexión
    • Crear una declaración para compromiso/reversión
    • Ejecute la consulta para confirmar/revertir
    • Procesar los resultados
    • Cierre la conexión, de lo contrario, el procesamiento anterior puede perderse, si corresponde.

Paso 1: También podemos deshacer las modificaciones en la base de datos hasta un indicador en particular o un punto de guardado con solo pasar el nombre de los puntos de guardado necesarios como parámetro en el siguiente método:

// Set the Flag or Save point 
con.rollback("MysavePoint");

Paso 2. Para deshacer una transacción: Cargue el controlador JDBC, utilizando el método de la API para el nombre (String className) de la clase. En este ejemplo, estamos usando Oracle

   // To register the needed Driver
   DriverManager.registerDriver(new com.mysql.jdbc.Driver());
  • Obtenga la información de conexión utilizando el método API getConnection() de DriverManager:
   // For getting the connection
   String url = "jdbc:mysql://localhost/mydatabase/icpc";
   Connection conn = DriverManager.getConnection(string url, String user, String password);
  • Deshabilite la confirmación automática utilizando el método API del método setAutoCommit(boolean auto-commit) fuera de conexión como:
   // Set the auto commit false. This will execute all
   // SQL statements as individual transactions
   con.setAutoCommit(false);
  • Ahora, establezca el punto de guardado usando setSavepoint() o confirme la transacción usando el método API commit() de conexión como se muestra a continuación:
   Savepoint savePoint = con.setSavepoint("MysavePoint");
   Con.commit();
  • Si se encuentra alguna excepción SQL, entonces, en ese caso, invoque el método API rollback( ) para toda la transacción hasta el punto de guardado previamente establecido:
   con.rollback() Or,
   con. rollback(my_Savepoint);

Implementación: el programa Java para demostrar tanto el programa rollback() como commit() es el siguiente

Java

// Importing generic java libraries
import java.io.*;
 
// Retrieving SQL DB
// javaconnector-linkage for JDBC
import java.sql.*;
import java.sql.SQLException;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.Date;
// Importing drivers(if necessarily)
 
// GFG class only to illustrate JDBC
// not illustrating connection class
class GFG {
 
    /* Step 1: Importing DB */
 
    // Database URL so as to create/fetch data from DB
    static String DB_URL
        = "jdbc:oracle:thin:@localhost/my_database_";
 
    // DB userID
    static String DB_USER = "local";
 
    // Remember randomly self createdDB password
    // to deal with above DB root
    static String DB_PASSWORD = "test";
 
    // Main driver method
    public static void main(String args[])
    {
        // Try block to check exceptions  if occurs
        try {
 
            /* Step 2: Loading and registering drivers*/
 
            Class.forName(
                "oracle.jdbc.driver.OracleDriver");
 
            /* Step 3: Create the new connection */
            Connection conn = DriverManager.getConnection(
                DB_URL, DB_USER, DB_PASSWORD);
 
            // set auto commit of the connection to false
            conn.setAutoCommit(false);
 
            /* Step 4: Create a statement */
 
            // Input the info into record
            String sql_
                = "INSERT INTO Employee (empid, empname) VALUES (?, ?)";
 
            // Create a Statement_object
            PreparedStatement ps
                = conn.prepareStatement(sql_);
 
            /* Step 5: Execute a query */
 
            // Take user input
            BufferedReader br = new BufferedReader(
                new InputStreamReader(System.in));
 
            while (true) {
 
                // Asking user to enter data(EmpID)
                System.out.print("Enter emp_Id: ");
 
                // Reading above user entered EmpID
                String s_1 = br.readLine();
                int empid = Integer.parseInt(s_1);
 
                // Asking user to enter data(EmpName)
                System.out.print("Enter emp_name: ");
 
                // Reading above user entered EmpName
                String name = br.readLine();
 
                // Creating entry in table
 
                // Set emp_id
                ps.setInt(1, empid);
 
                // Set emp_name
                ps.setString(2, name);
 
                // Execute the updation operation
                ps.executeUpdate();
 
                /* Step 6: Process the results */
 
                /* Displaying choice what user wants to do
                   with updation, either Commit() or
                   rollback() */
                System.out.println("commit or rollback");
 
                // Reading choice from user
                String answer = br.readLine();
 
                /* Asking user's choice for condition
                 * check*/
 
                /* Checking if users want to commit or
                 * rollback */
 
                // If user wants to commit
                if (answer.equals("commit")) {
                    conn.commit();
                }
 
                // If user wants to rollback
                if (answer.equals("rollback")) {
 
                    // Rollback the update in case if some
                    // flaw in your record
                    conn.rollback();
                }
 
                /* Display message to user for inputing next
                   record if user wants to add */
                System.out.println(
                    "Do you want to include more records");
 
                /* Asking choice */
                System.out.println("\n yes/no");
 
                // Read user's choice
                String answ = br.readLine();
                if (answ.equals("no")) {
                    break;
                }
            }
            conn.commit();
 
            // Print message
            System.out.println(
                "record is successfully saved");
 
            /* Step 7: Close the connection */
 
            // calling commit() before closing connection
            // else updation would be lost
            conn.close();
        }
 
        // Exception handled if occurred by catch block
        catch (Exception exc) {
 
            // Highlighting line where exception occurred
            // as execution is equal
            exc.printStackTrace();
        }
    }
}

Salida: hay dos imágenes de salida de muestra que cubren ambos casos: confirmación y reversión o simplemente reversión directa, como se ilustra en las siguientes salidas. 

Publicación traducida automáticamente

Artículo escrito por madhav_mohan y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *