Target Baby Registry 15% Off Single Item or Total Transaction
You can use this guide to get a simple and practical understanding of how Spring's transaction management with the @Transactional annotation works.
The only prerequisite? You need to have a rough thought about ACID, i.e. what database transactions are and why to use them. Also, distributed transactions or reactive transactions are not covered hither, though the general principles, in terms of Bound, however utilize.
Introduction
In this guide you are going to larn about the main pillars of Jump cadre's transaction abstraction framework (a confusing term, isn't information technology?) - described with a lot of code examples:
-
@Transactional (Declarative Transaction Management) vs Programmatic Transaction Management.
-
Physical vs Logical transactions.
-
Spring @Transactional and JPA / Hibernate integration.
-
Spring @Transactional and Spring Boot or Spring MVC integration.
-
Rollbacks, Proxies, Mutual Pitfalls and much more.
Equally opposed to, say, the official Spring documentation, this guide won't confuse you by diving correct into the topic Bound-beginning.
Instead y'all are going to learn Spring transaction management the unconventional way: From the footing upwards, step by stride. This means, starting with plainly old JDBC transaction management.
Why?
Because everything that Spring does is based on these very JDBC basics. And yous'll save a ton of time with Bound'southward @Transactional note later, if you lot grasp these nuts.
How plain JDBC Transaction Management works
If you are thinking of skipping this department, without knowing JDBC transactions within-out: don't.
How to kickoff, commit or rollback JDBC transactions
The commencement important take-away is this: It does non matter if you are using Spring's @Transactional annotation, plain Hide, jOOQ or any other database library.
In the end, they all practice the very same thing to open and close (let's call that 'manage') database transactions. Patently JDBC transaction management lawmaking looks like this:
import java.sql.Connection ; Connectedness connection = dataSource . getConnection (); // (i) try ( connection ) { connection . setAutoCommit ( imitation ); // (2) // execute some SQL statements... connection . commit (); // (three) } catch ( SQLException e ) { connexion . rollback (); // (4) } -
Y'all need a connexion to the database to showtime transactions. DriverManager.getConnection(url, user, password) would work equally well, though in near enterprise-y applications you volition accept a information source configured and become connections from that.
-
This is the only way to start a database transaction in Java, even though the name might sound a chip off. setAutoCommit(truthful) wraps every single SQL statement in its ain transaction and setAutoCommit(fake) is the opposite: Y'all are the master of the transaction.
-
Let's commit our transaction…
-
Or, rollback our changes, if at that place was an exception.
Yes, these 4 lines are (oversimplified) everything that Jump does whenever yous are using the @Transactional annotation. In the adjacent affiliate you'll find out how that works. Merely before we get at that place, in that location's a tiny bit more you need to learn.
(A quick notation for smarty-pants: Connection pool libraries similar HikariCP might toggle the autocommit mode automatically for you lot, depending on the configuration. But that is an advanced topic.)
How to apply JDBC isolation levels and savepoints
If you already played with Spring's @Transactional annotation you might have encountered something like this:
@Transactional ( propagation = TransactionDefinition . NESTED , isolation = TransactionDefinition . ISOLATION_READ_UNCOMMITTED ) We volition encompass nested Spring transactions and isolation levels later in more detail, but again information technology helps to know that these parameters all eddy down to the following, bones JDBC lawmaking:
import coffee.sql.Connection ; // isolation=TransactionDefinition.ISOLATION_READ_UNCOMMITTED connection . setTransactionIsolation ( Connectedness . TRANSACTION_READ_UNCOMMITTED ); // (one) // propagation=TransactionDefinition.NESTED Savepoint savePoint = connexion . setSavepoint (); // (2) ... connection . rollback ( savePoint ); -
This is how Spring sets isolation levels on a database connection. Not exactly rocket science, is information technology?
-
Nested transactions in Spring are just JDBC / database savepoints. If you don't know what a savepoint is, have a expect at this tutorial, for example. Note that savepoint support is dependent on your JDBC driver/database.
How Spring'due south or Spring Boot'southward Transaction Management works
Every bit you at present have a practiced JDBC transaction understanding, let's have a look at how patently, core Leap manages transactions. Everything here applies 1:ane to Spring Kick and Spring MVC, but more nigh that a bit later on..
What actually is Spring's transaction management or its (rather confusingly named) transaction abstraction framework?
Remember, transaction management simply ways: How does Spring start, commit or rollback JDBC transactions? Does this sound in whatsoever way familiar from above?
Here'south the catch: Whereas with plain JDBC you just have i way (setAutocommit(false)) to manage transactions, Spring offers you many dissimilar, more convenient ways to achieve the same.
How to use Bound's Programmatic Transaction Management?
The start, just rather sparingly used way to define transactions in Spring is programmatically: Either through a TransactionTemplate or straight through the PlatformTransactionManager. Code-wise, it looks similar this:
@Service public class UserService { @Autowired private TransactionTemplate template ; public Long registerUser ( User user ) { Long id = template . execute ( status -> { // execute some SQL that e.g. // inserts the user into the db and returns the autogenerated id return id ; }); } } Compared with the plain JDBC case:
-
You practice not accept to mess with opening or endmost database connections yourself (endeavor-finally). Instead you apply Transaction Callbacks.
-
Yous likewise exercise not take to catch SQLExceptions, as Spring converts these exceptions to runtime exceptions for you.
-
And y'all have better integration into the Bound ecosystem. TransactionTemplate will use a TransactionManager internally, which will use a data source. All are beans that you have to specify in your Spring context configuration, merely so don't have to worry virtually anymore subsequently.
While this counts as a minor improvement, programmatic transaction management is non what Jump'due south transaction framework mainly is nearly. Instead, it's all about declarative transaction management. Let'south find out what that is.
How to use Spring'southward XML Declarative Transaction Management?
Back in the day, when XML configuration was the norm for Spring projects, you could configure transactions directly in XML. Apart from a couple of legacy, enterprise projects, you won't find this arroyo anymore in the wild, as it has been superseded with the much simpler @Transactional notation.
Nosotros will non go into item on XML configuration in this guide, but you can use this case as a starting point to dive deeper into it - if needed (taken direct from the official Spring documentation):
<!-- the transactional advice (what 'happens'; see the <aop:advisor/> bean below) --> <tx:advice id= "txAdvice" transaction-manager= "txManager" > <!-- the transactional semantics... --> <tx:attributes> <!-- all methods starting with 'get' are read-simply --> <tx:method name= "get*" read-only= "true" /> <!-- other methods utilize the default transaction settings (see beneath) --> <tx:method proper noun= "*" /> </tx:attributes> </tx:advice> You are specifying an AOP advice (Aspect Oriented Programming) with the above XML block, that you lot tin can then employ to your UserService edible bean similar so:
<aop:config> <aop:pointcut id= "userServiceOperation" expression= "execution(* ten.y.service.UserService.*(..))" /> <aop:advisor communication-ref= "txAdvice" pointcut-ref= "userServiceOperation" /> </aop:config> <bean id= "userService" form= "x.y.service.UserService" /> Your UserService edible bean would then look like this:
public grade UserService { public Long registerUser ( User user ) { // execute some SQL that e.g. // inserts the user into the db and retrieves the autogenerated id return id ; } } From a Java lawmaking perspective, this declarative transaction approach looks a lot simpler than the programmatic approach. Only information technology leads to a lot of complicated, verbose XML, with the pointcut and advisor configurations.
So, this leads to the question: Is there a better way for declarative transaction direction instead of XML? Yes, there is: The @Transactional annotation.
How to employ Spring'southward @Transactional annotation ( Declarative Transaction Management )
Now let's accept a look at what modern Spring transaction management unremarkably looks like:
public form UserService { @Transactional public Long registerUser ( User user ) { // execute some SQL that e.one thousand. // inserts the user into the db and retrieves the autogenerated id // userDao.salve(user); return id ; } } How is this possible? At that place is no more than XML configuration and there's likewise no other code needed. Instead, you at present need to do ii things:
-
Make sure that your Leap Configuration is annotated with the @EnableTransactionManagement notation (In Jump Boot this will be done automatically for you).
-
Make sure you specify a transaction manager in your Leap Configuration (this you need to do anyway).
-
And and then Leap is smart enough to transparently handle transactions for you: Whatever edible bean's public method you annotate with the @Transactional note, volition execute inside a database transaction (note: there are some pitfalls).
So, to go the @Transactional annotation working, all you need to do is this:
@Configuration @EnableTransactionManagement public class MySpringConfig { @Bean public PlatformTransactionManager txManager () { return yourTxManager ; // more on that later } } Now, when I say Spring transparently handles transactions for you lot. What does that really hateful?
Armed with the knowledge from the JDBC transaction example, the @Transactional UserService code higher up translates (simplified) directly to this:
public grade UserService { public Long registerUser ( User user ) { Connection connection = dataSource . getConnection (); // (1) try ( connectedness ) { connection . setAutoCommit ( false ); // (i) // execute some SQL that due east.thou. // inserts the user into the db and retrieves the autogenerated id // userDao.save(user); < (2) connection . commit (); // (1) } catch ( SQLException e ) { connection . rollback (); // (one) } } } -
This is all only standard opening and closing of a JDBC connection. That'south what Spring's transactional annotation does for yous automatically, without y'all having to write it explicitly.
-
This is your own code, saving the user through a DAO or something similar.
This case might await a scrap magical, but let'southward take a look at how Jump inserts this connection code for you.
CGlib & JDK Proxies - @Transactional under the covers
Spring cannot really rewrite your Java class, like I did in a higher place, to insert the connection code (unless you are using advanced techniques like bytecode weaving, only we are ignoring that for now).
Your registerUser() method really just calls userDao.salvage(user), there's no fashion to change that on the wing.
But Spring has an advantage. At its core, it is an IoC container. It instantiates a UserService for you and makes sure to autowire that UserService into any other bean that needs a UserService.
Now whenever you are using @Transactional on a bean, Spring uses a tiny fob. Information technology does not just instantiate a UserService, but likewise a transactional proxy of that UserService.
It does that through a method called proxy-through-subclassing with the help of the Cglib library. In that location are besides other ways to construct proxies (like Dynamic JDK proxies), but let's leave information technology at that for the moment.
Permit'southward see proxies in action in this picture:
Every bit yous can see from that diagram, the proxy has one chore.
-
Opening and closing database connections/transactions.
-
And then delegating to the existent UserService, the one you wrote.
-
And other beans, like your UserRestController volition never know that they are talking to a proxy, and non the existent thing.
Quick Exam
Have a look at the following source code and tell me what type of UserService Spring automatically constructs, assuming it is marked with @Transactional or has a @Transactional method.
@Configuration @EnableTransactionManagement public static class MyAppConfig { @Bean public UserService userService () { // (one) return new UserService (); } } -
Correct. Spring constructs a dynamic CGLib proxy of your UserService class here that tin can open and close database transactions for you. You or whatever other beans won't fifty-fifty notice that information technology is non your UserService, but a proxy wrapping your UserService.
For what do you need a Transaction Director (like PlatformTransactionManager)?
Now in that location's merely one crucial slice of data missing, even though we have mentioned information technology a couple of times already.
Your UserService gets proxied on the fly, and the proxy manages transactions for you. Only it is not the proxy itself handling all this transactional state (open, commit, close), the proxy delegates that work to a transaction manager.
Spring offers y'all a PlatformTransactionManager / TransactionManager interface, which, past default, comes with a couple of handy implementations. One of them is the datasource transaction manager.
It does exactly what you did so far to manage transactions, but commencement, let's look at the needed Spring configuration:
@Bean public DataSource dataSource () { render new MysqlDataSource (); // (one) } @Bean public PlatformTransactionManager txManager () { render new DataSourceTransactionManager ( dataSource ()); // (2) } -
Y'all create a database-specific or connection-pool specific datasource here. MySQL is existence used for this example.
-
Here, you create your transaction director, which needs a data source to be able to manage transactions.
Simple every bit. All transaction managers then have methods like "doBegin" (for starting a transaction) or "doCommit", which look similar this - taken direct from Spring's source code and simplified a chip:
public class DataSourceTransactionManager implements PlatformTransactionManager { @Override protected void doBegin ( Object transaction , TransactionDefinition definition ) { Connectedness newCon = obtainDataSource (). getConnection (); // ... con . setAutoCommit ( false ); // yeah, that's it! } @Override protected void doCommit ( DefaultTransactionStatus status ) { // ... Connection connectedness = status . getTransaction (). getConnectionHolder (). getConnection (); try { con . commit (); } catch ( SQLException ex ) { throw new TransactionSystemException ( "Could not commit JDBC transaction" , ex ); } } } And so, the datasource transaction managing director uses exactly the same code that you lot saw in the JDBC section, when managing transactions.
With this in mind, let'southward extend our picture from higher up:
To sum things up:
-
If Spring detects the @Transactional note on a bean, information technology creates a dynamic proxy of that bean.
-
The proxy has access to a transaction manager and will ask it to open and close transactions / connections.
-
The transaction manager itself will merely do what you did in the evidently Java section: Manage a good, sometime JDBC connection.
What is the deviation betwixt physical and logical transactions?
Imagine the following two transactional classes.
@Service public class UserService { @Autowired individual InvoiceService invoiceService ; @Transactional public void invoice () { invoiceService . createPdf (); // send invoice every bit email, etc. } } @Service public grade InvoiceService { @Transactional public void createPdf () { // ... } } UserService has a transactional invoice() method. Which calls another transactional method, createPdf() on the InvoiceService.
At present in terms of database transactions, this should really simply be one database transaction. (Remember: getConnection(). setAutocommit(false). commit().) Spring calls this physical transaction, fifty-fifty though this might sound a scrap confusing at first.
From Leap'southward side however, there's ii logical transactions happening: Starting time in UserService, the other one in InvoiceService. Jump has to exist smart enough to know that both @Transactional methods, should employ the same underlying, physical database transaction.
How would things be unlike, with the following change to InvoiceService?
@Service public class InvoiceService { @Transactional ( propagation = Propagation . REQUIRES_NEW ) public void createPdf () { // ... } } Changing the propagation mode to requires_new is telling Spring that createPDF() needs to execute in its ain transaction, independent of whatsoever other, already existing transaction. Thinking back to the plainly Java section of this guide, did yous run across a way to "carve up" a transaction in half? Neither did I.
Which basically means your code volition open two (physical) connections/transactions to the database. (Once again: getConnection() x2. setAutocommit(false) x2. commit() x2) Spring now has to be smart enough that the two logical transactional pieces (invoice()/createPdf()) now also map to two dissimilar, physical database transactions.
And so, to sum things upward:
-
Physical Transactions: Are your actual JDBC transactions.
-
Logical Transactions: Are the (potentially nested) @Transactional-annotated (Spring) methods.
This leads us to covering propagation modes in more item.
What are @Transactional Propagation Levels used for?
When looking at the Bound source code, y'all'll find a multifariousness of propagation levels or modes that you can plug into the @Transactional method.
@Transactional ( propagation = Propagation . REQUIRED ) // or @Transactional ( propagation = Propagation . REQUIRES_NEW ) // etc The full list:
-
REQUIRED
-
SUPPORTS
-
MANDATORY
-
REQUIRES_NEW
-
NOT_SUPPORTED
-
NEVER
-
NESTED
Practise:
In the plain Java section, I showed you everything that JDBC can do when it comes to transactions. Have a minute to call back about what every single Spring propagation way at the end REALLY does to your datasource or rather, your JDBC connexion.
Then take a look at the following answers.
Answers:
-
Required (default): My method needs a transaction, either open 1 for me or employ an existing i → getConnection(). setAutocommit(imitation). commit().
-
Supports: I don't really care if a transaction is open or not, i can piece of work either way → nothing to do with JDBC
-
Mandatory: I'm not going to open up a transaction myself, merely I'm going to cry if no one else opened 1 up → nada to exercise with JDBC
-
Require_new: I desire my completely own transaction → getConnection(). setAutocommit(false). commit().
-
Not_Supported: I really don't similar transactions, I will even effort and suspend a current, running transaction → nix to do with JDBC
-
Never: I'g going to weep if someone else started upwardly a transaction → zilch to practice with JDBC
-
Nested: Information technology sounds so complicated, merely we are just talking savepoints! → connexion.setSavepoint()
Equally yous can run into, near propagation modes really have nix to do with the database or JDBC, but more with how you lot construction your program with Spring and how/when/where Leap expects transactions to exist in that location.
Wait at this example:
public class UserService { @Transactional ( propagation = Propagation . MANDATORY ) public void myMethod () { // execute some sql } } In this case, Spring will wait a transaction to be open up, whenever you phone call myMethod() of the UserService grade. Information technology does non open 1 itself, instead, if you phone call that method without a pre-existing transaction, Spring will throw an exception. Keep this in mind equally boosted points for "logical transaction handling".
What are @Transactional Isolation Levels used for?
This is about a trick question at this indicate, simply what happens when you configure the @Transactional annotation like and then?
@Transactional ( isolation = Isolation . REPEATABLE_READ ) Yes, information technology does just lead to this:
connexion . setTransactionIsolation ( Connexion . TRANSACTION_REPEATABLE_READ ); Database isolation levels are, notwithstanding, a complex topic, and you should take some fourth dimension to fully grasp them. A expert start is the official Postgres Documentation and their section on isolation levels.
Also annotation, that when it comes to switching isolation levels during a transaction, you lot must brand sure to consult with your JDBC driver/database to empathise which scenarios are supported and which non.
The near common @Transactional pitfall
There is ane pitfall that Spring beginners usually see. Have a look at the following code:
@Service public class UserService { @Transactional public void invoice () { createPdf (); // ship invoice every bit email, etc. } @Transactional ( propagation = Propagation . REQUIRES_NEW ) public void createPdf () { // ... } } You take a UserService class with a transactional invoice method. Which calls createPDF(), which is besides transactional.
How many physical transactions would you expect to be open, one time someone calls invoice()?
Nope, the answer is not ii, but one. Why?
Let'south go back to the proxies' section of this guide. Jump creates that transactional UserService proxy for y'all, but once you are inside the UserService form and telephone call other inner methods, there is no more than proxy involved. This ways, no new transaction for you.
Let'due south have a look at it with a picture:
At that place'due south some tricks (similar self-injection), which you tin can use to get around this limitation. But the main takeaway is: e'er go along the proxy transaction boundaries in heed.
How to use @Transactional with Leap Kicking or Spring MVC
Then far, nosotros have merely talked nigh evidently, core Spring. Merely what about Spring Kick? Or Bound Web MVC? Do they handle transactions any differently?
The brusk reply is: No.
With either frameworks (or rather: all frameworks in the Spring ecosystem), yous will always utilise the @Transactional annotation, combined with a transaction manager and the @EnableTransactionManagement annotation. There is no other way.
The only difference with Spring Boot is, even so, that it automatically sets the @EnableTransactionManagement note and creates a PlatformTransactionManager for you - with its JDBC machine-configurations. Learn more about auto-configurations here.
How Spring handles rollbacks (and default rollback policies)
The department on Jump rollbacks volition exist handled in the adjacent revision of this guide.
How Spring and JPA / Hibernate Transaction Direction works
The goal: Syncing Jump's @Transactional and Hibernate / JPA
At some point, you will want your Spring application to integrate with another database library, such as Hibernate (a popular JPA-implementation) or Jooq etc.
Let'south take apparently Hibernate every bit an case (note: it does not affair if you are using Hibernate directly,or Hibernate via JPA).
Rewriting the UserService from before to Hibernate would expect like this:
public form UserService { @Autowired individual SessionFactory sessionFactory ; // (i) public void registerUser ( User user ) { Session session = sessionFactory . openSession (); // (2) // lets open upwards a transaction. remember setAutocommit(imitation)! session . beginTransaction (); // salve == insert our objects session . save ( user ); // and commit information technology session . getTransaction (). commit (); // close the session == our jdbc connexion session . close (); } } -
This is a apparently, old Hibernate SessionFactory, the entry-point for all Hibernate queries.
-
Manually managing sessions (read: database connections) and transactions with Hibernate's API.
At that place is one huge problem with the in a higher place code, nevertheless:
-
Hide would non know almost Spring'due south @Transactional note.
-
Leap'due south @Transactional would not know anything about Hibernate's transaction.
Merely we'd really love for Jump and Hibernate to integrate seamlessly, meaning that they know well-nigh each others' transactions.
In plain lawmaking:
@Service public grade UserService { @Autowired individual SessionFactory sessionFactory ; // (1) @Transactional public void registerUser ( User user ) { sessionFactory . getCurrentSession (). salvage ( user ); // (2) } } -
The aforementioned SessionFactory as before
-
But no more manual country management. Instead, getCurrentSession() and @Transactional are in sync.
How to get there?
Using the HibernateTransactionManager
In that location is a very elementary set for this integration trouble:
The specialized HibernateTransactionManager will brand certain to:
-
Manage transactions through Hibernate, i.e. the SessionFactory.
-
Exist smart enough to allow Spring to utilise that very aforementioned transaction in non-Hide, i.e. @Transactional Spring code.
Equally always, a flick might be simpler to understand (though note, the period between the proxy and real service is only conceptually right and oversimplified).
That is, in a nutshell, how you integrate Jump and Hibernate.
For other integrations or a more in-depth agreement, information technology helps to have a quick look at all possible PlatformTransactionManager implementations that Bound offers.
Fin
By now, you should have a pretty good overview of how transaction management works with the Jump framework and how information technology too applies to other Spring libraries like Spring Boot or Spring WebMVC. The biggest takeaway should be, that it does not thing which framework you are using in the finish, it is all about the JDBC basics.
Get them right (Remember: getConnection(). setAutocommit(fake). commit().) and y'all will have a much easier understanding of what happens later on in your complex, enterprise application.
Thanks for reading.
Acknowledgements
Cheers to Andreas Eisele for feedback on the early versions of this guide. Thank you to Ben Horsfield for coming up with much-needed Javascript snippets to enhance this guide.
At that place's more than where that came from
I'll send you an update when I publish new guides. Admittedly no spam, ever. Unsubscribe anytime.
Comments
Source: https://www.marcobehler.com/guides/spring-transaction-management-transactional-in-depth
0 Response to "Target Baby Registry 15% Off Single Item or Total Transaction"
Enviar um comentário