मॉर्फिया का परिचय - मोंगोडीबी के लिए जावा ओडीएम

1. अवलोकन

इस ट्यूटोरियल में, हम समझेंगे कि जावा में MongoDB के लिए मॉर्फिया, एक ऑब्जेक्ट डॉक्यूमेंट मैपर (ODM) का उपयोग कैसे करें।

इस प्रक्रिया में, हम यह भी समझेंगे कि ODM क्या है और यह MongoDB के साथ काम करने में कैसे मदद करता है।

2. एक ODMक्या है ?

इस क्षेत्र में शुरुआत न करने वालों के लिए, MongoDB एक दस्तावेज़-उन्मुख डेटाबेस है जिसे प्रकृति द्वारा वितरित करने के लिए बनाया गया है . दस्तावेज़-उन्मुख डेटाबेस, सरल शब्दों में, दस्तावेज़ों का प्रबंधन करते हैं, जो और कुछ नहीं बल्कि अर्ध-संरचित डेटा को व्यवस्थित करने का एक स्कीमा-रहित तरीका हैं। . वे NoSQL डेटाबेस के एक व्यापक और शिथिल परिभाषित छत्र के अंतर्गत आते हैं, जिसका नाम SQL डेटाबेस के पारंपरिक संगठन से उनके स्पष्ट प्रस्थान के नाम पर रखा गया है।

MongoDB जावा जैसी लगभग सभी लोकप्रिय प्रोग्रामिंग भाषाओं के लिए ड्राइवर प्रदान करता है . ये ड्राइवर MongoDB के साथ काम करने के लिए अमूर्तता की एक परत प्रदान करते हैं ताकि हम सीधे वायर प्रोटोकॉल के साथ काम न करें। इसे ऐसे समझें जैसे Oracle अपने रिलेशनल डेटाबेस के लिए JDBC ड्राइवर का कार्यान्वयन प्रदान करता है।

हालांकि, अगर हम सीधे जेडीबीसी के साथ काम करने के अपने दिनों को याद करते हैं, तो हम इस बात की सराहना कर सकते हैं कि यह कितना गन्दा हो सकता है - खासकर एक वस्तु-उन्मुख प्रतिमान में। सौभाग्य से, हमारे पास बचाव के लिए हाइबरनेट जैसे ऑब्जेक्ट रिलेशनल मैपिंग (ओआरएम) ढांचे हैं। यह MongoDB के लिए बहुत अलग नहीं है।

जबकि हम निश्चित रूप से निम्न-स्तरीय ड्राइवर के साथ काम कर सकते हैं, कार्य को पूरा करने के लिए इसे बहुत अधिक बॉयलरप्लेट की आवश्यकता होती है। यहां, हमारे पास ऑब्जेक्ट डॉक्यूमेंट मैपर (ओडीएम) नामक ओआरएम के समान अवधारणा है . मॉर्फिया वास्तव में जावा प्रोग्रामिंग भाषा के लिए उस स्थान को भरता है और मोंगोडीबी के लिए जावा ड्राइवर के शीर्ष पर काम करता है।

3. निर्भरताएँ सेट करना

हमें कुछ कोड में लाने के लिए हमने पर्याप्त सिद्धांत देखा है। हमारे उदाहरणों के लिए, हम पुस्तकों की एक लाइब्रेरी का मॉडल तैयार करेंगे और देखेंगे कि कैसे हम इसे Morphia का उपयोग करके MongoDB में प्रबंधित कर सकते हैं।

लेकिन इससे पहले कि हम शुरू करें, हमें कुछ निर्भरताएँ स्थापित करनी होंगी।

3.1. मोंगोडीबी

हमें काम करने के लिए MongoDB का एक चालू उदाहरण होना चाहिए। इसे प्राप्त करने के कई तरीके हैं, और सबसे आसान है हमारी स्थानीय मशीन पर सामुदायिक संस्करण को डाउनलोड और इंस्टॉल करना।

हमें सभी डिफ़ॉल्ट कॉन्फ़िगरेशन को यथावत छोड़ देना चाहिए, जिसमें वह पोर्ट भी शामिल है जिस पर MongoDB चलता है।

3.2. मॉर्फिया

हम मावेन सेंट्रल से मॉर्फिया के लिए पूर्व-निर्मित जार डाउनलोड कर सकते हैं और उन्हें हमारे जावा प्रोजेक्ट में उपयोग कर सकते हैं।

हालांकि, मावेन जैसे निर्भरता प्रबंधन उपकरण का उपयोग करने का सबसे आसान तरीका है:

<dependency>
    <groupId>dev.morphia.morphia</groupId>
    <artifactId>core</artifactId>
    <version>1.5.3</version>
</dependency>

4. मॉर्फिया का उपयोग करके कैसे कनेक्ट करें?

अब जबकि हमारे पास MongoDB स्थापित और चल रहा है और हमारे Java प्रोजेक्ट में Morphia सेट-अप है, हम Morphia का उपयोग करके MongoDB से कनेक्ट करने के लिए तैयार हैं।

आइए देखें कि हम इसे कैसे पूरा कर सकते हैं:

Morphia morphia = new Morphia();
morphia.mapPackage("com.baeldung.morphia");
Datastore datastore = morphia.createDatastore(new MongoClient(), "library");
datastore.ensureIndexes();

तो इतना ही है! आइए इसे बेहतर समझते हैं। हमारे मानचित्रण कार्यों के काम करने के लिए हमें दो चीजों की आवश्यकता है:

एक मैपर:यह हमारे जावा पीओजेओ को मोंगोडीबी संग्रह में मैप करने के लिए जिम्मेदार है . ऊपर हमारे कोड स्निपेट में, मॉर्फिया इसके लिए जिम्मेदार वर्ग है। ध्यान दें कि हम उस पैकेज को कैसे कॉन्फ़िगर कर रहे हैं जहां इसे हमारे पीओजेओ की तलाश करनी चाहिए।
एक कनेक्शन:यह एक MongoDB डेटाबेस का कनेक्शन है जिस पर मैपर विभिन्न ऑपरेशनों को निष्पादित कर सकता है। वर्ग डेटास्टोर पैरामीटर के रूप में MongoClient का एक उदाहरण लेता है (Java MongoDB ड्राइवर से) और MongoDB डेटाबेस का नाम, साथ काम करने के लिए एक सक्रिय कनेक्शन लौटाना ।

इसलिए, हम इस डेटास्टोर का उपयोग करने के लिए पूरी तरह तैयार हैं और हमारी संस्थाओं के साथ काम करें।

5. संस्थाओं के साथ कैसे काम करें?

इससे पहले कि हम अपने ताज़ा बनाए गए डेटास्टोर . का उपयोग कर सकें , हमें काम करने के लिए कुछ डोमेन इकाइयों को परिभाषित करने की आवश्यकता है।

5.1. साधारण इकाई

आइए एक साधारण पुस्तक . को परिभाषित करके प्रारंभ करें कुछ विशेषताओं वाली इकाई:

@Entity("Books")
public class Book {
    @Id
    private String isbn;
    private String title;
    private String author;
    @Property("price")
    private double cost;
    // constructors, getters, setters and hashCode, equals, toString implementations
}

यहाँ कुछ दिलचस्प बातें ध्यान देने योग्य हैं:

एनोटेशन पर ध्यान दें @इकाई जो इस POJO को ODM मैपिंग के लिए अर्हता प्राप्त करता है मॉर्फिया द्वारा
मॉर्फिया, डिफ़ॉल्ट रूप से, एक इकाई को उसके वर्ग के नाम से MongoDB में एक संग्रह में मैप करता है, लेकिन हम इसे स्पष्ट रूप से ओवरराइड कर सकते हैं (जैसे हमने इकाई के लिए किया है पुस्तक यहाँ)
मॉर्फिया, डिफ़ॉल्ट रूप से, एक इकाई में चर के नाम से MongoDB संग्रह में कुंजियों के लिए चर को मैप करता है, लेकिन फिर से हम इसे ओवरराइड कर सकते हैं (जैसे हमने चर लागत यहाँ)
अंत में, हमें एनोटेशन @Id द्वारा प्राथमिक कुंजी के रूप में कार्य करने के लिए इकाई में एक चर को चिह्नित करने की आवश्यकता है (जैसे हम यहां अपनी पुस्तक के लिए ISBN का उपयोग कर रहे हैं)

5.2. रिश्तों वाली संस्थाएं

वास्तविक दुनिया में, हालांकि, संस्थाएं शायद ही उतनी सरल होती हैं जितनी वे दिखती हैं और एक दूसरे के साथ जटिल संबंध रखती हैं। उदाहरण के लिए, हमारी साधारण इकाई पुस्तक एक प्रकाशक हो सकता है और अन्य साथी पुस्तकों का संदर्भ दे सकते हैं। हम उनका मॉडल कैसे बनाते हैं?

