What is Transaction? Why Transaction Management Required? JDBC Transaction Management in Java with Example. JDBC Transaction Management Example

Size: px

Start display at page:

Download "What is Transaction? Why Transaction Management Required? JDBC Transaction Management in Java with Example. JDBC Transaction Management Example"

Jewel Houston
6 years ago
Views:

1 JDBC Transaction Management in Java with Example Here you will learn to implement JDBC transaction management in java. By default database is in auto commit mode. That means for any insert, update or delete operation the changes takes place immediately in database. What is Transaction? Transaction involves several sql queries that are considered as one unit. For example money transfer done in bank is a kind of transaction as it involves two steps. First debit the x amount of money from source account and then credit that amount to destination account. Why Transaction Management Required? To avoid data inconsistency transaction management is required. Lets understand this by one example. Money transferring involves two steps, suppose money is debited from source account but failed to credit to destination account. This arises data inconsistency. Now this problem can be solved using transaction management. If any of the operation is failed in transaction then all the operations are rolled back and the database restored back to the state where the transaction was started. Image Source JDBC Transaction Management Example In JDBC we can begin the transaction by disabling auto commit using setautocommit(false) method and end the transaction by commit() method. Roll back can be done using rollback() method. In case of any exception the rollback should be done in catch block. If due to some reason sql statements or queries are not executed properly then rollback should be done before commit. Posted on February 20,

2 JDBC Transaction Tutorial: Commit() And Rollback() Example 1. WHAT IS TRANSACTION MANAGEMENT IN JDBC? Transaction Management works great when you need to execute set of task and each task executes when previous task completes. Transaction Management ensures that all the task executes successfully and if one task fails, the whole task would be rollback to previous state. Simply, either all the statements are executed, or none of the statements is executed. 2. FACT ABOUT TRANSACTION 1. ACID: It represents ACID Properties. Atomicity means either all successful or none. Consistency ensures bringing the database from one consistent state to another consistent state. Isolation ensures that transaction is isolated from other transaction. Durability means once a transaction has been committed, it will remain so, even in the event of errors, power loss etc. 2. Disable Auto Commit Mode: When the connection is created it is auto commit mode. It means all the individual SQL Statements will be treated as Transaction. When using Transaction, Disable Auto Commit Mode and call it explicitly. After disabling commit mode, no statement will be execute until you call Commit() method explicitly. Each statement will be executed after the previous call of Commit method. con.setautocommit(false); In JDBC, Connection interface provides methods to manage transaction. METHOD DESCRIPTION void setautocommit (boolean status) It is true bydefault means each transaction is committed bydefault. void commit() commits the transaction. void rollback() cancels the transaction. 3. ADVANTAGE OF TRANSACTION MANAGEMENT 1. Transaction Management widely used in financial application where you want to ensure that if any problem happens meanwhile the payment process, the whole transaction rollback. 2. Transaction Management is also very beneficial when you need to insert multiple row in multiple table simultaneously. It ensures that all the table gets successful execution of statement and if any table fails to execute statement, all the row roll backed and none of table affected. 3. Transaction Treats all the SQL statements as a single logical unit and if one statement fails the entire transaction fails. 4. Commit and Rollback : Commit() method does the changes in database table and Rollback methods undo all the changes done by current connection con. 4. PROGRAMMING EXAMPLE In this programming example, I will insert two row in a two different table using Transaction. This example explains Commit() method. In the next example you will get Rollback. Step 1. Create Two Tables table1 and table2 with following description 2

3 CREATE TABLE Table1 ( ID int(11) NOT NULL AUTO_INCREMENT, PRODUCT varchar(50) NULL, PRICE varchar(10) NULL, PRIMARY KEY(ID) ) CREATE TABLE Table2( ID int(11) NOT NULL AUTO_INCREMENT, PRODUCT varchar(50) NULL, PRICE varchar(10) NULL, PRIMARY KEY(ID) ) You can use your own table to execute query. If you don t have any, then create table using above query. Step 2. Programming Example of Commit() Method. 1 package AdvanceJDBC; import java.sql.*; public class Transaction_Example static final String JDBC_DRIVER = "com.mysql.jdbc.driver"; static final String dburl = "jdbc:mysql://localhost/storedb"; static final String dbuser = "root"; static final String dbpass = "root"; public static void main(string[] args) Connection con = null; Statement stmt = null; try //Step 1 : Connecting to server and database con = DriverManager.getConnection(dburl, dbuser, dbpass); con.setautocommit(false); //Step 2 : Initialize Statement stmt=con.createstatement(); //Step 3 : SQL Query String query1="insert INTO Table1(PRODUCT,PRICE) VALUES('Laptop','29000')"; String query2="insert INTO Table2(PRODUCT,PRICE) VALUES('Mouse','305')"; stmt.executeupdate(query1); stmt.executeupdate(query2); //If you run this program without con.commit you will notice that there is no insert in table1 and table2 con.commit(); System.out.println("Row Inserted"); catch (SQLException e) System.err.println("Cannot connect! "); e.printstacktrace(); 3 finally System.out.println("Closing the connection."); if (con!= null) try con.close(); catch (SQLException ignore)

