streamalism.org

1. Oversikt

Fra og med 4.0-utgivelsen støtter MongoDB multi-document ACID-transaksjoner. Og, Spring Data Lovelace gir nå støtte for disse innfødte MongoDB-transaksjonene.

I denne veiledningen vil vi diskutere Spring Data MongoDB-støtte for synkrone og reaktive transaksjoner.

Vi tar også en titt på Spring Data TransactionTemplate for ikke-innfødte transaksjoner støtte.

For en introduksjon til denne vårdatamodulen, ta en titt på vår innledende skriving.

2. Konfigurer MongoDB 4.0

Først må vi konfigurere nyeste MongoDB for å prøve den nye innfødte transaksjonstøtten.

For å komme i gang må vi laste ned den nyeste versjonen fra MongoDB Download Center.

Deretter begynner vi mongod tjeneste ved hjelp av kommandolinjen:

mongod --replSet rs0

Til slutt, start replikasett - hvis ikke allerede:

mongo --eval "rs.initiate ()"

Merk at MongoDB for øyeblikket støtter transaksjoner over et replikasett.

3. Maven-konfigurasjon

Deretter må vi legge til følgende avhengigheter i vår pom.xml:

 org.springframework.data spring-data-mongodb 3.0.3.RELEASE 

Den siste utgivelsen av biblioteket finner du på Central Repository

4. MongoDB-konfigurasjon

La oss ta en titt på konfigurasjonen vår:

@Configuration @EnableMongoRepositories (basePackages = "com.baeldung.repository") offentlig klasse MongoConfig utvider AbstractMongoClientConfiguration {@Bean MongoTransactionManager transactionManager (MongoDatabaseFactory dbFactory) {returner nye MongoTransactionManager; } @ Override-beskyttet streng getDatabaseName () {returner "test"; } @ Override public MongoClient mongoClient () {final ConnectionString connectionString = new ConnectionString ("mongodb: // localhost: 27017 / test"); endelig MongoClientSettings mongoClientSettings = MongoClientSettings.builder () .applyConnectionString (connectionString) .build (); returner MongoClients.create (mongoClientSettings); }}

Noter det vi må registrere oss MongoTransactionManager i vår konfigurasjon for å aktivere native MongoDB-transaksjoner ettersom de er deaktivert som standard.

5. Synkrontransaksjoner

Etter at vi er ferdig med konfigurasjonen, er alt vi trenger å gjøre for å bruke innfødte MongoDB-transaksjoner kommentere metoden vår med @Transaksjonell.

Alt i den merkede metoden vil bli utført i en transaksjon:

@Test @Transactional public void whenPerformMongoTransaction_thenSuccess () {userRepository.save (ny bruker ("John", 30)); userRepository.save (ny bruker ("Ringo", 35)); Query query = new Query (). AddCriteria (Criteria.where ("name"). Is ("John")); Liste brukere = mongoTemplate.find (spørring, User.class); assertThat (users.size (), er (1)); }

Merk at vi ikke kan bruke listCollections kommando i en multi-dokument transaksjon - for eksempel:

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

Dette eksemplet kaster a MongoTransactionException som vi brukte collectionExists () metode.

6. TransactionTemplate

Vi så hvordan Spring Data støtter ny MongoDB native-transaksjon. I tillegg gir Spring Data også alternativet som ikke er hjemmehørende.

Vi kan utføre ikke-innfødte transaksjoner ved hjelp av Spring Data TransactionTemplate:

@Test offentlig ugyldighet gittTransactionTemplate_whenPerformTransaction_thenSuccess () {mongoTemplate.setSessionSynchronization (SessionSynchronization.ALWAYS); TransactionTemplate transactionTemplate = ny 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")); Liste brukere = mongoTemplate.find (spørring, User.class); assertThat (users.size (), er (1)); }

Vi må sette SessionSynchronization til ALLTID å bruke ikke-opprinnelige vårdata-transaksjoner.

7. Reaktive transaksjoner

Til slutt tar vi en titt på Vårdatastøtte for MongoDB reaktive transaksjoner.

Vi må legge til noen flere avhengigheter til pom.xml å jobbe med reaktivt MongoDB:

 org.mongodb mongodb-driver-reactivestreams 4.1.0 org.mongodb mongodb-driver-sync 4.0.5 io.projectreactor reactor-test 3.2.0.RELEASE test 

Avhengighetene av mongodb-driver-reactivestreams, mongodb-driver-sync og reaktortest er tilgjengelige på Maven Central.

Og selvfølgelig må vi konfigurere vår reaktive MongoDB:

@Configuration @EnableReactiveMongoRepositories (basePackages = "com.baeldung.reactive.repository") offentlig klasse MongoReactiveConfig utvider AbstractReactiveMongoConfiguration {@Override public MongoClient reactiveMongoClient () {return MongoClients.c } @ Override-beskyttet streng getDatabaseName () {return "reaktiv"; }}

For å bruke transaksjoner i reaktivt MongoDB, må vi bruke inTransaction () metode i ReactiveMongoOperations:

@Autowired private ReactiveMongoOperations reactiveOps; @Test offentlig ugyldig nårPerformTransaction_thenSuccess () {User user1 = new User ("Jane", 23); Bruker bruker2 = ny bruker ("John", 34); reactiveOps.inTransaction () .execute (action -> action.insert (user1) .then (action.insert (user2))); }

Mer informasjon om reaktive arkiver i Spring Data er tilgjengelig her.

8. Konklusjon

I denne oppskriften lærte vi hvordan vi bruker innfødte og ikke-innfødte MongoDB-transaksjoner ved hjelp av Spring Data.

Den fullstendige kildekoden for eksemplene er tilgjengelig på GitHub.