• JDBC Tutorial

• What is JDBC
• SQL Syntax
• JDBC Driver Types
• JDBC Simple Program
• JDBC Statement interface
• JDBC ResultSet interface
• JDBC PreparedStatement
• JDBC CallableStatement
• JDBC ResultSetMetaData
• JDBC DatabaseMetaData
• JDBC Transaction Management
• JDBC Batch Processing
• Step by Step JDBC Program
• JDBC Select Program
• JDBC Insert Program
• JDBC Update Program
• JDBC Delete Program
• JDBC Image Insert Example
• JDBC Image Read Example
• JDBC Scrollable ResultSet
• JDBC Updatable ResultSet
• JDBC Interview Questions

JDBC Transaction Management

A transaction represents a group of operations, used to perform a task.

Transaction Management in JDBC :

Here are the most important points about Transaction Management in JDBC.

1. A transaction means, it is a group of operations used to perform a task.
2. A transaction can reach either success state or failure state.
3. If all operations are completed successfully then the transaction becomes success.
4. If any one of the operation fail then all remaining operations will be cancelled and finally transaction will reach to fail state.

Types of Transactions :

The basic transactions are of two types.

1. Local Transactions
2. Global / Distributed Transactions

Local Transactions :

If all the operations are executed on one/same database, then it is called as local transaction.

Global / Distributed Transaction :

If the operations are executed on more than one database then it is called as global transactions.

Example : If we transfer the money from account1 to account2 of same bank, then it is called as local transaction. If we transfer the money from account1 to account2 of different banks, then it is called as global or distributed transaction.

Transaction Management in JDBC Example :

We can get the Transaction support in JDBC from Connection interface. The Connection interface given 3 methods to perform Transaction Management in JDBC.

1. setAutoCommit()
2. commit()
3. rollback()

Transaction setAutoCommit() :

Before going to begin the operations, first we need to disable the auto commit mode. This can be done by calling setAutoCommit(false).

By default, all operations done from the java program are going to execute permanently in database. Once the permanent execution happened in database, we can’t revert back them (Transaction Management is not possible).

Transaction commit() :

If all operations are executed successfully, then we commit a transaction manually by calling the commit() method.

Transaction rollback() :

If any one of the operation failed, then we cancel the transaction by calling rollback() method.

                        connection.setAutoCommit(false);

                        try{

                        ----------
                        ----------

                        connection.commit();

                        }catch(Exception e){

                        connection.rollback();

                        }
                    

Example Program

                        package com.java.session.ninteen;

                        import java.sql.Connection;
                        import java.sql.DriverManager;
                        import java.sql.PreparedStatement;

                        public class JdbcTransactionManagementExample {
                            static final String DB_URL = "jdbc:mysql://localhost/emp";
                            static final String USER = "root";
                            static final String PASS = "PASSWORD";
                            static final String QUERY = "INSERT INTO EMP.EMPLOYEE VALUES(?,?,?,?)";
                            public static void main(String[] args) throws Exception {
                                Connection connection = null;
                                PreparedStatement preparedStatement = null;
                                try {
                                    connection = DriverManager.getConnection(DB_URL, USER, PASS);
                                    connection.setAutoCommit(false);
                                    preparedStatement = connection.prepareStatement(QUERY);
                                    preparedStatement.setInt(1, 15);
                                    preparedStatement.setInt(2, 23);
                                    preparedStatement.setString(3, "alikhan");
                                    preparedStatement.setString(4, "navab");
                                    preparedStatement.executeUpdate();

                                    connection.commit();
                                    System.out.println("Transaction is committed.");
                                } catch (Exception e) {
                                    e.printStackTrace();
                                    connection.rollback();
                                } finally {
                                    try {
                                        preparedStatement.close();
                                        connection.close();
                                    } catch (Exception e) {
                                        e.printStackTrace();
                                    }
                                }
                            }
                        }