4 Output Row Closing the connection Inserted 5. ROLLBACK EXAMPLE In this example I will use Rollback method to ensure all the successful insertion in both table. You will see what happen when statement execution fails in table Programming Example Example 1: With Commit(false) In this program I have Passed long value in PRICE column for table2. It will raise exception because of size of PRICE is set to varchar(10). This is for showing you what happened when one query executed but another get failed in transaction. You will notice that there were no changes in table. package AdvanceJDBC; import java.sql.*; public class Rollback_Example static final String JDBC_DRIVER = "com.mysql.jdbc.driver"; static final String dburl = "jdbc:mysql://localhost/storedb"; static final String dbuser = "root"; static final String dbpass = "root"; public static void main(string[] args) throws SQLException Connection con = null; Statement stmt = null; try //Step 1 : Connecting to server and database con = DriverManager.getConnection(dburl, dbuser, dbpass); con.setautocommit(false); //Step 2 : Initialize Statement stmt=con.createstatement(); //Step 3 : SQL Query String query1="insert INTO Table1(PRODUCT,PRICE) VALUES('Mobile','11500')"; stmt.executeupdate(query1); System.out.println("Table1 Successfull"); String query2="insert INTO Table2(PRODUCT,PRICE) VALUES('Charger',' ')"; stmt.executeupdate(query2); //If you run this program without con.commit you will notice that there is no insert in table1 and table2 con.commit(); System.out.println("Row Inserted"); catch (SQLException e) System.err.println("Cannot connect! "); 4 con.rollback(); e.printstacktrace();

5 finally System.out.println("Closing the connection."); if (con!= null) try con.close(); catch (SQLException ignore) Output Table1 Successfull Cannot connect! com.mysql.jdbc.mysqldatatruncation: Data truncation: Data too long for column PRICE at row 1 Spring Transaction Management over multiple threads April 19, 2017 Spring framework provides a comprehensive API for database transaction management. Spring takes care of all underlying transaction management considerations and provides a consistent programming model for different transaction APIs such as Java Transaction API (JTA), JDBC, Hibernate, Java Persistence API (JPA), and Java Data Objects (JDO). There are 2 main types of transaction management in Spring. They are declarative transaction management which is a high level one and programmatic transaction management which is more advance but flexible. The Spring API works very well with almost all of the transaction management requirements as long as the transaction is on a single thread. The problem rises when we want to manage a transaction across multiple threads. Spring doesn't support transactions over multiple threads out of the box. Spring doesn't explicitly mention that in the documentation. But you will end up with run time errors or unexpected results if you try to do so. 7. Why do spring transactions over multiple threads fail? Spring stores a set of thread locals inside the org.springframework.transaction.support.transactionsynchronizationmanager class. These thread locals are specific for an ongoing transaction on a single thread. (Thread locals values are specific for a single thread. Thread local value set by one thread cannot be accessed by another thread) 5 public abstract class TransactionSynchronizationManager private static final Log logger = LogFactory.getLog(TransactionSynchronizationManager.class); private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal("Transactional resources"); private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal("Transaction synchronizations"); private static final ThreadLocal<String> currenttransactionname = new NamedThreadLocal("Current transaction name"); private static final ThreadLocal<Boolean> currenttransactionreadonly = new NamedThreadLocal("Current transaction read-only status"); private static final ThreadLocal<Integer> currenttransactionisolationlevel = new NamedThreadLocal("Current transaction isolation level"); private static final ThreadLocal<Boolean> actualtransactionactive = new NamedThreadLocal("Actual transaction active"); If we start the transaction from one thread and try to commit or rollback the transaction form another thread, a run

