स्प्रिंग डेटा MongoDB का परिचय

1. अवलोकन

यह लेख एक त्वरित और व्यावहारिक स्प्रिंग डेटा MongoDB का परिचय . होगा

हम MongoTemplate . दोनों का उपयोग करके बुनियादी बातों पर ध्यान देंगे साथ ही MongoRepository , प्रत्येक ऑपरेशन को स्पष्ट करने के लिए व्यावहारिक उदाहरणों के साथ।

आगे पढ़ना:

MongoDB में भू-स्थानिक सहायता

एम्बेडेड MongoDB के साथ स्प्रिंग बूट एकीकरण परीक्षण

2. मोंगोटेम्पलेट और MongoRepository

द MongoTemplate स्प्रिंग में मानक टेम्पलेट पैटर्न का पालन करता है और अंतर्निहित दृढ़ता इंजन के लिए एक तैयार-टू-गो, बुनियादी एपीआई प्रदान करता है।

भंडार स्प्रिंग डेटा-केंद्रित दृष्टिकोण का अनुसरण करता है और सभी स्प्रिंग डेटा प्रोजेक्ट्स में जाने-माने एक्सेस पैटर्न के आधार पर अधिक लचीले और जटिल एपीआई संचालन के साथ आता है।

दोनों के लिए, हमें निर्भरता को परिभाषित करके शुरू करना होगा - उदाहरण के लिए, pom.xml में , मावेन के साथ:

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

यह जांचने के लिए कि क्या पुस्तकालय का कोई नया संस्करण जारी किया गया है, यहां रिलीज को ट्रैक करें।

3. MongoTemplate . के लिए कॉन्फ़िगरेशन

3.1. एक्सएमएल विन्यास

आइए Mongo टेम्पलेट के लिए सरल XML कॉन्फ़िगरेशन से शुरू करें:

<mongo:mongo-client id="mongoClient" host="localhost" />
<mongo:db-factory id="mongoDbFactory" dbname="test" mongo-client-ref="mongoClient" />

हमें सबसे पहले मोंगो इंस्टेंस बनाने के लिए जिम्मेदार फ़ैक्टरी बीन को परिभाषित करने की आवश्यकता है।

इसके बाद, हमें वास्तव में टेम्पलेट बीन को परिभाषित (और कॉन्फ़िगर) करने की आवश्यकता है:

<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate"> 
    <constructor-arg ref="mongoDbFactory"/> 
</bean>

और अंत में, हमें किसी भी MongoExceptions . का अनुवाद करने के लिए पोस्ट प्रोसेसर को परिभाषित करने की आवश्यकता है @Repository . में फेंका गया एनोटेट कक्षाएं:

<bean class=
  "org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>

3.2. जावा विन्यास

आइए अब MongoDB कॉन्फ़िगरेशन AbstractMongoConfiguration के लिए बेस क्लास का विस्तार करके जावा कॉन्फिगरेशन का उपयोग करके एक समान कॉन्फ़िगरेशन बनाएं। :

@Configuration
public class MongoConfig extends AbstractMongoClientConfiguration {
 
    @Override
    protected String getDatabaseName() {
        return "test";
    }
 
    @Override
    public MongoClient mongoClient() {
        ConnectionString connectionString = new ConnectionString("mongodb://localhost:27017/test");
        MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
            .applyConnectionString(connectionString)
            .build();
        
        return MongoClients.create(mongoClientSettings);
    }
 
    @Override
    public Collection getMappingBasePackages() {
        return Collections.singleton("com.baeldung");
    }
}

ध्यान दें कि हमें MongoTemplate को परिभाषित करने की आवश्यकता नहीं थी पिछले कॉन्फ़िगरेशन में बीन क्योंकि यह पहले से ही AbstractMongoClientConfiguration में परिभाषित है ।

हम AbstractMongoClientConfiguration . का विस्तार किए बिना भी शुरुआत से अपने कॉन्फ़िगरेशन का उपयोग कर सकते हैं :

@Configuration
public class SimpleMongoConfig {
 
    @Bean
    public MongoClient mongo() {
        ConnectionString connectionString = new ConnectionString("mongodb://localhost:27017/test");
        MongoClientSettings mongoClientSettings = MongoClientSettings.builder()
          .applyConnectionString(connectionString)
          .build();
        
        return MongoClients.create(mongoClientSettings);
    }

    @Bean
    public MongoTemplate mongoTemplate() throws Exception {
        return new MongoTemplate(mongo(), "test");
    }
}

4. MongoRepository . के लिए कॉन्फ़िगरेशन

4.1. एक्सएमएल विन्यास

