Transaksi MongoDB Data Musim Semi

1. Ikhtisar

Mulai dari rilis 4.0, MongoDB mendukung transaksi ACID multi-dokumen. Dan, Spring Data Lovelace sekarang menyediakan dukungan untuk transaksi asli MongoDB ini .

Dalam tutorial ini, kita akan membahas dukungan Spring Data MongoDB untuk transaksi sinkron dan reaktif.

Kami juga akan melihat Spring Data TransactionTemplate untuk dukungan transaksi non-asli.

Untuk pengenalan modul Data Musim Semi ini, lihat artikel pengantar kami.

2. Siapkan MongoDB 4.0

Pertama, kita perlu menyiapkan MongoDB terbaru untuk mencoba dukungan transaksi asli yang baru.

Untuk memulai, kita harus mengunduh versi terbaru dari Pusat Unduhan MongoDB.

Selanjutnya, kita akan memulai mongod layanan menggunakan baris perintah:

mongod --replSet rs0

Terakhir, mulai set replika – jika belum:

mongo --eval "rs.initiate()"

Perhatikan bahwa MongoDB saat ini mendukung transaksi melalui kumpulan replika.

3. Konfigurasi Maven

Selanjutnya, kita perlu menambahkan dependensi berikut ke pom.xml . kita :

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>3.0.3.RELEASE</version>
</dependency>

Rilis terbaru dari perpustakaan dapat ditemukan di Central Repository

4. Konfigurasi MongoDB

Sekarang, mari kita lihat konfigurasi kita:

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

    @Bean
    MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {
        return new MongoTransactionManager(dbFactory);
    }

    @Override
    protected String getDatabaseName() {
        return "test";
    }

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

Perhatikan bahwa kita perlu mendaftarkan MongoTransactionManager dalam konfigurasi kami untuk mengaktifkan transaksi MongoDB asli karena dinonaktifkan secara default.

5. Transaksi Sinkron

Setelah kita menyelesaikan konfigurasi, yang perlu kita lakukan untuk menggunakan transaksi asli MongoDB – adalah menganotasi metode kita dengan @Transaksional .

Segala sesuatu di dalam metode beranotasi akan dieksekusi dalam satu transaksi:

@Test
@Transactional
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));
}

Perhatikan bahwa kami tidak dapat menggunakan listCollections perintah di dalam transaksi multi-dokumen – misalnya:

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

Contoh ini menampilkan MongoTransactionException saat kami menggunakan collectionExists() metode.

6. Templat Transaksi

Kami melihat bagaimana Spring Data mendukung transaksi asli MongoDB baru. Selain itu, Spring Data juga menyediakan opsi non-asli.

Kami dapat melakukan transaksi non-asli menggunakan Spring Data TransactionTemplate :

@Test
public void givenTransactionTemplate_whenPerformTransaction_thenSuccess() {
    mongoTemplate.setSessionSynchronization(SessionSynchronization.ALWAYS);                                     

    TransactionTemplate transactionTemplate = new TransactionTemplate(mongoTransactionManager);
    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
        @Override
        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));
}

Kita perlu mengatur SessionSynchronization untuk SELALU untuk menggunakan transaksi Spring Data non-asli.

7. Transaksi Reaktif

Terakhir, kita akan melihat Dukungan Data Musim Semi untuk transaksi reaktif MongoDB .

Kita perlu menambahkan beberapa dependensi lagi ke pom.xml untuk bekerja dengan MongoDB reaktif:

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-reactivestreams</artifactId>
    <version>4.1.0</version>
</dependency>

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-sync</artifactId>
    <version>4.0.5</version>
</dependency>
        
<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-test</artifactId>
    <version>3.2.0.RELEASE</version>
    <scope>test</scope>
</dependency>

mongodb-driver-reactivestreams, mongodb-driver-sync dan dependensi uji reaktor tersedia di Maven Central.

Dan tentu saja, kita perlu mengkonfigurasi MongoDB Reaktif kita:

@Configuration
@EnableReactiveMongoRepositories(basePackages 
  = "com.baeldung.reactive.repository")
public class MongoReactiveConfig 
  extends AbstractReactiveMongoConfiguration {

    @Override
    public MongoClient reactiveMongoClient() {
        return MongoClients.create();
    }

    @Override
    protected String getDatabaseName() {
        return "reactive";
    }
}

Untuk menggunakan transaksi di MongoDB reaktif, kita perlu menggunakan inTransaction() metode di ReactiveMongoOperations :

@Autowired
private ReactiveMongoOperations reactiveOps;

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

Informasi lebih lanjut tentang repositori reaktif di Spring Data tersedia di sini.