6 time error will be generated complaining that the spring transaction is not active on the current thread. Though we start and end the transaction from the same thread, we cannot perform database operations belong to transaction from another thread too. When we initialize the transaction the actualtransactionactive thread local is set to true. synchronizations thread local is also initialized. Other thread locals are also accessed and updated during the life cycle of the transaction. When we try to commit or rollback the transaction at the end of the transaction scope, values of these thread locals are again checked. What happens if we use multiple threads for the transaction is that, these thread local values are not visible across multiple threads. Therefore, spring cannot maintain the transaction state through out the transaction. 8. How to use spring transactions with multiple threads? Now you can understand the problem with spring transactions over multiple threads. The thread local values are not propagating to new threads from old threads. The only solution here is we have to manually copy these thread local values to newly spawned threads to keep the transaction unbroken. As mentioned above, actualtransactionactive thread local is used to check whether the transaction is active on the current thread. This thread local is set true on the thread which initializes the transaction. But, since this thread local value is not visible to other threads we have to maintain another boolean flag to inform the activeness of the transaction to other threads. Then we can check that flag from the new thread and set actualtransactionactivethread local to true manually. Thread local value can be set by calling following code line. 1 TransactionSynchronizationManager.setActualTransactionActive(true); 9. Practical applications of multi threaded database transactions Database processing element of Adroitlogic Project-X is a good industrial level practical application of multi threaded database transactions. 10. What is Project-X? Project X is the base framework for a new generation of redesigned integration products by Adroitlogic. Project-X consists of all the API definitions, core implementations of those APIs, messaging engine, message format definitions and implementations, metrics engine etc to be used by those integration products. 11. What is database processing element? The database connector and the database processing element provide the data persistent capabilities to the project-x. There are three main components to perform database operations such as db egress connector, db ingress connector and the db processing element. Database processing element supports for all 4 CRUD operations. Database egress connector provides create, update, delete operations and database ingress connector provides read operation in a timed manner. 12. How transactions are used in database processor? Let s see how to configure an integration flow to perform a database transactional operation. Here we enter the data to a table, obtain the id of the last inserted row and then again insert data to another table with the id obtained from the previous database operation. 6 Suppose there is a database table named as people having columns named as id, name and age. Second table is named as students and the columns are id, school and the grade. Here the id of the students table is a foreign key referenced from the people table.

7 The database transaction scope start element[1] starts the transaction scope. All the database operations happening within transaction scope are guaranteed to be committed if and only if all the operations within the transaction scope were a success. Then the clone message processing element[2] just take a clone of the message and send one copy as the response to the nio http ingress connector and the other copy to the database processor. Two new threads are created here and thread locals of the TransactionSynchronizationManager class are copied to the newly created threads. Then database processing element[3] do the first insert to the people table in the database. Next database processing element[5] reads the last inserted row from the people table and return the result in DBResultsSetFormat. Then we use a custom processing element[6] to extract the id from the DBResultsSetFormat and set it to the header of the message. Last database processing element[7] does the second insert to the students table using the data read from the payload the id read from the message header. Finally the database transaction scope end element closes the transaction scope and commit the changes to the database if all the operations are complete. The database transaction will be rolled back in any kind of failure within the transaction scope of the flow. Spring Questions and Answers Transaction Management This set of Java Spring Multiple Choice Questions & Answers (MCQs) focuses on Transaction Management Transactions can be described with key properties:- a) Atomicity b) Consistency c) Isolation d) All of the mentioned Answer: d Explanation: The concept of transactions can be described with four key properties: atomicity, consistency, isolation, and 7

8 durability (ACID). Atomicity: A transaction is an atomic operation that consists of a series of actions. The atomicity of a transaction ensures that the actions either complete entirely or take no effect at all. Consistency: Once all actions of a transaction have completed, the transaction is committed. Then your data and resources will be in a consistent state that conforms to business rules. Isolation: Because there may be many transactions processing with the same data set at the same time, each transaction should be isolated from others to prevent data corruption. Durability: Once a transaction has completed, its result should be durable to survive any system failure (imagine if the power to your machine was cut right in the middle of a transaction s commit). Usually, the result of a transaction is written to persistent storage To access a database running on the Derby server, you have to add:- a) Derby client library b) Tomcat client library c) All of the mentioned d) None of the mentioned Explanation: To access a database running on the Derby server, you have to the Derby client library to your CLASSPATH Spring s transaction support offers a set of technology-independent facilities, including transaction managers. a) org.springframework.transaction.platformtransactionmanager b) org.springframework.transaction.support.transactiontemplate c) all of the mentioned d) none of the mentioned Answer: c 8 Explanation: Spring s transaction support offers a set of technology-independent facilities, a transaction template (e.g., org.springframework.transaction.support.transactiontemplate), and transaction declaration support to simplify your transaction management tasks Spring s core transaction management abstraction is based on the interface:- a) PlatformTransaction