कस्टम रिपॉजिटरी का उपयोग करने के लिए (MongoRepository . का विस्तार करना) ), हमें खंड 3.1 से कॉन्फ़िगरेशन जारी रखने की आवश्यकता है। और भंडार स्थापित करें:

<mongo:repositories 
  base-package="com.baeldung.repository" mongo-template-ref="mongoTemplate"/>

4.2. जावा विन्यास

इसी तरह, हम खंड 3.2 में पहले से बनाए गए कॉन्फ़िगरेशन पर निर्माण करेंगे। और मिश्रण में एक नया एनोटेशन जोड़ें:

@EnableMongoRepositories(basePackages = "com.baeldung.repository")

4.3. रिपोजिटरी बनाएं

कॉन्फ़िगरेशन के बाद, हमें एक रिपॉजिटरी बनाने की आवश्यकता है - मौजूदा MongoRepository . का विस्तार करना इंटरफ़ेस:

public interface UserRepository extends MongoRepository<User, String> {
    // 
}

अब हम इस UserRepository को ऑटो-वायर कर सकते हैं और MongoRepository . से संचालन का उपयोग करें या कस्टम संचालन जोड़ें।

5. MongoTemplate का उपयोग करना

5.1. इंसर्ट

आइए इन्सर्ट ऑपरेशन के साथ-साथ एक खाली डेटाबेस से शुरू करें:

{
}

अब यदि हम एक नया उपयोगकर्ता सम्मिलित करते हैं:

User user = new User();
user.setName("Jon");
mongoTemplate.insert(user, "user");

डेटाबेस इस तरह दिखेगा:

{
    "_id" : ObjectId("55b4fda5830b550a8c2ca25a"),
    "_class" : "com.baeldung.model.User",
    "name" : "Jon"
}

5.2. सहेजें - डालें

सहेजें ऑपरेशन में सेव-या-अपडेट शब्दार्थ है:यदि कोई आईडी मौजूद है, तो यह एक अपडेट करता है, और यदि नहीं, तो यह एक इंसर्ट करता है।

आइए पहले शब्दार्थ को देखें - सम्मिलित करें।

यहाँ डेटाबेस की प्रारंभिक स्थिति है:

{
}

जब हम अब सहेजें एक नया उपयोगकर्ता:

User user = new User();
user.setName("Albert"); 
mongoTemplate.save(user, "user");

इकाई को डेटाबेस में सम्मिलित किया जाएगा:

{
    "_id" : ObjectId("55b52bb7830b8c9b544b6ad5"),
    "_class" : "com.baeldung.model.User",
    "name" : "Albert"
}

इसके बाद, हम उसी ऑपरेशन को देखेंगे — सहेजें — अद्यतन शब्दार्थ के साथ।

5.3. सहेजें - अपडेट करें

आइए अब देखें सहेजें अद्यतन शब्दार्थ के साथ, मौजूदा निकाय पर कार्य कर रहा है:

{
    "_id" : ObjectId("55b52bb7830b8c9b544b6ad5"),
    "_class" : "com.baeldung.model.User",
    "name" : "Jack"
}

जब हम सहेजते हैं मौजूदा उपयोगकर्ता, हम इसे अपडेट करेंगे:

user = mongoTemplate.findOne(
  Query.query(Criteria.where("name").is("Jack")), User.class);
user.setName("Jim");
mongoTemplate.save(user, "user");

डेटाबेस इस तरह दिखेगा:

{
    "_id" : ObjectId("55b52bb7830b8c9b544b6ad5"),
    "_class" : "com.baeldung.model.User",
    "name" : "Jim"
}

हम देख सकते हैं कि इस विशेष उदाहरण में, सहेजें अपडेट . के शब्दार्थ का उपयोग करता है क्योंकि हम दिए गए _id . के साथ किसी ऑब्जेक्ट का उपयोग करते हैं ।

5.4. पहले अपडेट करें

पहले अपडेट करें क्वेरी से मेल खाने वाले पहले दस्तावेज़ को अपडेट करता है।

आइए डेटाबेस की प्रारंभिक स्थिति से शुरू करें:

[
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Alex"
    },
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614c"),
        "_class" : "com.baeldung.model.User",
        "name" : "Alex"
    }
]

जब हम अब updateFirst चलाते हैं :

Query query = new Query();
query.addCriteria(Criteria.where("name").is("Alex"));
Update update = new Update();
update.set("name", "James");
mongoTemplate.updateFirst(query, update, User.class);

केवल पहली प्रविष्टि अपडेट की जाएगी:

[
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "James"
    },
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614c"),
        "_class" : "com.baeldung.model.User",
        "name" : "Alex"
    }
]

