1. Overview

Starting from the 4.0 release, MongoDB supports multi-document ACID transactions. And, Spring Data Lovelace now provides support for these native MongoDB transactions.

In this tutorial, we'll discuss Spring Data MongoDB support for synchronous and reactive transactions.

We'll also take a look at Spring Data TransactionTemplate for non-native transactions support.

For an introduction to this Spring Data module, have a look at our introductory write-up.

2. Setup MongoDB 4.0

First, we'll need to setup latest MongoDB to try the new native transactions support.

To get started, we have to download the latest version from the MongoDB Download Center.

Next, we'll start mongod service using the command line:

mongod --replSet rs0

Finally, initiate replica set – if not already:

mongo --eval "rs.initiate()"

Note that MongoDB currently supports transactions over a replica set.

3. Maven Configuration

Next, we need to add the following dependencies to our pom.xml:


The latest release of the library can be found on the Central Repository

4. MongoDB Configuration

Now, let's take a look at our configuration:

@EnableMongoRepositories(basePackages = "com.baeldung.repository")
public class MongoConfig extends AbstractMongoClientConfiguration{

    MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {
        return new MongoTransactionManager(dbFactory);

    protected String getDatabaseName() {
        return "test";

    public MongoClient mongoClient() {
        final ConnectionString connectionString = new ConnectionString("mongodb://localhost:27017/test");
        final MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
        return MongoClients.create(mongoClientSettings);

Note that we need to register MongoTransactionManager in our configuration to enable native MongoDB transactions as they are disabled by default.

5. Synchronous Transactions

After we finished the configuration, all we need to do to use native MongoDB transactions – is to annotate our method with @Transactional.

Everything inside the annotated method will be executed in one transaction:

public void whenPerformMongoTransaction_thenSuccess() {
    userRepository.save(new User("John", 30));
    userRepository.save(new User("Ringo", 35));
    Query query = new Query().addCriteria(Criteria.where("name").is("John"));
    List<User> users = mongoTemplate.find(query, User.class);

    assertThat(users.size(), is(1));

Note that we can't use listCollections command inside a multi-document transaction – for example:

@Test(expected = MongoTransactionException.class)
public void whenListCollectionDuringMongoTransaction_thenException() {
    if (mongoTemplate.collectionExists(User.class)) {
        mongoTemplate.save(new User("John", 30));
        mongoTemplate.save(new User("Ringo", 35));

This example throws a MongoTransactionException as we used the collectionExists() method.

6. TransactionTemplate

We saw how Spring Data support new MongoDB native transaction. Additionally, Spring Data also provides the non-native option.

We can perform non-native transactions using Spring Data TransactionTemplate:

public void givenTransactionTemplate_whenPerformTransaction_thenSuccess() {

    TransactionTemplate transactionTemplate = new TransactionTemplate(mongoTransactionManager);
    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            mongoTemplate.insert(new User("Kim", 20));
            mongoTemplate.insert(new User("Jack", 45));

    Query query = new Query().addCriteria(Criteria.where("name").is("Jack")); 
    List<User> users = mongoTemplate.find(query, User.class);

    assertThat(users.size(), is(1));

We need to set SessionSynchronization to ALWAYS to use non-native Spring Data transactions.

7. Reactive Transactions

Finally, we'll take a look at Spring Data support for MongoDB reactive transactions.

We'll need to add a few more dependencies to the pom.xml to work with reactive MongoDB:



The mongodb-driver-reactivestreams, mongodb-driver-sync and reactor-test dependencies are available on Maven Central.

And of course, we need to configure our Reactive MongoDB:

  = "com.baeldung.reactive.repository")
public class MongoReactiveConfig 
  extends AbstractReactiveMongoConfiguration {

    public MongoClient reactiveMongoClient() {
        return MongoClients.create();

    protected String getDatabaseName() {
        return "reactive";

To use transactions in reactive MongoDB, we need to use the inTransaction() method in ReactiveMongoOperations:

private ReactiveMongoOperations reactiveOps;

public void whenPerformTransaction_thenSuccess() {
    User user1 = new User("Jane", 23);
    User user2 = new User("John", 34);
      .execute(action -> action.insert(user1)

More information on reactive repositories in Spring Data is available here.

8. Conclusion

In this write-up, we learned how to use native and non-native MongoDB transactions using Spring Data.

The full source code for the examples is available over on GitHub.

Generic bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

Newest Most Voted
Inline Feedbacks
View all comments
1 year ago

Hello, nice article. I use spring boot 2.0.6 with relative spring data mongo. I use directly the mongotemplate with the dao pattern. So not repositories. I read that i have to use reactiveoperations to use transactions but what about mongotemplate and other queries executed with it ? It seems that they are separeted classes. Can i use mongotemplate to perform reactive transactions ?

Loredana Crusoveanu
1 year ago
Reply to  Antonio

Hey Antonio, if you use MongoTemplate then you can use the approach from section 5, with the @Transactional annotation. If you had reactive transactions, then your class would be ReactiveMongoTemplate (which implements ReactiveMongoOperations) and you would need to use the inTransaction() method.

Comments are closed on this article!