MongoDB संबंध बनाने के लिए दो तंत्र प्रदान करता है - संदर्भ और एम्बेडिंग . जैसा कि नाम से पता चलता है, संदर्भ के साथ, MongoDB संबंधित डेटा को उसी या एक अलग संग्रह में एक अलग दस्तावेज़ के रूप में संग्रहीत करता है और बस अपनी आईडी का उपयोग करके इसे संदर्भित करता है।

इसके विपरीत, एम्बेडिंग के साथ, MongoDB मूल दस्तावेज़ में ही संबंध को संग्रहीत करता है या एम्बेड करता है।

आइए देखें कि हम उनका उपयोग कैसे कर सकते हैं। आइए प्रकाशक . को एम्बेड करके प्रारंभ करें हमारी पुस्तक . में :

@Embedded
private Publisher publisher;

काफी सरल। अब आगे बढ़ते हैं और अन्य पुस्तकों के संदर्भ जोड़ते हैं:

@Reference
private List<Book> companionBooks;

बस इतना ही - मॉर्फिया मोंगोडीबी द्वारा समर्थित मॉडल संबंधों के लिए सुविधाजनक एनोटेशन प्रदान करता है। संदर्भ बनाम एम्बेडिंग का विकल्प, हालांकि, डेटा मॉडल जटिलता, अतिरेक, और संगति से आकर्षित होना चाहिए अन्य विचारों के बीच।

अभ्यास संबंधपरक डेटाबेस में सामान्यीकरण के समान है।

अब, हम पुस्तक . पर कुछ संचालन करने के लिए तैयार हैं डेटास्टोर . का उपयोग करना ।

6. कुछ बुनियादी संचालन

आइए देखें कि मॉर्फिया का उपयोग करके कुछ बुनियादी कार्यों के साथ कैसे काम किया जाए।

6.1. सहेजें

आइए पुस्तक . का एक उदाहरण बनाते हुए सबसे सरल संचालन से शुरू करें हमारे MongoDB डेटाबेस में लाइब्रेरी :

Publisher publisher = new Publisher(new ObjectId(), "Awsome Publisher");

Book book = new Book("9781565927186", "Learning Java", "Tom Kirkman", 3.95, publisher);
Book companionBook = new Book("9789332575103", "Java Performance Companion", 
  "Tom Kirkman", 1.95, publisher);

book.addCompanionBooks(companionBook);

datastore.save(companionBook);
datastore.save(book);

यह मॉर्फिया को हमारे मोंगोडीबी डेटाबेस में एक संग्रह बनाने के लिए पर्याप्त है, अगर यह अस्तित्व में नहीं है, और एक अपरर्ट ऑपरेशन करता है।

6.2. प्रश्न

आइए देखें कि क्या हम उस पुस्तक को क्वेरी करने में सक्षम हैं जिसे हमने अभी-अभी MongoDB में बनाया है:

List<Book> books = datastore.createQuery(Book.class)
  .field("title")
  .contains("Learning Java")
  .find()
  .toList();

assertEquals(1, books.size());

assertEquals(book, books.get(0));

मॉर्फिया में किसी दस्तावेज़ को क्वेरी करना डेटास्टोर . का उपयोग करके एक क्वेरी बनाने के साथ शुरू होता है और फिर कार्यात्मक प्रोग्रामिंग से प्यार करने वालों की खुशी के लिए घोषणात्मक रूप से फ़िल्टर जोड़ना!

मॉर्फिया फिल्टर और ऑपरेटरों के साथ बहुत अधिक जटिल क्वेरी निर्माण का समर्थन करता है। इसके अलावा, मॉर्फिया क्वेरी में परिणामों को सीमित करने, छोड़ने और क्रमबद्ध करने की अनुमति देता है।

इसके अलावा, मॉर्फिया हमें मोंगोडीबी के लिए जावा ड्राइवर के साथ लिखे गए कच्चे प्रश्नों का अधिक नियंत्रण के लिए उपयोग करने की अनुमति देता है, इसकी आवश्यकता होनी चाहिए।

6.3. अपडेट करें

यद्यपि प्राथमिक कुंजी मेल खाने पर एक सेव ऑपरेशन अपडेट को संभाल सकता है, मॉर्फिया चुनिंदा दस्तावेजों को अपडेट करने के तरीके प्रदान करता है:

Query<Book> query = datastore.createQuery(Book.class)
  .field("title")
  .contains("Learning Java");

UpdateOperations<Book> updates = datastore.createUpdateOperations(Book.class)
  .inc("price", 1);