5.5. मल्टी अपडेट करें

मल्टी अपडेट करें दी गई क्वेरी से मेल खाने वाले सभी दस्तावेज़ों को अपडेट करता है।

सबसे पहले, यहाँ updateMulti . करने से पहले डेटाबेस की स्थिति है :

[
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Eugen"
    },
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614c"),
        "_class" : "com.baeldung.model.User",
        "name" : "Eugen"
    }
]

अब चलिए अपडेटमल्टी चलाते हैं ऑपरेशन:

Query query = new Query();
query.addCriteria(Criteria.where("name").is("Eugen"));
Update update = new Update();
update.set("name", "Victor");
mongoTemplate.updateMulti(query, update, User.class);

दोनों मौजूदा ऑब्जेक्ट डेटाबेस में अपडेट किए जाएंगे:

[
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Victor"
    },
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614c"),
        "_class" : "com.baeldung.model.User",
        "name" : "Victor"
    }
]

5.6. FindAndModify

यह ऑपरेशन updateMulti . की तरह काम करता है , लेकिन यह ऑब्जेक्ट को संशोधित करने से पहले वापस कर देता है।

सबसे पहले, findAndModify . को कॉल करने से पहले यह डेटाबेस की स्थिति है :

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Markus"
}

आइए वास्तविक ऑपरेशन कोड देखें:

Query query = new Query();
query.addCriteria(Criteria.where("name").is("Markus"));
Update update = new Update();
update.set("name", "Nick");
User user = mongoTemplate.findAndModify(query, update, User.class);

लौटाया गया उपयोगकर्ता ऑब्जेक्ट डेटाबेस में प्रारंभिक स्थिति के समान मान हैं।

हालांकि, यह डेटाबेस में नया राज्य है:

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Nick"
}

5.7. ऊपर करें

अपसर्ट खोजें और संशोधित करें और शब्दार्थ बनाएं पर काम करता है :अगर दस्तावेज़ का मिलान हो गया है, तो उसे अपडेट करें, या फिर क्वेरी और अपडेट ऑब्जेक्ट को मिलाकर एक नया दस्तावेज़ बनाएं।

आइए डेटाबेस की प्रारंभिक स्थिति से शुरू करें:

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Markus"
}

अब चलिए अपसर्ट चलाते हैं :

Query query = new Query();
query.addCriteria(Criteria.where("name").is("Markus"));
Update update = new Update();
update.set("name", "Nick");
mongoTemplate.upsert(query, update, User.class);

यहाँ ऑपरेशन के बाद डेटाबेस की स्थिति है:

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Nick"
}

5.8. निकालें

निकालें . को कॉल करने से पहले हम डेटाबेस की स्थिति देखेंगे :

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Benn"
}

आइए अब चलाएं निकालें :

mongoTemplate.remove(user, "user");

परिणाम उम्मीद के मुताबिक होगा:

{
}

6. MongoRepository . का उपयोग करना

6.1. सम्मिलित करें

सबसे पहले, हम सम्मिलित करें . चलाने से पहले डेटाबेस की स्थिति देखेंगे :

{
}

अब हम एक नया उपयोगकर्ता सम्मिलित करेंगे:

User user = new User();
user.setName("Jon");
userRepository.insert(user);

और यहाँ डेटाबेस की अंतिम स्थिति है:

{
    "_id" : ObjectId("55b4fda5830b550a8c2ca25a"),
    "_class" : "com.baeldung.model.User",
    "name" : "Jon"
}

ध्यान दें कि ऑपरेशन कैसे सम्मिलित करें . के समान कार्य करता है MongoTemplate . में एपीआई।

6.2. सहेजें - डालें

इसी तरह, सहेजें सहेजें . के समान कार्य करता है MongoTemplate . में संचालन एपीआई।

आइए सम्मिलित शब्दार्थ को देखकर प्रारंभ करें ऑपरेशन के।

यहाँ डेटाबेस की प्रारंभिक स्थिति है:

{
}

अब हम सहेजें . निष्पादित करते हैं ऑपरेशन:

User user = new User();
user.setName("Aaron");
userRepository.save(user);

इसके परिणामस्वरूप उपयोगकर्ता को डेटाबेस में जोड़ा जाता है:

{
    "_id" : ObjectId("55b52bb7830b8c9b544b6ad5"),
    "_class" : "com.baeldung.model.User",
    "name" : "Aaron"
}

फिर से ध्यान दें कि कैसे सहेजें सम्मिलित करें . के साथ काम करता है शब्दार्थ क्योंकि हम एक नई वस्तु सम्मिलित कर रहे हैं।

