Using Transactions in Quarkus

Quarkus comes with a Transaction Manager and uses it to coordinate and expose transactions to your applications. Each extension dealing with persistence will integrate with it for you. And you will explicitly interact with transactions via CDI. This guide will walk you through all that.

Setting it up

You don’t need to worry about setting it up most of the time as extensions needing it will simply add it as a dependency. Hibernate ORM for example will include the transaction manager and set it up properly.

You might need to add it as a dependency explicitly if you are using transactions directly without Hibernate ORM for example. Add the following to your pom.xml:

<dependencies>
    <!-- Transaction Manager extension -->
    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-narayana-jta</artifactId>
    </dependency>
</dependencies>

Starting and stopping transactions: defining your boundaries

You can define your transaction boundaries the easy way, or the less easy way :)

Declarative approach

The easiest way to define your transaction boundaries is to use the @Transactional annotation on your entry method (javax.transaction.Transactional).

@ApplicationScoped
public class SantaClausService {

    @Inject ChildDAO childDAO;
    @Inject SantaClausDAO santaDAO;

    @Transactional (1)
    public void getAGiftFromSanta(Child child, String giftDescription) {
        // some transaction work
        Gift gift = childDAO.addToGiftList(child, giftDescription);
        if (gift == null) {
            throw new OMGGiftNotRecognizedException(); (2)
        }
        else {
            santaDAO.addToSantaTodoList(gift);
        }
    }
}

1	This annotation defines your transaction boundaries and will wrap this call within a transaction.
2	A `RuntimeException` crossing the transaction boundaries will rollback the transaction.

@Transactional can be used to control transaction boundaries on any CDI bean at the method level or at the class level to ensure every method is transactional. That includes REST endpoints.

You can control whether and how the transaction is started with parameters on @Transactional:

@Transactional(REQUIRED) (default): starts a transaction if none was started, stays with the existing one otherwise.
@Transactional(REQUIRES_NEW): starts a transaction if none was started ; if an existing one was started, suspends it and starts a new one for the boundary of that method.
@Transactional(MANDATORY): fails if no transaction was started ; works within the existing transaction otherwise.
@Transactional(SUPPORTS): if a transaction was started, joins it ; otherwise works with no transaction.
@Transactional(NOT_SUPPORTED): if a transaction was started, suspends it and works with no transaction for the boundary of the method ; otherwise works with no transaction.
@Transactional(NEVER): if a transaction was started, raises an exception ; otherwise works with no transaction.

REQUIRED or NOT_SUPPORTED are probably the most useful ones. This is how you decide whether a method is to be running within or outside a transaction. Make sure to check the JavaDoc for the precise semantic.

The transaction context is propagated to all calls nested in the @Transactional method as you would expect (in this example childDAO.addToGiftList() and santaDAO.addToSantaTodoList()). The transaction will commit unless a runtime exception crosses the method boundary. You can override whether an exception forces the rollback or not by using @Transactional(dontRollbackOn=SomeException.class) (or rollbackOn).

You can also programmatically ask for a transaction to be marked for rollback. Inject a TransactionManager for this.

@ApplicationScoped
public class SantaClausService {

    @Inject TransactionManager tm; (1)
    @Inject ChildDAO childDAO;
    @Inject SantaClausDAO santaDAO;

    @Transactional
    public void getAGiftFromSanta(Child child, String giftDescription) throws Exception {
        // some transaction work
        Gift gift = childDAO.addToGiftList(child, giftDescription);
        if (gift == null) {
            tm.setRollbackOnly(); (2)
        }
        else {
            santaDAO.addToSantaTodoList(gift);
        }
    }
}

1	Inject the `TransactionManager` to be able to activate `setRollbackOnly` semantic.
2	Programmatically decide to set the transaction for rollback.

API approach

The less easy way is to inject a UserTransaction and use the various transaction demarcation methods.

@ApplicationScoped
public class SantaClausService {

    @Inject ChildDAO childDAO
    @Inject SantaClausDAO santaDAO
    @Inject UserTransaction transaction

    public void getAGiftFromSanta(Child child, String giftDescription) throws Exception {
        // some transaction work
        try {
            transaction.begin();
            Gift gift = childDAO.addToGiftList(child, giftDescription);
            santaDAO.addToSantaTodoList(gift);
            transaction.commit();
        }
        catch(SomeException e) {
            // do something on Tx failure
            transaction.rollback();
        }
    }
}

You cannot use UserTransaction in a method having a transaction started by a @Transactional call.

Why always having a transaction manager?

Does it work everywhere I want to?: Yep, it works in your Quarkus application, in your IDE, in your tests, because all of these are Quarkus applications. JTA has some bad press for some people. I don’t know why. Let’s just say that this is not your grand’pa’s JTA implementation. What we have is perfectly embeddable and lean.
Does it do 2 Phase Commit and slow down my app?: No, this is an old folk tale. Let’s assume it essentially comes for free and let you scale to more complex cases involving several datasources as needed.
I don’t need transaction when I do read only operations, it’s faster.: Wrong.
First off, just disable the transaction by marking your transaction boundary with @Transactional(NOT_SUPPORTED) (or NEVER or SUPPORTS depending on the semantic you want).
Second, it’s again fairy tale that not using transaction is faster. The answer is, it depends on your DB and how many SQL SELECTs you are making. No transaction means the DB does have a single operation transaction context anyways.
Third, when you do several SELECTs, it’s better to wrap them in a single transaction because they will all be consistent with one another. Say your DB represents your car dashboard, you can see the number of kilometers remaining and the fuel gauge level. By reading it in one transaction, they will be consistent. If you read one and the other from two different transactions, then they can be inconsistent. It can be more dramatic if you read data related to rights and access management for example.
Why do you prefer JTA vs Hibernate’s transaction management API: Managing the transactions manually via entityManager.getTransaction().begin() and friends lead to a butt ugly code with tons of try catch finally that people get wrong. Transactions are also about JMS and other database access, so one API makes more sense.
It’s a mess because I don’t know if my JPA persistence unit is using JTA or Resource-level Transaction: It’s not a mess in Quarkus :) Resource-level was introduced to support JPA in a non managed environment. But Quarkus is both lean and a managed environment so we can safely always assume we are in JTA mode. The end result is that the difficulties of running Hibernate ORM + CDI + a transaction manager in Java SE mode are solved by Quarkus.