Home » Core Java » sql » JDBC Transaction Rollback Example

About Andres Cespedes

Andres Cespedes
Andres is a Java Software Craftsman from Medellin Colombia, who strongly develops on DevOps practices, RESTful Web Services, Continuous integration and delivery. Andres is working to improve software process and modernizing software culture on Colombia.

JDBC Transaction Rollback Example

In this example will talk about how to perform rollback in JDBC transactions.

When we are making changes in the database through a java.sql.Connection, it’s necessary prevent it form going to an inconsistent state, in case of an exception for example. So how do we do that? There are some key steps.

  • Manage manually the changes with transactions, disabling the auto commit
  • Explicitly call commit and rollback
  • Rollback a transaction in a catch clause
  • Explicitly close the connection.
 
It’s so important that you remember that if you call connection.commit() the changes cannot be reverted with connection.rollback().

1. Example

Let’s take a look of the example with this code snippet.

DBConnection.java:

package com.javacodegeeks.jdbc.transactions;

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

/**
 * @author Andres.Cespedes
 *
 */
public class DBConnection {

	private static String DB_URL = "jdbc:mysql://localhost:3307/test";
	private static String DB_USER = "admin";
	private static String DB_PASSWORD = "admin";

	public static Connection getConnection() throws SQLException {
		Connection connection = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
		System.err.println("The connection is successfully obtained");
		return connection;
	}
}

Rollback.java:

package com.javacodegeeks.jdbc.transactions;

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

/**
 * @author Andres.Cespedes
 *
 */
public class Rollback {

	private static String INSERT = "INSERT INTO test.department (idDepartment, name) VALUES (?, ?)";

	public static void insertRow(Connection conn, int idRow, String contentRow)
			throws SQLException {
		PreparedStatement pstmt = null;
		pstmt = conn.prepareStatement(INSERT);
		pstmt.setInt(1, idRow);
		pstmt.setString(2, contentRow);
		pstmt.execute();
		pstmt.close();
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Connection connection = null;
		try {
			// 1st Step, Make a connection
			connection = DBConnection.getConnection();
		} catch (SQLException e) {
			System.err.println("There was an error getting the connection");
		}
		try {
			// 2nd Step, Disable the auto commit
			connection.setAutoCommit(false);
			System.err.println("The autocommit was disabled!");
		} catch (SQLException e) {
			System.err.println("There was an error disabling autocommit");
		}
		// Starts JDBC Transaction
		try {
			// 3rd Step, Execute the statements
			insertRow(connection, 1, "Malaga");
			insertRow(connection, 2, "Barcelona");
			// 4th Step, Complete a transaction, committing the changes.
			connection.commit();
			System.err.println("The transaction was successfully executed");
		} catch (SQLException e) {
			try {
				// 5th and Final Step, We must rollback the transaction if a
				// SQLException occurs
				connection.rollback();
				System.err.println(e.getMessage());
				System.err.println("Transaction rollback");
			} catch (SQLException e1) {
				System.err.println(e1.getMessage());
				System.err.println("There was an error making a rollback");
			}
		}
	}

}

2. The Output

In this example, we define a column with a VARCHAR(6). This means that we can store up to six characters to it. In the first insert, we put "Malaga", whose length is within the limit. This will be stored in the database, but remember that the change is not still permanent. In the second insert we put in "Barcelona", whose length exceeds the limit. So it generates a SQLException thus connection.rollback(); is called.

This is the output.

The connection is successfully obtained
The autocommit was disabled!
Data truncation: Data too long for column 'name' at row 1
The transaction rollback

Now if you go to your database you will see that "Malaga" is not inserted to the table, because the transaction rolled back. So all the changes that have not been committed will be reverted.

3. Download Source Code

Download
You can download the full source code of this example here: JDBCRollbackExample.zip
(No Ratings Yet)
Start the discussion Views Tweet it!

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

 

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

 

and many more ....

 

Receive Java & Developer job alerts in your Area

 

Leave a Reply

avatar
  Subscribe  
Notify of