9 b) PlatformTransactionManager c) TransactionManager d) PlatformManager Answer: b Explanation: It encapsulates a set of technology-independent methods for transaction management The PlatformTransactionManager interface provides methods for working with transactions: a) gettransaction(transactiondefinition definition) b) commit(transactionstatus status) c) rollback(transactionstatus status) d) all of the mentioned Answer: d Explanation: TransactionStatus gettransaction(transactiondefinition definition) throws TransactionException void commit(transactionstatus status) throws TransactionException; void rollback(transactionstatus status) throws TransactionException; Spring has several built-in implementations of PlatformTransactionManager interface for use with different transaction management APIs. a) True b) False Explanation: If you have to deal with only a single data source in your application and access it with JDBC, DataSourceTransactionManager should meet your needs. If you are using JTA for transaction management on a Java EE application server, you should use JtaTransactionManager to look up a transaction from the application server. Additionally, JtaTransactionManager is appropriate for distributed transactions (transactions that span multiple resources). Note that while it s common to use a JTA transaction manager to integrate the application servers transaction manager, there s nothing stopping you from using a standalone JTA transaction manager such as Atomikos. 9

10 If you are using an object/relational mapping framework to access a database, you should choose a corresponding transaction manager for this framework, such as HibernateTransactionManager and JpaTransactionManager A transaction manager is declared in the Spring IoC container as a normal bean. a) True b) False Explanation: For example, the following bean configuration declares a DataSourceTransactionManager instance. It requires the datasource property to be set so that it can manage transactions for connections made by this data source Method that allows you to start a new transaction (or obtain the currently active transaction). a) gettransaction() b) commit() c) rollback() d) all of the mentioned Explanation: Spring s transaction manager provides a technology-independent API that allows you to start a new transaction (or obtain the currently active transaction) by calling the gettransaction() method PlatformTransactionManager is an abstract unit for transaction management. a) True b) False Explanation: Because PlatformTransactionManager is an abstract unit for transaction management, the methods you called for transaction management are guaranteed to be technology independent Method to start a new transaction with that definition:- a) gettransaction() b) commit() c) rollback() d) none of the mentioned 10

11 Explanation: Once you have a transaction definition, you can ask the transaction manager to start a new transaction with that definition by calling the gettransaction() method To help you control the overall transaction management process and transaction exception handling. a) SpringTransactionTemplate b) TransactionTemplate c) Transaction d) None of the mentioned Answer: b Explanation: Spring also provides a TransactionTemplate to help you control the overall transaction management process and transaction exception handling You just have to encapsulate your code block in a callback class that implements the TransactionCallback interface and pass it to the TransactionTemplate s execute method for execution. In this way, you don t need to repeat the boilerplate transaction management code for this block. a) True b) False Explanation: In this way, you don t need to repeat the boilerplate transaction management code for this block A TransactionTemplate can accept a transaction callback object that implements:- a) TransactionCallback b) TransactionCallbackWithoutResult class c) All of the mentioned d) None of the mentioned Answer: c Explanation: A TransactionTemplate can accept a transaction callback object that implements either the TransactionCallback or an instance of the one implementor of that interface provided by the framework, the TransactionCallbackWithoutResult class Spring (since version 2.0) offers a transaction advice that can be easily configured via the:- a) rx:advice b) bx:advice 11

12 c) tx:advice d) none of the mentioned Answer: c Explanation: This advice can be enabled with the AOP configuration facilities defined in the aop saop schema You can omit the transaction-manager attribute in the element if your transaction manager has the name transactionmanager. a) True b) False Explanation: This element will automatically detect a transaction manager with this name. You have to s 12

Java Database Connectivity (JDBC) 25.1 What is JDBC?

PART 25 Java Database Connectivity (JDBC) 25.1 What is JDBC? JDBC stands for Java Database Connectivity, which is a standard Java API for database-independent connectivity between the Java programming