Spring transaction management

Transaction management

A database transaction is a sequence of operations that is considered a single unit of work. T hese operations should either be performed in its entirety or not at all. T ransaction management is an important component of RDBMS for enterprise applications to ensure data integrity and consistency. The concept of a transaction can be described as having four key attributes that can be described as ACID:

• Atomicity: A transaction should be treated as a single unit of operation, which means that the entire sequence operation either succeeds or fails.

• Consistency: This represents the consistency of the reference integrity of the database, the unique primary key in the table, and so on.

• Isolation: Many transactions with the same data set may be processed at the same time, and each transaction should be isolated from other transactions to prevent data corruption.

• Persistence: Once a transaction has completed all operations, the result of the transaction must be permanent and cannot be removed from the database due to a system failure.

A true RDBMS database system guarantees all four properties for each transaction. A simple view of transactions published to the database using SQL is as follows:

• Start the transaction with the begin transaction command.

• Use SQL query statements to perform various deletions, updates, or inserts.

• If all operations succeed, the commit operation is performed, otherwise all operations are rolled back.

The Spring framework provides an abstraction layer at the top of different underlying transaction management APIs. S pring's transaction support is designed to provide an option for EJB transactions by adding transaction capabilities to POJOs. S pring supports programmatic and declartive transaction management. EJBs require an application server, but Spring transaction management can be implemented without the need for an application server.

Local transactions vs. global transactions

A local transaction is a single transaction resource, such as a JDBC connection, while a global transaction can span multiple transaction resource transactions, such as a transaction in a distributed system.

Local transaction management is useful in a centralized computing environment where application components and resources are located at one unit point, while transaction management involves only one local data manager running in a single machine. Local transactions are easier to implement.

Global transaction management requires a distributed computing environment in which all resources are distributed across multiple systems. I n this case, transaction management needs to be both local and global. Distributed or global transactions are executed across multiple systems and require coordination between the global transaction management system and local data managers of all related systems.

Programmatic vs. declared

Spring supports two types of transaction management:

• Programmatic transaction management: This means that you have the help of programming to manage transactions. This gives you a lot of flexibility, but it's hard to maintain.

• Declared transaction management: This means that you separate transaction management from your business code. You only use comments or XML configurations to manage transactions.

Declarive transaction management is preferable to programmatic transaction management, and although it is not as flexible as programmatic transaction management, it allows you to control transactions through code. H owever, as a cross-cutting concern, declarate transaction management can be modularized using the AOP approach. Spring supports statement transaction management using the Spring AOP framework.

Spring transaction abstraction

Spring transaction management has five key attributes: isolation level, propagation behavior, read-only, transaction timeout, and rollback rules

The key to Spring transaction abstraction is defined by the org.springframework.transaction.PlatformTransactionManager interface, as follows:

public interface PlatformTransactionManager {
   TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
   void commit(TransactionStatus status) throws TransactionException;
   void rollback(TransactionStatus status) throws TransactionException;
}

TransactionDefinition is the core interface supported by transactions in Spring and is defined as follows:

public interface TransactionDefinition {
   int getPropagationBehavior();
   int getIsolationLevel();
   String getName();
   int getTimeout();
   boolean isReadOnly();
}

Here are the possible values for the isolation level:

Here are the possible values for the propagation type:

The TransactionStatus interface provides transaction code with an easy way to control the execution of transactions and query transaction status.

public interface TransactionStatus extends SavepointManager {
   boolean isNewTransaction();
   boolean hasSavepoint();
   void setRollbackOnly();
   boolean isRollbackOnly();
   boolean isCompleted();
}