Transaction Management in Spring

Transaction Management :

Important aspect of transaction management is defining the right transaction boundary for e.g when should a transaction start,when should it end,when data should be committed in DB and when it should be rolled back (in the case of exception).

Spring provides the facility of AOP based transaction management in which transactions can be associated to the business logic as a concern.

Two types of transaction management are supported by the spring.
 
 Declarative transaction management
 Programmatic transaction management


  1. Programmatic transaction management : This means that you have to manage the transaction with the help of programming. That gives you extreme flexibility, but it is difficult to maintain.
  1.  Declarative transaction management: This means you separate transaction management from the business code. You only use annotations or XML based configuration to manage the transactions.

Choosing between Programmatic and Declarative Transaction Management:

  • Programmatic transaction management is good only if you have a small number of transactional operations. (Most of the times, this is not the case.)
  • Transaction name can be explicitly set only using Programmatic transaction management.
  • Programmatic transaction management should be used when you want explicit control over managing transactions.
  • On the other hand, if your application has numerous transactional operations, declarative transaction management is worthwhile.
  • Declarative Transaction management keeps transaction management out of business logic, and is not difficult to configure.
Components need to understand to use transaction management:

1. PlatformTransactionManager
It is an interface which provides method to start, commit, rollback transaction. Different Implementation of this interfacee are provided by the framework for the different API such as JDBC, JPA, JTA, Hibernate etc.

2. TransactionDefinition
It is an interface. It provides methods to obtain the characteristics of transaction. Different Implementation of TransactionManagement are provided by the framework.

3. TransactionStatus
It is also an interface. It provides the methods to obtain the state of the transaction. Its implementations are providing by the framework.

4. DataSourceUtils
It is a utility class. It facilities sharing of a connection among all the persistance method which participate in a transaction.

How It Works:


1. Transaction Manager is obtained.

2. TransactionDefinition object is created.

3. TransactionDefinition object is provided to the TransactionManager and the TransactionManager is asked to started the transaction.

4. TransactionManager reads the transaction characteristics from the TransactionDefinition.

5. TransactionManager asks a connection from the DataSourceUtils.

6. Connection is created by the DataSourceUtils.

7. Connection reference is provided to the TransactionManager as well as stored in a ThreadLocalRepository.

8. Using the connection, transaction is started by the TransactionManager and a TransactionStatus object is created to identify the transaction.

9. Reference of the TransactionStatus object is returned.

10 : Persistance methods are invoked.

11 : Connection is request by the persistance method from the DataSourceUtils.

12 : Connection participating in transaction is returned from the ThreadLocalRepository by the DataSourceUtils.

13 : Connection is used by the persistence methods for creating statements.

14 : Using the statement queries are executed.

15 : After the query execution control is returned to the DAO.

16 : DAO returns the control back to the business component without doing the connection.

17. Depending on the success or failure of the persistance mathod. TransactionManager is asked to commit and rollback the transaction.

18. TransactionManager identifies the connection for the transaction from the TransactionStatus.

19. TransactionManager asks the identfied connection to commit and rollaback the connection.  

Comments

Post a Comment

Popular posts from this blog

JIT Compiler

Image
The Just-In-Time (JIT) compiler is a component of the Java Runtime Environment that improves the performance of Java applications at run time. Java programs consists of classes, which contain platform neutral bytecode that can be interpreted by a JVM on many different computer architectures. At run time, the JVM loads the class files, determines the semantics of each individual bytecode, and performs the appropriate computation. The additional processor and memory usage during interpretation means that a Java application performs more slowly than a native application. The JIT compiler helps improve the performance of Java programs by compiling bytecode into native machine code at run time.  Nothing in the JVM affects performance more than the compiler, and choosing a compiler is one of the first decisions made when running a Java application whether you are a Java developer or an end-user. The JIT compiler is enabled by default, and is activated when a Java method is c
Read more

Authentication using One Time Password (OTP)

Image
The point of two-factor authentication is to prevent attackers from getting access to your account. Two-factor authentication requires that two tokens be provided for proof of ownership of the account. The first token is something that we're all familiar with- a username and a password. The second token is a bit more elusive, however. It should be something you have, and only you. No one else should be able to come into possession with the same token. The same should be true for usernames and passwords, but we've seen how easily broken a single-factor authentication system is.  The traditional way of just memorizing the password to validate one’s identity is not enough and web sites and applications are now expecting one to possess email Id or a smartphone to communicate with another short-lived randomized password, One Time Password (OTP) , as one more factor to the authentication. The first approach in the implementation of the two factor authenticati
Read more

JWT to Secure REST API with Spring Boot

Image
JWT Working Flow T o Secure your Rest services and the way to handle users Authentication/Authorization, First Approach is sending basic HTTP auth headers (username/password) for every request, but that would require to keep those credentials in memory and the service would have to check those credentials .So this’s not the best way. This is why REST services typically use a token system. A standard token system returns a 'token' (just a long unique string of random characters, for example a GUID) on successful login. The client in turn then sends this token in every request’s Authorization header. The service, on every request, 'rehydrates' its context by looking up the context on the server side. This context can be stored in a DB, retrieved from a Redis cache or simply stored in memory in a hash table. The downside of this approach is that for every REST method you will need to do this lookup in the database or cache. And then comes JSON Web Tokens, or JWT
Read more