1. परिचय
इस ट्यूटोरियल में, हम यह देखने जा रहे हैं कि MongoDB के साथ स्प्रिंग डेटा रिएक्टिव रिपॉजिटरी के माध्यम से रिएक्टिव प्रोग्रामिंग का उपयोग करके डेटाबेस संचालन को कैसे कॉन्फ़िगर और कार्यान्वित किया जाए।
हम ReactiveCrud . के बुनियादी उपयोगों पर चर्चा करेंगे भंडार, ReactiveMongoRepository , साथ ही ReactiveMongoTemplate.
हालांकि ये कार्यान्वयन प्रतिक्रियाशील प्रोग्रामिंग का उपयोग करते हैं, यह इस ट्यूटोरियल का प्राथमिक फोकस नहीं है।
2. पर्यावरण
प्रतिक्रियाशील MongoDB का उपयोग करने के लिए, हमें निर्भरता को अपने pom.xml. में जोड़ना होगा।
हम परीक्षण के लिए एक एम्बेडेड MongoDB भी जोड़ेंगे:
<dependencies>
// ...
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
</dependency>
<dependency>
<groupId>de.flapdoodle.embed</groupId>
<artifactId>de.flapdoodle.embed.mongo</artifactId>
<scope>test</scope>
</dependency>
</dependencies>3. विन्यास
प्रतिक्रियाशील समर्थन को सक्रिय करने के लिए, हमें @EnableReactiveMongoRepositories का उपयोग करने की आवश्यकता है कुछ बुनियादी ढांचे के सेटअप के साथ:
@EnableReactiveMongoRepositories
public class MongoReactiveApplication
extends AbstractReactiveMongoConfiguration {
@Bean
public MongoClient mongoClient() {
return MongoClients.create();
}
@Override
protected String getDatabaseName() {
return "reactive";
}
}ध्यान दें कि उपरोक्त आवश्यक होगा यदि हम स्टैंडअलोन MongoDB स्थापना का उपयोग कर रहे थे। लेकिन, जैसा कि हम अपने उदाहरण में एम्बेडेड MongoDB के साथ स्प्रिंग बूट का उपयोग कर रहे हैं, उपरोक्त कॉन्फ़िगरेशन आवश्यक नहीं है।
4. एक दस्तावेज़ बनाना
नीचे दिए गए उदाहरणों के लिए, आइए एक खाता बनाएं क्लास और इसे @Document . के साथ एनोटेट करें डेटाबेस संचालन में इसका उपयोग करने के लिए:
@Document
public class Account {
@Id
private String id;
private String owner;
private Double value;
// getters and setters
}5. प्रतिक्रियाशील भंडारों का उपयोग करना
हम पहले से ही रिपॉजिटरी प्रोग्रामिंग मॉडल से परिचित हैं, सीआरयूडी विधियों को पहले से ही परिभाषित किया गया है और साथ ही कुछ अन्य सामान्य चीजों के लिए भी समर्थन है।
अब रिएक्टिव मॉडल के साथ, हमें विधियों और विशिष्टताओं का एक ही सेट मिलता है, सिवाय इसके कि हम परिणामों और मापदंडों से प्रतिक्रियाशील तरीके से निपटेंगे।
5.1. ReactiveCrudRepository
हम इस रिपॉजिटरी का उपयोग उसी तरह कर सकते हैं जैसे ब्लॉकिंग CrudRepository :
@Repository
public interface AccountCrudRepository
extends ReactiveCrudRepository<Account, String> {
Flux<Account> findAllByValue(String value);
Mono<Account> findFirstByOwner(Mono<String> owner);
}हम विभिन्न प्रकार के तर्क पारित कर सकते हैं जैसे सादा (स्ट्रिंग ), लपेटा हुआ (वैकल्पिक , स्ट्रीम ), या प्रतिक्रियाशील (मोनो , प्रवाह ) जैसा कि हम findFirstByOwner() . में देख सकते हैं विधि।
5.2. ReactiveMongoRepository
ReactiveMongoRepository . भी है इंटरफ़ेस, जो ReactiveCrudRepository . से विरासत में मिला है और कुछ नई क्वेरी विधियाँ जोड़ता है:
@Repository
public interface AccountReactiveRepository
extends ReactiveMongoRepository<Account, String> { }ReactiveMongoRepository . का उपयोग करना , हम उदाहरण के द्वारा क्वेरी कर सकते हैं:
Flux<Account> accountFlux = repository
.findAll(Example.of(new Account(null, "owner", null)));परिणामस्वरूप, हमें प्रत्येक खाता मिलेगा यह वही है जो पारित उदाहरण के रूप में है।
हमारे बनाए गए रिपॉजिटरी के साथ, उनके पास पहले से ही कुछ डेटाबेस संचालन करने के लिए परिभाषित तरीके हैं जिन्हें हमें लागू करने की आवश्यकता नहीं है:
Mono<Account> accountMono
= repository.save(new Account(null, "owner", 12.3));
Mono<Account> accountMono2 = repository
.findById("123456");5.3. RxJava2CrudRepository
RxJava2CrudRepository, . के साथ हमारा व्यवहार ReactiveCrudRepository, . जैसा ही है लेकिन RxJava . के परिणामों और पैरामीटर प्रकारों के साथ :
@Repository
public interface AccountRxJavaRepository
extends RxJava2CrudRepository<Account, String> {
Observable<Account> findAllByValue(Double value);
Single<Account> findFirstByOwner(Single<String> owner);
}5.4. हमारे बुनियादी संचालन का परीक्षण
हमारे भंडार विधियों का परीक्षण करने के लिए, हम परीक्षण ग्राहक का उपयोग करेंगे:
@Test
public void givenValue_whenFindAllByValue_thenFindAccount() {
repository.save(new Account(null, "Bill", 12.3)).block();
Flux<Account> accountFlux = repository.findAllByValue(12.3);
StepVerifier
.create(accountFlux)
.assertNext(account -> {
assertEquals("Bill", account.getOwner());
assertEquals(Double.valueOf(12.3) , account.getValue());
assertNotNull(account.getId());
})
.expectComplete()
.verify();
}
@Test
public void givenOwner_whenFindFirstByOwner_thenFindAccount() {
repository.save(new Account(null, "Bill", 12.3)).block();
Mono<Account> accountMono = repository
.findFirstByOwner(Mono.just("Bill"));
StepVerifier
.create(accountMono)
.assertNext(account -> {
assertEquals("Bill", account.getOwner());
assertEquals(Double.valueOf(12.3) , account.getValue());
assertNotNull(account.getId());
})
.expectComplete()
.verify();
}
@Test
public void givenAccount_whenSave_thenSaveAccount() {
Mono<Account> accountMono = repository.save(new Account(null, "Bill", 12.3));
StepVerifier
.create(accountMono)
.assertNext(account -> assertNotNull(account.getId()))
.expectComplete()
.verify();
}6. ReactiveMongoTemplate
रिपॉजिटरी दृष्टिकोण के अलावा, हमारे पास ReactiveMongoTemplate . है ।
सबसे पहले, हमें ReactiveMongoTemplate register को पंजीकृत करना होगा बीन के रूप में:
@Configuration
public class ReactiveMongoConfig {
@Autowired
MongoClient mongoClient;
@Bean
public ReactiveMongoTemplate reactiveMongoTemplate() {
return new ReactiveMongoTemplate(mongoClient, "test");
}
}और फिर, हम डेटाबेस संचालन करने के लिए इस बीन को अपनी सेवा में इंजेक्ट कर सकते हैं:
@Service
public class AccountTemplateOperations {
@Autowired
ReactiveMongoTemplate template;
public Mono<Account> findById(String id) {
return template.findById(id, Account.class);
}
public Flux<Account> findAll() {
return template.findAll(Account.class);
}
public Mono<Account> save(Mono<Account> account) {
return template.save(account);
}
}ReactiveMongoTemplate इसके कई तरीके हैं जो हमारे पास मौजूद डोमेन से संबंधित नहीं हैं, आप उन्हें दस्तावेज़ीकरण में देख सकते हैं।
