Spring Data MongoDB Transactions – Spring Data MongoDB交易

最后修改: 2018年 10月 6日

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.

从4.0版本开始,MongoDB支持多文档ACID事务。而且,Spring Data Lovelace现在为这些本地MongoDB事务提供了支持

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

在本教程中,我们将讨论Spring Data MongoDB对同步和反应式事务的支持。

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

我们还将看看Spring Data TransactionTemplate对非本地事务的支持。

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

关于这个Spring Data模块的介绍,请看我们的介绍性的文章

2. Setup MongoDB 4.0

2.设置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.

我们看到Spring Data是如何支持新的MongoDB本地事务的。此外,Spring Data还提供了非本地选项。

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

我们可以使用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.

我们需要将SessionSynchronization设置为ALWAYS,以使用非本地的Spring Data事务。

7. Reactive Transactions


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

最后,我们将看一下Spring Data对MongoDB反应式事务的支持

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.

mongodb-driver-reactivestreamsmongodb-driver-sync 和 reactor-test依赖项可在Maven Central获得。

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

当然,我们还需要配置我们的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.

有关 Spring Data 中的反应式存储库的更多信息可在此处获得。

8. Conclusion


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

在本篇文章中,我们学习了如何使用Spring Data的本地和非本地MongoDB事务。

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