streamalism.org

1. סקירה כללית

במדריך זה נבין כיצד להשתמש ב- Morphia, Mapper Object Document Mapper (ODM) עבור MongoDB בג'אווה.

בתהליך נבין גם מה זה ODM וכיצד זה מאפשר לעבוד עם MongoDB.

2. מה זה ODM?

לחסרי היכרות באזור זה, MongoDB הוא מסד נתונים מונחה מסמכים הבנוי להפצה מטבעו. מאגרי מידע מכוונים למסמכים, במילים פשוטות, מנהלים מסמכים, שאינם אלא דרך ללא סכימה לארגן נתונים מובנים למחצה. הם נופלים תחת מטרייה רחבה יותר ומוגדרת באופן חופשי של מאגרי מידע NoSQL, על שם עזיבתם לכאורה מהארגון המסורתי של מאגרי SQL.

MongoDB מספק מנהלי התקנים כמעט לכל שפות התכנות הפופולריות כמו Java. מנהלי התקנים אלה מציעים שכבה של הפשטה לעבודה עם MongoDB כך שאיננו עובדים ישירות עם Wire Protocol. חשוב על כך שאורקל מספקת יישום של מנהל ההתקן JDBC למסד הנתונים היחסי שלהם.

עם זאת, אם נזכור את ימינו בעבודה עם JDBC ישירות, נוכל להעריך עד כמה זה יכול להיות מבולגן - במיוחד בפרדיגמה מונחית עצמים. למרבה המזל, יש לנו מסגרות מיפוי אובייקטים (ORM) כמו Hibernate להצלתנו. זה לא שונה מאוד עבור MongoDB.

אמנם אנו יכולים בהחלט לעבוד עם הנהג ברמה הנמוכה, אך לשם כך נדרש הרבה יותר פלטת דוד. הנה, יש לנו מושג דומה ל- ORM הנקרא Object Document Mapper (ODM). מורפיה בדיוק ממלא את המרחב הזה עבור שפת התכנות ג'אווה ועובד על גבי מנהל ההתקן של Java עבור MongoDB.

3. הגדרת תלות

ראינו מספיק תיאוריה כדי להכניס אותנו לקוד כלשהו. לדוגמאות שלנו, נעבד מודל של ספריית ספרים ונראה כיצד אנו יכולים לנהל אותה ב- MongoDB באמצעות מורפיה.

אך לפני שנתחיל, נצטרך להגדיר חלק מהתלות.

3.1. MongoDB

עלינו להיות מופע פועל של MongoDB לעבוד איתו. ישנן מספר דרכים להשיג זאת, והפשוטה ביותר היא להוריד ולהתקין מהדורה קהילתית במחשב המקומי שלנו.

עלינו להשאיר את כל תצורות ברירת המחדל כפי שהן, כולל הנמל שעליו פועל MongoDB.

3.2. מורפיה

אנו יכולים להוריד את ה- JAR שנבנו מראש עבור מורפיה ממייבן סנטרל ולהשתמש בהם בפרויקט Java שלנו.

עם זאת, הדרך הפשוטה ביותר היא להשתמש בכלי ניהול תלות כמו Maven:

 dev.morphia.morphia core 1.5.3 

4. כיצד להתחבר באמצעות מורפיה?

כעת, לאחר שהתקנו והפעלנו את MongoDB והקמנו את מורפיה בפרויקט Java שלנו, אנו מוכנים להתחבר ל- MongoDB באמצעות מורפיה.

בואו נראה איך נוכל להשיג זאת:

מורפיה מורפיה = מורפיה חדשה (); morphia.mapPackage ("com.baeldung.morphia"); חנות נתונים חנות נתונים = morphia.createDatastore (MongoClient חדש (), "ספרייה"); datastore.ensureIndexes ();

זה פחות או יותר זה! בואו נבין את זה טוב יותר. אנו זקוקים לשני דברים כדי שפעולות המיפוי שלנו יפעלו:

1. Mapper: זה אחראי על מיפוי Java POJO שלנו לאוספי MongoDB. בקטע הקוד שלנו לעיל, מורפיה הוא הכיתה האחראית לכך. שים לב כיצד אנו מגדירים את החבילה היכן שהיא צריכה לחפש את ה- POJO שלנו.
2. חיבור: זהו החיבור למסד נתונים של MongoDB שעליו יכול הממפה לבצע פעולות שונות. הכיתה חנות מידע לוקח כפרמטר מופע של MongoClient (ממנהל ההתקן של Java MongoDB) ושם מסד הנתונים של MongoDB, החזרת חיבור פעיל לעבודה.