datastore.update(query, updates);

List<Book> books = datastore.createQuery(Book.class)
  .field("title")
  .contains("Learning Java")
  .find()
  .toList();

assertEquals(4.95, books.get(0).getCost());

यहां, हम क्वेरी द्वारा लौटाई गई सभी पुस्तकों की कीमत को एक से बढ़ाने के लिए एक क्वेरी और एक अपडेट ऑपरेशन बना रहे हैं।

6.4. मिटाएं

अंत में, जो बनाया गया है उसे हटा दिया जाना चाहिए! फिर से, मॉर्फिया के साथ, यह काफी सहज है:

Query<Book> query = datastore.createQuery(Book.class)
  .field("title")
  .contains("Learning Java");

datastore.delete(query);

List<Book> books = datastore.createQuery(Book.class)
  .field("title")
  .contains("Learning Java")
  .find()
  .toList();

assertEquals(0, books.size());

हम पहले की तरह ही क्वेरी बनाते हैं और डेटास्टोर . पर डिलीट ऑपरेशन चलाते हैं ।

7. उन्नत उपयोग

MongoDB के पास कुछ उन्नत संचालन जैसे एकत्रीकरण, अनुक्रमण, और कई अन्य हैं . हालांकि मॉर्फिया का उपयोग करके वह सब करना संभव नहीं है, लेकिन उसमें से कुछ हासिल करना निश्चित रूप से संभव है। दूसरों के लिए, दुख की बात है कि हमें मोंगोडीबी के लिए जावा ड्राइवर पर वापस जाना होगा।

आइए इनमें से कुछ उन्नत कार्यों पर ध्यान दें जिन्हें हम मॉर्फिया के माध्यम से निष्पादित कर सकते हैं।

7.1. एकत्रीकरण

MongoDB में एकत्रीकरण हमें एक पाइपलाइन में संचालन की एक श्रृंखला को परिभाषित करने की अनुमति देता है जो दस्तावेजों के एक सेट पर काम कर सकता है और समग्र आउटपुट का उत्पादन कर सकता है ।

मॉर्फिया के पास ऐसी एकत्रीकरण पाइपलाइन का समर्थन करने के लिए एक एपीआई है।

आइए मान लें कि हम अपने पुस्तकालय डेटा को इस तरह से एकत्रित करना चाहते हैं कि हमारे पास उनके लेखक द्वारा समूहीकृत सभी पुस्तकें हैं:

Iterator<Author> iterator = datastore.createAggregation(Book.class)
  .group("author", grouping("books", push("title")))
  .out(Author.class);

यह कैसे काम करता है? हम उसी पुराने डेटास्टोर . का उपयोग करके एक एकत्रीकरण पाइपलाइन बनाकर शुरू करते हैं . हमें वह इकाई प्रदान करनी होगी जिस पर हम एकत्रीकरण संचालन करना चाहते हैं, उदाहरण के लिए, पुस्तक यहाँ।

इसके बाद, हम दस्तावेज़ों को "लेखक" द्वारा समूहित करना चाहते हैं और "पुस्तकें" नामक एक कुंजी के तहत उनके "शीर्षक" को एकत्रित करना चाहते हैं। अंत में, हम यहां एक ODM के साथ काम कर रहे हैं। इसलिए, हमें अपना समेकित डेटा एकत्र करने के लिए एक इकाई को परिभाषित करना होगा - हमारे मामले में, यह लेखक है ।

बेशक, हमें लेखक . नामक एक इकाई को परिभाषित करना होगा पुस्तकों नामक एक चर के साथ:

@Entity
public class Author {
    @Id
    private String name;
    private List<String> books;
    // other necessary getters and setters
}

यह, निश्चित रूप से, MongoDB द्वारा प्रदान किए गए एक बहुत ही शक्तिशाली निर्माण की सतह को खरोंचता है और विवरण के लिए आगे की खोज की जा सकती है।

7.2. प्रक्षेपण

MongoDB में प्रोजेक्शन हमें केवल उन फ़ील्ड का चयन करने की अनुमति देता है जिन्हें हम अपने प्रश्नों में दस्तावेज़ों से प्राप्त करना चाहते हैं . यदि दस्तावेज़ संरचना जटिल और भारी है, तो यह वास्तव में तब उपयोगी हो सकता है जब हमें केवल कुछ क्षेत्रों की आवश्यकता हो।

मान लें कि हमें अपनी क्वेरी में केवल उनके शीर्षक वाली पुस्तकें लाने की आवश्यकता है:

List<Book> books = datastore.createQuery(Book.class)
  .field("title")
  .contains("Learning Java")
  .project("title", true)
  .find()
  .toList();
 
assertEquals("Learning Java", books.get(0).getTitle());
assertNull(books.get(0).getAuthor());

यहां, जैसा कि हम देख सकते हैं, हम केवल अपने परिणाम में शीर्षक वापस प्राप्त करते हैं, न कि लेखक और अन्य क्षेत्रों में। हालांकि, हमें मोंगोडीबी को वापस सहेजने में अनुमानित आउटपुट का उपयोग करने में सावधान रहना चाहिए। इसके परिणामस्वरूप डेटा हानि हो सकती है!

7.3. अनुक्रमण

डेटाबेस के साथ क्वेरी ऑप्टिमाइज़ेशन में इंडेक्स बहुत महत्वपूर्ण भूमिका निभाते हैं - रिलेशनल और साथ ही कई गैर-रिलेशनल वाले।

MongoDB प्राथमिक कुंजी पर डिफ़ॉल्ट रूप से बनाए गए अद्वितीय अनुक्रमणिका के साथ संग्रह के स्तर पर अनुक्रमणिका को परिभाषित करता है . इसके अलावा, MongoDB किसी दस्तावेज़ के भीतर किसी भी क्षेत्र या उप-क्षेत्र पर अनुक्रमणिका बनाने की अनुमति देता है। हम जिस क्वेरी को बनाना चाहते हैं, उसके आधार पर हमें एक कुंजी पर एक इंडेक्स बनाना चुनना चाहिए।

उदाहरण के लिए, हमारे उदाहरण में, हम पुस्तक के "शीर्षक" फ़ील्ड पर एक अनुक्रमणिका बनाना चाह सकते हैं जैसा कि हम अक्सर इस पर पूछताछ करते हैं:

@Indexes({
  @Index(
    fields = @Field("title"),
    options = @IndexOptions(name = "book_title")
  )
})
public class Book {
    // ...
    @Property
    private String title;
    // ...
}

बेशक, हम बनने वाले इंडेक्स की बारीकियों को अनुकूलित करने के लिए अतिरिक्त इंडेक्सिंग विकल्प पास कर सकते हैं। ध्यान दें कि फ़ील्ड को @संपत्ति . द्वारा एनोटेट किया जाना चाहिए किसी अनुक्रमणिका में उपयोग करने के लिए।

इसके अलावा, क्लास-लेवल इंडेक्स के अलावा, मॉर्फिया में फील्ड-लेवल इंडेक्स को भी परिभाषित करने के लिए एक एनोटेशन है।

7.4. स्कीमा सत्यापन

हमारे पास एक संग्रह के लिए डेटा सत्यापन नियम प्रदान करने का विकल्प है जिसका उपयोग MongoDB अद्यतन या सम्मिलित ऑपरेशन करते समय कर सकता है . मॉर्फिया अपने एपीआई के माध्यम से इसका समर्थन करता है।

मान लें कि हम वैध मूल्य के बिना कोई पुस्तक सम्मिलित नहीं करना चाहते हैं। हम इसे प्राप्त करने के लिए स्कीमा सत्यापन का लाभ उठा सकते हैं:

@Validation("{ price : { $gt : 0 } }")
public class Book {
    // ...
    @Property("price")
    private double cost;
    // ...
}

MongoDB द्वारा प्रदान किए गए सत्यापन का एक समृद्ध सेट है जिसे यहां नियोजित किया जा सकता है।

8. वैकल्पिक MongoDB ODMs

जावा के लिए मॉर्फिया एकमात्र उपलब्ध मोंगोडीबी ओडीएम नहीं है। कई अन्य हैं जिन्हें हम अपने अनुप्रयोगों में उपयोग करने पर विचार कर सकते हैं। मॉर्फिया के साथ तुलना पर चर्चा यहां संभव नहीं है, लेकिन हमारे विकल्पों को जानना हमेशा उपयोगी होता है:

स्प्रिंग डेटा:MongoDB के साथ काम करने के लिए स्प्रिंग-आधारित प्रोग्रामिंग मॉडल प्रदान करता है
MongoJack:JSON से MongoDB ऑब्जेक्ट्स के लिए डायरेक्ट मैपिंग प्रदान करता है

यह जावा के लिए MongoDB ODMs की पूरी सूची नहीं है, लेकिन कुछ दिलचस्प विकल्प उपलब्ध हैं!