6.3. सहेजें - अपडेट करें

आइए अब उसी ऑपरेशन को देखें लेकिन अद्यतन शब्दार्थ के साथ।

सबसे पहले, नया सहेजें . चलाने से पहले डेटाबेस की स्थिति यहां दी गई है :

{
    "_id" : ObjectId("55b52bb7830b8c9b544b6ad5"),
    "_class" : "com.baeldung.model.User",
    "name" : "Jack"81*6
}

अब हम ऑपरेशन निष्पादित करते हैं:

user = mongoTemplate.findOne(
  Query.query(Criteria.where("name").is("Jack")), User.class);
user.setName("Jim");
userRepository.save(user);

अंत में, यहाँ डेटाबेस की स्थिति है:

{
    "_id" : ObjectId("55b52bb7830b8c9b544b6ad5"),
    "_class" : "com.baeldung.model.User",
    "name" : "Jim"
}

फिर से ध्यान दें कि कैसे सहेजें अपडेट . के साथ काम करता है शब्दार्थ क्योंकि हम एक मौजूदा वस्तु का उपयोग कर रहे हैं।

6.4. हटाएं

हटाएं . को कॉल करने से पहले डेटाबेस की स्थिति यहां दी गई है :

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Benn"
}

आइए चलाएं हटाएं :

userRepository.delete(user);

और ये रहा हमारा परिणाम:

{
}

6.5. ढूंढें

इसके बाद, यह डेटाबेस की स्थिति है जब ढूंढें कहा जाता है:

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Chris"
}

आइए अब findOne . को क्रियान्वित करें :

userRepository.findOne(user.getId())

और परिणाम मौजूदा डेटा लौटाएगा:

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Chris"
}

6.6. मौजूद है

कॉल करने से पहले डेटाबेस की स्थिति मौजूद है :

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Harris"
}

अब चलो मौजूद चलाते हैं , जो निश्चित रूप से सत्य . लौटाएगा :

boolean isExists = userRepository.exists(user.getId());

6.7. सभी खोजें साथ क्रमबद्ध करें

findAll . को कॉल करने से पहले डेटाबेस की स्थिति :

[
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Brendan"
    },
    {
        "_id" : ObjectId("67b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Adam"
    }
]

आइए अब findAll . चलाते हैं साथ क्रमबद्ध करें :

List<User> users = userRepository.findAll(Sort.by(Sort.Direction.ASC, "name"));

परिणाम नाम के अनुसार आरोही क्रम में क्रमित किया जाएगा :

[
    {
        "_id" : ObjectId("67b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Adam"
    },
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Brendan"
    }
]

6.8. सभी खोजें साथ पेजेबल

findAll . को कॉल करने से पहले डेटाबेस की स्थिति :

[
    {
        "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Brendan"
    },
    {
        "_id" : ObjectId("67b5ffa5511fee0e45ed614b"),
        "_class" : "com.baeldung.model.User",
        "name" : "Adam"
    }
]

आइए अब निष्पादित करें सभी खोजें पेजिनेशन अनुरोध के साथ:

Pageable pageableRequest = PageRequest.of(0, 1);
Page<User> page = userRepository.findAll(pageableRequest);
List<User> users = pages.getContent();

परिणामी उपयोगकर्ता सूची केवल एक उपयोगकर्ता होगी:

{
    "_id" : ObjectId("55b5ffa5511fee0e45ed614b"),
    "_class" : "com.baeldung.model.User",
    "name" : "Brendan"
}

7. टिप्पणियां

अंत में, आइए उन सरल एनोटेशन पर भी ध्यान दें, जिनका उपयोग स्प्रिंग डेटा इन एपीआई कार्यों को चलाने के लिए करता है।

फ़ील्ड स्तर @Id एनोटेशन लंबी . सहित किसी भी प्रकार को सजा सकता है और स्ट्रिंग :

@Id
private String id;

अगर @Id . का मान फ़ील्ड शून्य नहीं है, यह डेटाबेस में इस रूप में संग्रहीत है; अन्यथा, कनवर्टर यह मान लेगा कि हम एक ऑब्जेक्टआईड . को स्टोर करना चाहते हैं डेटाबेस में (या तो ObjectId , स्ट्रिंग या BigInteger काम)।

हम आगे @Document . पर नज़र डालेंगे :

@Document
public class User {
    //
}

यह एनोटेशन केवल किसी वर्ग को डोमेन ऑब्जेक्ट के रूप में चिह्नित करता है जिसे हमें उपयोग किए जाने वाले संग्रह का नाम चुनने की अनुमति देने के साथ-साथ डेटाबेस में बने रहने की आवश्यकता है।