אז כולנו מוכנים להשתמש בזה חנות מידע ולעבוד עם הישויות שלנו.

5. כיצד לעבוד עם ישויות?

לפני שנוכל להשתמש במטבעות הטריות שלנו חנות מידע, עלינו להגדיר כמה ישויות תחום לעבוד איתן.

5.1. ישות פשוטה

נתחיל בהגדרת פשוט סֵפֶר ישות עם כמה תכונות:

@Entity ("ספרים") ספר בכיתה ציבורית {@Id פרטי מחרוזת isbn; כותרת מחרוזת פרטית; סופר מחרוזת פרטי; @Property ("מחיר") עלות כפולה פרטית; // בונים, גטרים, סטרים ו- hashCode, שווה, ליישומי מחרוזת}

יש לציין כאן כמה דברים מעניינים:

• שימו לב להערה @יֵשׁוּת שמסמיך POJO זה למיפוי ODM מאת מורפיה
• מורפיה, כברירת מחדל, ממפה ישות לאוסף ב- MongoDB בשם המחלקה שלה, אך אנו יכולים לעקוף זאת במפורש (כמו שעשינו עבור הישות סֵפֶר פה)
• מורפיה, כברירת מחדל, ממפה את המשתנים ביישות למפתחות באוסף MongoDB בשם המשתנה, אך שוב אנו יכולים לעקוף זאת (כמו שעשינו למשתנה עֲלוּת פה)
• לבסוף, אנחנו צריכים סמן משתנה ביישות כדי שישמש כמפתח הראשי על ידי ההערה @תְעוּדַת זֶהוּת (כאילו אנחנו משתמשים ב- ISBN עבור הספר שלנו כאן)

5.2. ישויות עם מערכות יחסים

בעולם האמיתי, עם זאת, ישויות אינן פשוטות כפי שהן נראות ומנהלות מערכות יחסים מורכבות זו עם זו. למשל, היישות הפשוטה שלנו סֵפֶר יכול להיות מוֹצִיא לָאוֹר ויכולים להפנות לספרי לוויה אחרים. איך אנחנו מדגמנים אותם?

MongoDB מציע שני מנגנונים לבניית מערכות יחסים - הפניה והטבעה. כפי שהשם מרמז, בהפניה, MongoDB שומר נתונים קשורים כמסמך נפרד באותו אוסף או אחר ופשוט מפנה אליו באמצעות המזהה שלו.

נהפוך הוא, עם הטבעה, MongoDB מאחסן או ליתר דיוק מטמיע את הקשר בתוך מסמך האם עצמו.

בואו נראה איך נוכל להשתמש בהם. נתחיל בהטבעה מוֹצִיא לָאוֹר בשלנו סֵפֶר:

מו"ל מפרסם פרטי משובץ;

פשוט מספיק. עכשיו בואו נמשיך להוסיף הפניות לספרים אחרים:

@ רפרנס רשימה פרטית companionBooks;

זהו זה - מורפיאה מספקת הערות נוחות למודלים של מערכות יחסים בתמיכת MongoDB. הבחירה ב התייחסות לעומת הטמעה, לעומת זאת, צריכה לשאוב ממורכבות, יתירות ועקביות ממודל מודל הנתונים בין יתר השיקולים.

התרגיל דומה לנורמליזציה במאגרי מידע יחסיים.

כעת אנו מוכנים לבצע פעולות נוספות סֵפֶר באמצעות חנות מידע.

6. כמה פעולות בסיסיות

בואו נראה כיצד לעבוד עם כמה מהפעולות הבסיסיות באמצעות מורפיה.

6.1. להציל

נתחיל עם הפעולות הפשוטות ביותר, ויצור מופע של סֵפֶר במסד הנתונים שלנו של MongoDB סִפְרִיָה:

מפרסם לאור = מפרסם חדש (ObjectId חדש (), "מפרסם Awsome"); ספר ספרים = ספר חדש ("9781565927186", "לימוד ג'אווה", "טום קירקמן", 3.95, הוצאה לאור); ספר לוויה ספר = ספר חדש ("9789332575103", "Java Performance Companion", "Tom Kirkman", 1.95, הוצאה לאור); book.addCompanionBooks (ספר לוויה); datastore.save (ספר לוויה); datastore.save (ספר);

זה מספיק כדי לאפשר למורפיה ליצור אוסף במסד הנתונים שלנו של MongoDB, אם הוא לא קיים, ולבצע פעולת עלייה.

6.2. שאילתא

בואו נראה אם ​​אנו מסוגלים לשאול את הספר שיצרנו זה עתה ב- MongoDB:

ספר ספרים = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .find () .toList (); assertEquals (1, books.size ()); assertEquals (ספר, books.get (0));

שאילתת מסמך במורפיה מתחילה ביצירת שאילתה באמצעות חנות מידע ואז הוספת מסננים בהצהרה, לשמחת המאוהבים בתכנות פונקציונלי!

מורפיה תומכת בבניית שאילתות מורכבת הרבה יותר עם פילטרים ומפעילים. יתר על כן, מורפיה מאפשרת להגביל, לדלג ולסדר תוצאות בשאילתה.

יתרה מכך, מורפיה מאפשר לנו להשתמש בשאילתות גולמיות שנכתבו עם מנהל ההתקן של Java עבור MongoDB לצורך שליטה רבה יותר, אם יהיה צורך בכך.

6.3. עדכון

למרות שפעולת שמירה יכולה לטפל בעדכונים אם המפתח הראשי תואם, מורפיה מספקת דרכים לעדכן באופן סלקטיבי מסמכים:

שאילתת שאילתה = datastore.createQuery (Book.class) .field ("title") .contains ("למידת Java"); עדכוני UpdateOperations = datastore.createUpdateOperations (Book.class) .inc ("מחיר", 1); datastore.update (שאילתה, עדכונים); ספר ספרים = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .find () .toList (); assertEquals (4.95, books.get (0) .getCost ());

כאן אנו בונים שאילתה ופעולת עדכון כדי להעלות באחד את מחיר הספרים שהוחזרו על ידי השאילתה.

6.4. לִמְחוֹק

לבסוף יש למחוק את מה שנוצר! שוב, עם מורפיה, זה די אינטואיטיבי:

שאילתת שאילתה = datastore.createQuery (Book.class) .field ("title") .contains ("למידת Java"); datastore.delete (שאילתה); ספר ספרים = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .find () .toList (); assertEquals (0, books.size ());

אנו יוצרים את השאילתה באופן דומה למדי כמו בעבר ומריצים את פעולת המחיקה ב- חנות מידע.

7. שימוש מתקדם

ל- MongoDB יש כמה פעולות מתקדמות כמו צבירה, אינדקס ורבים אחרים. אמנם לא ניתן לבצע את כל אלה באמצעות מורפיה, אך בהחלט ניתן להשיג חלק מכך. לאחרים, למרבה הצער, נצטרך לחזור למנהל ההתקן של Java עבור MongoDB.

בואו נתמקד בכמה מהפעולות המתקדמות הללו שנוכל לבצע באמצעות מורפיה.

7.1. צבירה

צבירה ב- MongoDB מאפשרת לנו להגדיר סדרת פעולות בצינור שיכולה לפעול על סט מסמכים ולהפיק פלט מצטבר.

למורפיה יש API שתומך בצינור צבירה כזה.

נניח שאנו רוצים לצבור את נתוני הספרייה שלנו בצורה כזו שקובץ את כל הספרים לפי מחברם:

איטרטור איטרטור = datastore.createAggregation (Book.class) .group ("מחבר", קיבוץ ("ספרים", דחיפה ("כותרת")). Out (מחבר. Class);

אז איך זה עובד? אנו מתחילים ביצירת צינור צבירה באמצעות אותו ישן חנות מידע. עלינו לספק את הישות עליה אנו רוצים לבצע פעולות צבירה, למשל, סֵפֶר פה.

לאחר מכן, אנו רוצים לקבץ מסמכים לפי "מחבר" ​​ולצבור את "כותרתם" תחת מפתח שנקרא "ספרים". לבסוף, אנו עובדים עם ODM כאן. אז עלינו להגדיר ישות שתאסוף את הנתונים המצטברים שלנו - במקרה שלנו זה מְחַבֵּר.

כמובן, עלינו להגדיר ישות שנקראת מְחַבֵּר עם משתנה שנקרא ספרים:

@Entity class class מחבר {@Id פרטי שם מחרוזת; ספרי רשימה פרטיים; // אחרים וקבצים נחוצים אחרים}

זה, כמובן, רק מגרד את פני השטח של מבנה חזק מאוד המסופק על ידי MongoDB וניתן לחקור אותו לפרטים נוספים.

7.2. הַקרָנָה

הקרנה ב- MongoDB מאפשרת לנו בחר רק את השדות שאנו רוצים להביא ממסמכים בשאילתות שלנו. במקרה שמבנה המסמך מורכב וכבד, זה יכול להיות מאוד שימושי כשאנחנו זקוקים לשדות בודדים בלבד.

נניח שעלינו להביא ספרים עם כותרתם רק בשאילתה שלנו:

ספר ספרים = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .project ("title", true) .find () .toList (); assertEquals ("לימוד Java", books.get (0) .getTitle ()); assertNull (books.get (0) .getAuthor ());

כאן, כפי שאנו רואים, אנו מקבלים רק את הכותרת בתוצאה שלנו ולא המחבר ותחומים אחרים. עלינו, עם זאת, להיזהר בשימוש בפלט המוקרן בחיסכון בחזרה ל- MongoDB. זה עלול לגרום לאובדן נתונים!

7.3. אינדקס

לאינדקסים תפקיד חשוב מאוד באופטימיזציה של שאילתות עם בסיסי נתונים - יחסיים כמו גם רבים שאינם קשורים.

MongoDB מגדיר אינדקסים ברמת האוסף עם אינדקס ייחודי שנוצר על המפתח הראשי כברירת מחדל. יתר על כן, MongoDB מאפשר ליצור אינדקסים בכל שדה או שדה משנה במסמך. עלינו לבחור ליצור אינדקס על מקש בהתאם לשאילתה שברצוננו ליצור.

לדוגמא, בדוגמה שלנו, ייתכן שנרצה ליצור אינדקס בשדה "כותרת" סֵפֶר כשאנחנו בסופו של דבר שואלים על זה:

@Indexes ({@Index (שדות = @Field ("כותרת"), אפשרויות = @IndexOptions (name = "book_title"))}) ספר בכיתה ציבורית {// ... @Property פרטי כותרת מחרוזת; // ...}

כמובן, אנו יכולים להעביר אפשרויות נוספות לאינדקס כדי להתאים את הניואנסים של האינדקס שנוצר. שים לב כי השדה צריך להיות ביאור על ידי @תכונה לשימוש באינדקס.

יתר על כן, מלבד המדד ברמה הכיתתית, למורפיה יש ביאור להגדרת אינדקס ברמת השדה.

7.4. אימות סכמה

יש לנו אפשרות לספק כללי אימות נתונים לאוסף בו MongoDB יכולה להשתמש בעת ביצוע פעולת עדכון או הוספה. מורפיה תומכת בכך באמצעות ממשקי ה- API שלהם.

בואו נגיד שאנחנו לא רוצים להכניס ספר ללא מחיר תקף. אנו יכולים למנף אימות סכמות כדי להשיג זאת:

@Validation ("{price: {$ gt: 0}}") ספר בכיתה ציבורית {// ... @Property ("price") עלות כפולה פרטית; // ...}

יש מערכת אימות עשירה שמספקת MongoDB שניתן להעסיק כאן.

8. חלופות ODM חלופיות של MongoDB

מורפיה היא לא ה- ODM היחיד של MongoDB עבור Java. ישנם כמה אחרים שאנו יכולים לשקול להשתמש בהם ביישומים שלנו. דיון בנושא השוואה עם מורפיה אינו אפשרי כאן, אך תמיד כדאי לדעת את האפשרויות שלנו:

• נתוני אביב: מספק מודל תכנות מבוסס אביב לעבודה עם MongoDB
• MongoJack: מספק מיפוי ישיר מאובייקטים JSON ל- MongoDB

זו לא רשימה מלאה של ODMs של MongoDB עבור Java, אך ישנם חלופות מעניינות זמינות!

9. מסקנה

במאמר זה הבנו את הפרטים הבסיסיים של MongoDB ואת השימוש ב- ODM לחיבור ולפעול ב- MongoDB משפת תכנות כמו Java. עוד חקרנו את מורפיה כ- ODM של MongoDB עבור Java ואת היכולות השונות שיש לה.

כמו תמיד, ניתן למצוא את הקוד ב- GitHub.