racavedigger.com
Daily insights on Bitcoin and crypto markets
  • Facebook
  • Pinterest
  • Home
  • News

האם MongoDB תומך ב- Java

Νίσα

תחילת העבודה עם MongoDB ו- Java – הדרכה לתפעול CRUD

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

סיכום

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

נקודות מפתח:

  1. התמיכה ב- MongoDB בג’אווה כוללת מגוון רחב של תכונות.
  2. האביב מספק תמיכה בתצורה עבור MongoDB באמצעות שיעורי @Configuration מבוססי Java או מרחב שמות XML.
  3. כיתת Mongotemplate היא כלי עזר מועיל לביצוע פעולות MongoDB נפוצות ומיפוי אובייקטים בין מסמכים לפוג’ו.
  4. תרגום חריג להיררכיה של גישה לנתונים ניידים של האביב נתמך.
  5. שירות ההמרה של האביב משתלב עם מיפוי האובייקטים העשיר בתכונות של MongoDB.
  6. מטא נתונים של מיפוי מבוסס ביאור זמינים וניתן להרחיב אותם כדי לתמוך בפורמטים אחרים.
  7. תמיכה באירועי מחזור החיים של התמדה ומיפוי.
  8. שאילתה, קריטריונים ועדכונים מבוססי Java ניתנים.
  9. יישום אוטומטי של ממשקי מאגר נתמך, כולל שיטות Finder מותאמות אישית.
  10. שילוב Querydsl מאפשר שאילתות בטוחות מסוג.
  11. נתמכת התמדה חוצה חנות, ומאפשרת להתמיד/לאחזר ישויות JPA באמצעות MongoDB.
  12. מפייס יומן Log4J מסופק לשילוב MongoDB.
  13. אינטגרציה גיאוגרפית זמינה לעבודה עם נתונים גיאוגרפיים.

שאלות:

  1. ש 1: אילו תכונות תמיכה ב- MongoDB בג’אווה?
  2. A1: תמיכה ב- MongoDB בג’אווה כוללת מגוון רחב של תכונות, כגון תמיכה בתצורת האביב, מיפוי אובייקטים, תרגום חריגים ועוד.

  3. Q2: כיצד נוכל להגדיר את התצורה של MongoDB באביב?
  4. A2: ניתן להגדיר את MongoDB באביב באמצעות שיעורי @Configuration מבוססי Java או מרחב שמות XML.

  5. Q3: למה המשמש כיתת המונגוט?
  6. A3: מחלקת Mongotemplate היא מחלקת עוזרים המגדילה את הפרודוקטיביות על ידי ביצוע פעולות מונגודב נפוצות ומתן מיפוי אובייקטים בין מסמכים לפוג’ו.

  7. Q4: כיצד האביב מטפל בחריגים בפעולות MongoDB?
  8. A4: האביב מתרגם חריגים להיררכיה של גישה לנתונים ניידים.

  9. ש 5: האם שילוב MongoDB עם מיפוי אובייקטים של תמיכה באביב?
  10. A5: כן, שילוב MongoDB עם האביב כולל מיפוי אובייקטים עשירים בתכונות משולב בשירות ההמרה של האביב.

  11. Q6: יכול MongoDB לתמוך בפורמטים אחרים של מטא נתונים?
  12. A6: כן, ניתן להרחיב את מטא נתונים של מיפוי מבוסס ההערה ב- MongoDB כדי לתמוך בפורמטים של מטא נתונים אחרים.

  13. ש 7: האם MongoDB תומך בהתמדה ובמיפוי אירועי מחזור חיים?
  14. A7: כן, MongoDB תומך באירועי התמדה ומיפוי מחזור חיים.

  15. ש 8: מה היתרון בשימוש בשאילתה, קריטריונים מבוססי Java ועדכון DSLs ב- MongoDB?
  16. A8: שאילתה, קריטריונים ועדכוני DSL מבוססי Java מספקים דרך בטוחה יותר ונוחה לבנות שאילתות ולעדכן פעולות ב- MongoDB.

  17. Q9: יכול לקפוץ באופן אוטומטי ליישם שיטות Finder מותאמות אישית בממשקי מאגר?
  18. A9: כן, האביב יכול ליישם אוטומטית שיטות FINDER מותאמות אישית בממשקי מאגר.

  19. Q10: מה היתרון של שילוב Querydsl ב- MongoDB?
  20. A10: שילוב Querydsl ב- MongoDB מאפשר שאילתות בטוחות מסוג.

  21. Q11: האם ניתן להשתמש ב- MongoDB להתמדה בחנות חוצה?
  22. A11: כן, MongoDB תומך בהתמדה חוצה חנות, ומאפשר להתמיד/לאחזר ישויות JPA באמצעות MongoDB.

  23. Q12: האם MongoDB מספק?
  24. A12: כן, MongoDB מספקת Log4J Appender לשילוב עם log4j.

  25. Q13: האם MongoDB תומך בנתונים גיאוגרפיים?
  26. A13: כן, MongoDB מספק אינטגרציה לעבודה עם נתונים גיאוגרפיים.

מתחילים

כדי להתחיל עם תמיכה באביב mongodb, תצטרך mongodb 1.4 ומעלה וג’אווה SE 5 ומעלה. מומלץ להשתמש במהדורת ההפקה האחרונה (2.0.x נכון לכתיבת שורות אלה).

בצע את הצעדים הבאים להגדרת סביבת עבודה:

  1. הגדר שרת MongoDB פועל. עיין במדריך ההתחלה המהירה של MongoDB לקבלת הוראות כיצד להתחיל מופע mongoDB.
  2. צור פרויקט מבוסס אביב ב- STS (Spring Tool Suite) או כל סביבת פיתוח משולבת אחרת (IDE).
  3. כלול את תלות ה- MongoDB של נתוני האביב ב- POM של הפרויקט שלך.קובץ XML:
  4.         <תלות>
                <קבוצה>אורג.SpringFramework.נתונים</GroupId>
                <Artifactid>Spring-Data-Mongodb</artifactid>
                <גִרְסָה>1.1.0.לְשַׁחְרֵר</גִרְסָה>
            </תלות>
        
  5. וודא שיש לך את הגרסה הנכונה של האביב שצוין ב- POM שלך.XML:
  6.         <נכסים>
                <אביב.גִרְסָה>3.1.2.לְשַׁחְרֵר</אביב.גִרְסָה>
            </נכסים>
        
  7. הוסף את מאגר אבן הדרך באביב לפום שלך.XML:
  8.         <מאגרים>
                <מאגר>
                    <תְעוּדַת זֶהוּת>אביב-מילסטון</תְעוּדַת זֶהוּת>
                    <שֵׁם>מאגר אבן הדרך של אביב אביב</שֵׁם>
                    <כתובת אתר>http: // repo.Springsource.org/libs-milestone</url>
                </מאגר>
            </מאגרים>
        
  9. הגדר את רמת הרישום של Log4J לניפוי באגים ב- Log4J.קובץ מאפיינים:
  10.         log4j.קטגוריה.אורג.SpringFramework.נתונים.מסמך.mongodb = ניפוי באגים
            log4j.מפעיל.סטדאוט.מַעֲרָך.PartingPattern = %d %5p %40.40C:%4L -%m%n
        
  11. צור שיעור אדם פשוט כדי להתמיד:
  12.         חבילה אורג.אביב.מונגודב.דוגמא;
            איש מעמד ציבורי {
                מזהה מחרוזת פרטי;
                שם מחרוזת פרטי;
                גיל פרטי;
                אדם ציבורי (שם מחרוזת, גיל int) {
                    זֶה.שם = שם;
                    זֶה.גיל = גיל;
                }
                מחרוזת ציבורית getId () {
                    החזרה מזהה;
                }
                מחרוזת ציבורית getName () {
                    שם החזרה;
                }
                getage int ציבורי () {
                    גיל החזרה;
                }
                @Override
                מחרוזת ציבורית ToString () {
                    החזר "אדם [id =" + id + ", name =" + name + ", gees =" + gees + "]";
                }
            }
        
  13. צור יישום ראשי להפעלה:
  14.         חבילה אורג.אביב.מונגודב.דוגמא;
            יבוא אורג 'סטטי.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.קריטריונים.איפה;
            יבוא אורגני.אפאצ'י.Commons.כניסה.עֵץ;
            יבוא אורגני.אפאצ'י.Commons.כניסה.LogFactory;
            יבוא אורגני.SpringFramework.נתונים.מונגודב.הליבה.Mongooperations;
            יבוא אורגני.SpringFramework.נתונים.מונגודב.הליבה.Mongotemplate;
            יבוא אורגני.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.שאילתא;
            יבוא com.מונגודב.מונגו;
            כיתה ציבורית mongoapp {
                יומן סופי סטטי פרטי = logfactory.GetLog (MongoApp.מעמד);
                עיקרי ריק סטטי ציבורי (מחרוזת [] args) זורקת חריג {
                    Mongooperations mongoops = Mongotemplate חדש (Mongo () חדש, "מסד נתונים");
                    מונגולים.הכנס (אדם חדש ("ג'ו", 34));
                    עֵץ.מידע (Mongoops.FindOne (שאילתה חדשה (איפה ("שם").הוא ("ג'ו"), אדם.מעמד));
                }
            }
        

תחילת העבודה עם MongoDB ו- Java – הדרכה לתפעול CRUD

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

האם MongoDB תומך ב- Java

התמיכה ב- MongoDB מכילה מגוון רחב של תכונות המסוכמות להלן.

  • תמיכה בתצורת האביב באמצעות שיעורי @Configuration מבוססי Java או מרחב שמות XML עבור מופע מנהל התקן של Mongo ומערכות העתק
  • מחלקת עוזר Mongotemplate המגדילה את הפרודוקטיביות בביצוע פעולות מונגו נפוצות. כולל מיפוי אובייקטים משולב בין מסמכים לפוג’ו.
  • תרגום חריג להיררכיית הגישה לנתונים הניידים של האביב
  • תכונות מיפוי אובייקטים עשירים משולבים בשירות ההמרה של ספרינג
  • מטא נתונים מיפוי מבוסס ביאור אך ניתן להרחבה לתמוך בפורמטים של מטא נתונים אחרים
  • התמדה ומיפוי אירועי מחזור חיים
  • שאילתה מבוססת Java, קריטריונים ועדכון DSLS
  • יישום אוטומטי של ממשקי מאגר כולל תמיכה בשיטות Finder מותאמות אישית.
  • שילוב Querydsl לתמיכה בשאילתות בטוחות מסוג.
  • התמדה חוצה חנות – תמיכה בגורמי JPA עם שדות נמשכה/הוחזרו בשקיפות באמצעות mongoDB
  • Log4J Log Appender
  • שילוב גיאוגרפי

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

5.אני מתחיל

תמיכה באביב mongodb דורשת mongodb 1.4 ומעלה וג’אווה SE 5 ומעלה. המהדורה האחרונה של ההפקה (2.0.x נכון לכתיבת שורות אלה) מומלץ. דרך קלה להגדרת סביבת עבודה היא ליצור פרויקט מבוסס אביב ב- STS.

ראשית עליך להגדיר שרת MongoDB פועל. עיין במדריך ההתחלה המהירה של MongoDB לקבלת הסבר כיצד להפעיל מופע mongodb. ברגע שהותקן מתחיל mongodb הוא בדרך כלל עניין של ביצוע הפקודה הבאה: mongo_home/bin/mongod

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

ואז הוסף את הדברים הבאים לפום.פרק תלות XML.

    אורג.SpringFramework.נתונים Spring-Data-Mongodb 1.1.0.לְשַׁחְרֵר  

שנה גם את גרסת האביב ב- POM.XML להיות

 3.1.2.לְשַׁחְרֵר 

תצטרך להוסיף את המיקום של מאגר אבן הדרך באביב עבור Maven לפום שלך.XML שנמצא באותה רמה של האלמנט שלך

   אביב-מילסטון מאגר אבן הדרך של אביב אביב http: // repo.Springsource.org/libs-milestone  

המאגר ניתן גם לדאון כאן.

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

log4j.קטגוריה.אורג.SpringFramework.נתונים.מסמך.mongodb = Debug log4J.מפעיל.סטדאוט.מַעֲרָך.PartingPattern = %d %5p %40.40C:%4L -%m%n

ליצור מעמד אדם פשוט כדי להתמיד

חֲבִילָה אורג.אביב.מונגודב.דוגמא; פּוּמְבֵּי מעמד אדם < פְּרָטִי מזהה מחרוזת; פְּרָטִי שם מחרוזת; פְּרָטִי Int גיל; פּוּמְבֵּי אדם (שם מחרוזת, Int גיל) < זֶה.שם = שם; זֶה.גיל = גיל; > פּוּמְבֵּי מחרוזת getId () < לַחֲזוֹר תְעוּדַת זֶהוּת; > פּוּמְבֵּי מחרוזת getName () < לַחֲזוֹר שֵׁם; > פּוּמְבֵּי Int getage () < לַחֲזוֹר גיל; > @Override פּוּמְבֵּי ToString מחרוזת () < לַחֲזוֹר "אדם [id hl-string"> ", שם hl-string"> ", גיל HL-String"> "]"; >>

ויישום עיקרי להפעלה

חֲבִילָה אורג.אביב.מונגודב.דוגמא; יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.קריטריונים.איפה; יְבוּא אורג.אפאצ'י.Commons.כניסה.עֵץ; יְבוּא אורג.אפאצ'י.Commons.כניסה.LogFactory; יְבוּא אורג.SpringFramework.נתונים.מונגודב.הליבה.Mongooperations; יְבוּא אורג.SpringFramework.נתונים.מונגודב.הליבה.Mongotemplate; יְבוּא אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.שאילתא; יְבוּא com.מונגודב.מונגו; פּוּמְבֵּי מעמד מונגואפ < פְּרָטִי סטָטִי סופי Log log = logfactory.GetLog (MongoApp.מעמד); פּוּמְבֵּי סטָטִי בָּטֵל ראשי (מחרוזת [] args) זורק יוצא מן הכלל < MongoOperations mongoOps = חָדָשׁ Mongotemplate (חָדָשׁ מונגו (), "מאגר מידע"); מונגולים.לְהַכנִיס(חָדָשׁ אדם("ג'ו", 34)); עֵץ.מידע (Mongoops.FindOne (חָדָשׁ שאילתה (איפה ("שֵׁם").IS ("ג'ו")), אדם.מעמד)); מונגולים.DropCollection ("אדם"); >>

זה יפיק את הפלט הבא

10: 01: 32,062 ניפוי באגים.Mongopersistententityindexcreator: 80 - ניתוח org בכיתה בכיתה.אביב.דוגמא.אדם למידע על אינדקס. 10: 01: 32,265 עבודות ניפוי באגים.נתונים.מונגודב.הליבה.Mongotemplate: 631 - הכנס dbobject המכיל שדות: [_class, גיל, שם] באיסוף: אדם 10: 01: 32,765 עבודות ניפוי באגים.נתונים.מונגודב.הליבה.Mongotemplate: 1243 - Findone באמצעות שאילתה: < "name" : "Joe">ב- DB.אוסף: מסד נתונים.אדם 10: 01: 32,953 מידע אורג.אביב.מונגודב.דוגמא.MongoApp: 25 - אדם [id = 4ddbba3c0be56b7e1b210166, שם = ג'ו, גיל = 34] 10: 01: 32,984 עבודות ניפוי באגים.נתונים.מונגודב.הליבה.Mongotemplate: 375 - אוסף נפל [מסד נתונים.אדם]

אפילו בדוגמה הפשוטה הזו, ישנם כמה דברים לשים לב אליהם

  • אתה יכול להפעיל את מחלקת העוזרים המרכזית של ספרינג מונגו, Mongotemplate, באמצעות Com הסטנדרטי.מונגודב.אובייקט מונגו ושם מסד הנתונים לשימוש.
  • Mapper פועל נגד חפצי Pojo סטנדרטיים ללא צורך במטא נתונים נוספים (אם כי באפשרותך לספק מידע זה באופן אופציונלי. ראה כאן.).
  • מוסכמות משמשות לטיפול בשדה מזהה, והמירו להיות אובייקט הוא מאוחסן בבסיס הנתונים.
  • מוסכמות מיפוי יכולות להשתמש בגישה לשדה. שימו לב שלכיתת האדם יש רק גטטרס.
  • אם שמות הארגומנט של הבנאי תואמים את שמות השדות של המסמך המאוחסן, הם ישמשו כדי להפעיל את האובייקט

5.2 דוגמאות מאגר

יש מאגר GitHub עם כמה דוגמאות שתוכלו להוריד ולהשחק איתם כדי לקבל תחושה של האופן שבו הספרייה עובדת.

5.3 מתחברים ל- MongoDB עם האביב

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

למי שלא מכיר כיצד להגדיר את מיכל הקפיץ באמצעות מטא נתונים שעועית מבוססת Java במקום מטא נתונים מבוססי XML ראה את ההקדמה ברמה הגבוהה במסמכי ההתייחסות כאן כמו גם את התיעוד המפורט כאן.

5.3.1 רישום מופע של מונגו באמצעות מטא נתונים מבוססי Java

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

דוגמא 5.1. רישום com.מונגודב.אובייקט מונגו באמצעות מטא נתונים שעועית מבוססת Java

@תְצוּרָה פּוּמְבֵּי מעמד AppConfig < / * * השתמש בממשק ה- API של Driver Mongo כדי ליצור com.מונגודב.מופע מונגו. */ פּוּמְבֵּי @אפונה מונגו מונגו () זורק לא ידוע hostexception < לַחֲזוֹר חָדָשׁ מונגו ("מארח מקומי"); >>

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

אלטרנטיבה היא לרשום מופע של com.מונגודב.מופע מונגו עם המכולה באמצעות MongoFactoryBean של האביב . בהשוואה להפעלת COM.מונגודב.מופע של מונגו ישירות, גישת המפעל אינה זורקת חריג מסומן ויש לה את היתרון הנוסף בכך שהיא מספקת גם למכולה יישום חריג של טרנסלטור המתרגם חריגים של MongoDB לחריגים בהיררכיה הניידת של DataCessexception לשיעורי גישה לנתונים המועברים עם הערה @Repository. היררכיה ושימוש זה ב- @repository מתוארים בתכונות התמיכה של DAO של האביב.

דוגמה למטא נתונים שעועית מבוססת Java התומכת בתרגום חריג בכיתות @Repository Classated מוצגת להלן:

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

@תְצוּרָה פּוּמְבֵּי מעמד AppConfig < / * * שעועית מפעל שיוצרת את ה- com.מונגודב.מופע מונגו */ פּוּמְבֵּי @אפונה Mongofactorybean mongo () < MongoFactoryBean mongo = חָדָשׁ Mongofactorybean (); מונגו.sethost ("מארח מקומי"); לַחֲזוֹר מונגו; >>

כדי לגשת ל- COM.מונגודב.אובייקט Mongo שנוצר על ידי MongoFactoryBean ב- @Configuration אחר או בשיעורים משלך, השתמש בשדה “פרטי @Autowired Mongo Mongo;”.

5.3.2 רישום מופע של מונגו באמצעות מטא נתונים מבוססי XML

אמנם אתה יכול להשתמש במרחב השמות המסורתי של האביב כדי לרשום מופע של com.מונגודב.מונגו עם המכולה, ה- XML ​​יכול להיות די מילולי מכיוון שהוא מטרה כללית. מרחבי שמות XML הם אלטרנטיבה טובה יותר להגדרת תצורה של אובייקטים נפוצים כמו מופע Mongo. מרחב השמות של מונגו מאפשר לך ליצור מיקום שרת מופע של מונגו, ערכות העתק ואפשרויות.

כדי להשתמש באלמנטים של מרחב השמות של מונגו תצטרך להתייחס לסכימת המונגו:

דוגמא 5.3. סכימת XML להגדרת תצורה של MongoDB

  XMLNS="http: // www.SpringFramework.org/סכימה/שעועית " XMLNS: XSI="http: // www.W3.org/2001/xmlschema-instance " XMLNS: הקשר="http: // www.SpringFramework.org/schema/context " XMLNS: מונגו="http: // www.SpringFramework.org/schema/data/mongo " XSI: Schemalocation= "http: // www.SpringFramework.org/schema/context http: // www.SpringFramework.org/schema/context/spring-context-3.0.XSD http: // www.SpringFramework.org/schema/data/mongo http: // www.SpringFramework.org/סכמה/נתונים/מונגו/ספרינג-מונגו -1.0.XSD http: // www.SpringFramework.org/schema/שעועית http: // www.SpringFramework.org/סכמה/שעועית/שעועית אביב -3.0.xsd ">   

להלן תצורה מתקדמת יותר עם mongooptions מוצגת להלן (שימו לב אלה אינם ערכים מומלצים)

דוגמא 5.4. סכימת XML להגדרת תצורה של COM.מונגודב.אובייקט מונגו עם mongooptions

  מנחה="מארח מקומי" נמל="27017">  חיבורים למארח="8" חוטים המאושרים לחסימה לחיבור-חיבור="4" Connect-TimeOut="1000" זמן מקסימום="1500>" Retry-Connect-Retry="נָכוֹן" שקע-שמירה-חי="נָכוֹן" זמן שקע="1500" עבד-אוק="נָכוֹן" מספר כתיבה="1" זמן כתיבה="0" כתיבת כתיבה="נָכוֹן"/>   

תצורה באמצעות ערכות העתק מוצגת להלן.

דוגמא 5.5. סכימת XML להגדרת COM.מונגודב.אובייקט מונגו עם ערכות העתק

 תְעוּדַת זֶהוּת="ReplicasetMongo" מערך העתק="127.0.0.1: 27017, Localhost: 27018 "/> 

5.3.3 ממשק mongodbfactory

ואילו com.מונגודב.Mongo הוא נקודת הכניסה לממשק ה- API של מנהל התקן MongoDB, המתחבר למופע מסד נתונים MongoDB ספציפי דורש מידע נוסף כגון שם מסד הנתונים ושם משתמש וסיסמא אופציונלי. עם מידע זה אתה יכול להשיג com.מונגודב.DB אובייקט וגישה לכל הפונקציונליות של מופע מסד נתונים של MongoDB ספציפי. האביב מספק את האורג.SpringFramework.נתונים.מונגודב.הליבה.ממשק mongodbfactory המוצג להלן לקישוריות רצועת אתחול למסד הנתונים.

פּוּמְבֵּי מִמְשָׁק Mongodbfactory < DB getDb() זורק DataAccessException; Db getdb (מחרוזת dbname) זורק DataAccessException; >

החלקים הבאים מראים כיצד תוכלו להשתמש ב- Contiainer עם Java או במטא נתונים מבוססי XML כדי להגדיר מופע של ממשק mongodbfactory. בתורו, אתה יכול להשתמש במופע mongodbfactory כדי להגדיר את Mongotemplate.

אורג הכיתה.SpringFramework.נתונים.מונגודב.הליבה.SimpleMongoDbFactory מספק מיישמים את הממשק mongodbfactory ונוצר עם com סטנדרטי.מונגודב.מופע של מונגו, שם בסיס הנתונים וארגון אופציונלי.SpringFramework.נתונים.אימות.טיעון קונסטרוקטור של userCredententials.

במקום להשתמש במיכל ה- IOC כדי ליצור מופע של Mongotemplate, אתה יכול פשוט להשתמש בהם בקוד Java רגיל כמוצג להלן.

פּוּמְבֵּי מעמד מונגואפ < פְּרָטִי סטָטִי סופי Log log = logfactory.GetLog (MongoApp.מעמד); פּוּמְבֵּי סטָטִי בָּטֵל ראשי (מחרוזת [] args) זורק יוצא מן הכלל < MongoOperations mongoOps = חָדָשׁ Mongotemplate (SimpleMongoDbfactory חדש (Mongo () חדש, "מסד נתונים")); מונגולים.לְהַכנִיס(חָדָשׁ אדם("ג'ו", 34)); עֵץ.מידע (Mongoops.FindOne (חָדָשׁ שאילתה (איפה ("שֵׁם").IS ("ג'ו")), אדם.מעמד)); מונגולים.DropCollection ("אדם"); >>

הקוד ב- Bold מדגיש את השימוש ב- SimpleMongoDbFactory והוא ההבדל היחיד בין הרישום המוצג בסעיף התחלה.

5.3.4 רישום מופע mongodbfactory באמצעות מטא נתונים מבוססי Java

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

@תְצוּרָה פּוּמְבֵּי מעמד תצורה מונגוקונטית < פּוּמְבֵּי @אפונה Mongodbfactory mongodbfactory () זורק יוצא מן הכלל < לַחֲזוֹר חָדָשׁ SimpleMongoDbFactory (חָדָשׁ מונגו (), "מאגר מידע"); >>

כדי להגדיר את שם המשתמש והסיסמה צור מופע של org.SpringFramework.נתונים.אימות.CredCredententials ומעבירים אותו לבנאי כמוצג להלן. רישום זה מציג גם באמצעות MongoDbFactory Regice מופע של mongotemplate עם המכולה.

@תְצוּרָה פּוּמְבֵּי מעמד תצורה מונגוקונטית < פּוּמְבֵּי @אפונה Mongodbfactory mongodbfactory () זורק יוצא מן הכלל < UserCredentials userCredentials = חָדָשׁ CredCredententials ("ג'ו", "סוֹד"); לַחֲזוֹר חָדָשׁ SimpleMongoDbFactory (חָדָשׁ מונגו (), "מאגר מידע", userCredententials); > פּוּמְבֵּי @אפונה Mongotemplate mongotemplate () זורק יוצא מן הכלל < לַחֲזוֹר חָדָשׁ Mongotemplate (mongodbfactory ()); >>

5.3.5 רישום מופע mongodbfactory באמצעות מטא נתונים מבוססי XML

מרחב השמות של Mongo מספק דרך נוחה ליצור SimpleMongoDbFactory בהשוואה לשימוש במרחב השמות. שימוש פשוט מוצג להלן

 DBName="מאגר מידע">

בדוגמה לעיל com.מונגודב.מופע Mongo נוצר באמצעות מארח ברירת המחדל ומספר היציאה. ה- SimpleMongoDbFactory הרשומה במכולה מזוהה על ידי המזהה ‘mongodbfactory’ אלא אם כן צוין ערך עבור תכונת המזהה.

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

 תְעוּדַת זֶהוּת="אחר של מונגודב -פקטורי" מנחה="מארח מקומי" נמל="27017" DBName="מאגר מידע" שם משתמש="ג'ו" סיסמה="סוֹד"/>

אם אתה צריך להגדיר אפשרויות נוספות ב- COM.מונגודב.מופע Mongo המשמש ליצירת SimpleMongoDbFactory באפשרותך להתייחס לשעועית קיימת באמצעות תכונה של Mongo-Ref כמוצג להלן. כדי להציג דפוס שימוש נפוץ נוסף, רישום זה מציג שימוש במציין מיקום נכס כדי לפרמטר את התצורה ויצירת Mongotemplate .

 מקום="ClassPath:/com/myapp/mongodb/config/mongo.נכסים"/>  מנחה="$" נמל="$">  חיבורים למארח="$" חוטים המאושרים לחסימה לחיבור-חיבור="$" Connect-TimeOut="$" זמן מקסימום="$" Retry-Connect-Retry="$" שקע-שמירה-חי="$" זמן שקע="$" עבד-אוק="$" מספר כתיבה="1" זמן כתיבה="0" כתיבת כתיבה="נָכוֹן"/>   DBName="מאגר מידע" מונגו-ריפ="מונגו"/>  תְעוּדַת זֶהוּת="עוד דגמה של המונגוט" מעמד="אורג.SpringFramework.נתונים.מונגודב.הליבה.Mongotemplate ">  שֵׁם="mongodbfactory" Ref="mongodbfactory"/> 

5.4 מבוא ל- Mongotemplate

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

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

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

הכיתה Mongotemplate מיישמת את משחקי הממשק . ככל האפשר, השיטות בנושא Mongooperations נקראות על שם שיטות הזמינות באובייקט אוסף הנהגים של MongoDB כמו להפוך את ה- API המוכר למפתחי MongoDB הקיימים שרגילים לממשק ה- API של הנהג. לדוגמה, תמצאו שיטות כמו “Find”, “findandModify”, “FindOne”, “הכנס”, “הסר”, “שמור”, “עדכון” ו- “updateMulti”. מטרת העיצוב הייתה להקל ככל האפשר לעבור בין השימוש בנהג ה- MongoDB הבסיס לבין mongooperations . ההבדל העיקרי בין שני ה- API הוא שניתן להעביר חפצי דומיין למגורים במקום dbobject וישנם ממשקי API שוטפים לשאילתה, קריטריונים, ולעדכן פעולות במקום לאכלס dbobject כדי לציין את הפרמטרים עבור אותם אופרים.

הדרך המועדפת להתייחס לפעולות במופע Mongotemplate היא באמצעות Mongooperations הממשק שלה .

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

במהדורת M2 SimpleMappingConverter, היה ברירת המחדל וכיתה זו מיושמת כעת מכיוון שהפונקציונליות שלו הוטבעה על ידי MongomappingConverter.

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

אמנם ישנן שיטות נוחות רבות ב- Mongotemplate שיעזרו לך לבצע בקלות משימות נפוצות אם עליך לגשת ישירות לממשק ה- API של Driver Driver כדי לגשת לפונקציונליות שלא נחשפת במפורש על ידי המונגוטמנט, אתה יכול להשתמש באחת מכמה שיטות התקשרות חוזרות לגישה לבסיס APIS הבסיסית לממשקי הנהג. ההפעלה חוזרת ייתן לך התייחסות לשני COM.מונגודב.אוסף או com.מונגודב.אובייקט DB. אנא עיין בסעיף התקשרות חוזרות למידע נוסף.

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

5.4. מיידי את Mongotemplate

אתה יכול להשתמש ב- Java כדי ליצור ולרשום מופע של mongotemplate כמוצג להלן.

דוגמא 5.6. רישום com.מונגודב.אובייקט Mongo ומאפשר תמיכה בתרגום החריג של האביב

@תְצוּרָה פּוּמְבֵּי מעמד AppConfig < פּוּמְבֵּי @אפונה מונגו מונגו () זורק יוצא מן הכלל < לַחֲזוֹר חָדָשׁ מונגו ("מארח מקומי"); > פּוּמְבֵּי @אפונה Mongotemplate mongotemplate () זורק יוצא מן הכלל < לַחֲזוֹר חָדָשׁ Mongotemplate (mongo (), "mydatabase"); >>

ישנם כמה קונסטרוקטורים עמוסים מדי של Mongotemplate. אלו הם

  • Mongotemplate (Mongo Mongo, String DatabaseName) – לוקח את ה- com.מונגודב.אובייקט Mongo ושם מסד הנתונים המוגדר כברירת מחדל לפעול נגד.
  • Mongotemplate (Mongo Mongo, String DatabaseName, UserCredententials UserCredentials) – מוסיף את שם המשתמש והסיסמה לאמותה עם בסיס הנתונים.
  • Mongotemplate (Mongodbfactory mongodbfactory) – לוקח אובייקט mongodbfactory שעטף את ה- com.מונגודב.אובייקט מונגו, שם מסד נתונים ושם משתמש וסיסמה.
  • Mongotemplate (Mongodbfactory mongodbfactory, mongoconverter mongoconverter) – מוסיף mongoconverter לשימוש למיפוי.

אתה יכול גם להגדיר תצורה של Mongotemplate באמצעות סכימת ה- XML ​​של האביב.

"מארח מקומי" יציאה ="27017"/> "Mongotemplate" מעמד="אורג.SpringFramework.נתונים.מונגודב.הליבה.Mongotemplate "> "מונגו"/> "databasename" ערך ="גיאוגרפיה"/> 

מאפיינים אופציונליים אחרים שאולי תרצה להגדיר בעת יצירת Mongotemplate הם ברירת המחדל של כותבי המוצא, WriteConcern ו- ReadPreference .

הדרך המועדפת להתייחס לפעולות במופע Mongotemplate היא באמצעות Mongooperations הממשק שלה .

מדיניות בדיקת סופרים

כאשר בפיתוח זה מאוד שימושי לרשום או לזרוק חריג אם ה- COM.מונגודב.Writeresult שהוחזר מכל פעולה של mongoDB מכיל שגיאה. זה די מקובל לשכוח לעשות זאת במהלך הפיתוח ואז בסופו של דבר עם אפליקציה שנראית כאילו היא פועלת בהצלחה, אך למעשה מסד הנתונים לא שונה על פי הציפיות שלך. הגדר את המאפיין של סופרי Mongotemplate לנקוט את המאפיין ל- Enum עם הערכים הבאים, היומן, החריג, או אף אחד. ברירת המחדל היא להשתמש בערך סופר -קולצ’ק של אף אחד.

WriteConcern

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

WriteConcernresolver

למקרים מתקדמים יותר שבהם ברצונך להגדיר ערכי WriteConcern שונים על בסיס להפעלה (להסרה, עדכון, הכנס ושמירה של פעולות), ניתן להגדיר ממשק אסטרטגיה הנקרא WriteConcernresolver על mongotemplate . מכיוון ש- Mongotemplate משמש להתמיד בפוג’וס, WriteConcernresolver מאפשר לך ליצור מדיניות שיכולה למפות מחלקת פוג’ו ספציפית לערך כותב. ממשק WriteConcernResolver מוצג להלן.

פּוּמְבֵּי מִמְשָׁק WriteConcernresolver

הוויכוח שהועבר, MongoAction, הוא מה שאתה משתמש בו כדי לקבוע את הערך WriteConcern שישמש או להשתמש בערך של התבנית עצמה כברירת מחדל. MongoAction מכיל את שם האוסף שנכתב אליו, ה- Java.לאנג.Class of the Pojo, ה- dbobject המומר, כמו גם הפעולה כמינוי (MongoActionOperation: הסר, עדכן, הכנס, insert_list, שמור) ועוד כמה פיסות מידע קונטקסטואלי אחרות. לדוגמה,

כיתה פרטית myappwriteconcernresolver מיישמת את WriteConcernresolver < public WriteConcern resolve(MongoAction action) < if (action.getEntityClass().getSimpleName().contains("Audit")) < return WriteConcern.NONE; >אחרת אם (פעולה.GetentityClass ().getSimplename ().מכיל ("מטא נתונים")) < return WriteConcern.JOURNAL_SAFE; >החזר פעולה.getDefaultWriteConcern (); >>

5.5 שמירת, עדכון והסרת מסמכים

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

ניתנת כיתה פשוטה כמו אדם

פּוּמְבֵּי מעמד אדם < פְּרָטִי מזהה מחרוזת; פְּרָטִי שם מחרוזת; פְּרָטִי Int גיל; פּוּמְבֵּי אדם (שם מחרוזת, Int גיל) < זֶה.שם = שם; זֶה.גיל = גיל; > פּוּמְבֵּי מחרוזת getId () < לַחֲזוֹר תְעוּדַת זֶהוּת; > פּוּמְבֵּי מחרוזת getName () < לַחֲזוֹר שֵׁם; > פּוּמְבֵּי Int getage () < לַחֲזוֹר גיל; > @Override פּוּמְבֵּי ToString מחרוזת () < לַחֲזוֹר "אדם [id hl-string"> ", שם hl-string"> ", גיל HL-String"> "]"; >>

אתה יכול לשמור, לעדכן ולמחוק את האובייקט כמוצג להלן.

Mongooperations הוא הממשק שמונגוטמטים מיישמים.

חֲבִילָה אורג.אביב.דוגמא; יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.קריטריונים.איפה; יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.עדכון.עדכון; יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.שאילתא.שאילתא; יְבוּא ג'אווה.שימוש.רשימה; יְבוּא אורג.אפאצ'י.Commons.כניסה.עֵץ; יְבוּא אורג.אפאצ'י.Commons.כניסה.LogFactory; יְבוּא אורג.SpringFramework.נתונים.מונגודב.הליבה.Mongooperations; יְבוּא אורג.SpringFramework.נתונים.מונגודב.הליבה.Mongotemplate; יְבוּא אורג.SpringFramework.נתונים.מונגודב.הליבה.SimpleMongoDbFactory; יְבוּא com.מונגודב.מונגו; פּוּמְבֵּי מעמד מונגואפ < פְּרָטִי סטָטִי סופי Log log = logfactory.GetLog (MongoApp.מעמד); פּוּמְבֵּי סטָטִי בָּטֵל ראשי (מחרוזת [] args) זורק יוצא מן הכלל < MongoOperations mongoOps = חָדָשׁ Mongotemplate (חָדָשׁ SimpleMongoDbFactory (חָדָשׁ מונגו (), "מאגר מידע")); אדם p = חָדָשׁ אדם("ג'ו", 34); // הכנס משמש לאחסון האובייקט בתחילה למסד הנתונים. מונגולים.הכנס (p); עֵץ.מידע ("הכנס:" + P); // למצוא p = mongoops.Findbyid (עמ '.getid (), אדם.מעמד); עֵץ.מידע ("מצאתי: " + P); // עדכון מונגולים.updatefirst (שאילתה (איפה (("שֵׁם").IS ("ג'ו")), עדכון("גיל", 35), אדם.מעמד); p = mongoops.FindOne (שאילתה (איפה ("שֵׁם").IS ("ג'ו")), אדם.מעמד); עֵץ.מידע ("עודכן:" + P); // מחק מונגולים.הסר (p); // בדוק שמחיקה עבדה רשימת אנשים = mongoops.FindAll (אדם.מעמד); עֵץ.מידע ("מספר האנשים =:" + אֲנָשִׁים.גודל()); מונגולים.DropCollection (אדם.מעמד); >>

זה יפיק את פלט היומן הבא (כולל הודעות באגים מ- Mongotemplate עצמו)

ניפוי באגים.Mongopersistententityindexcreator: 80 - ניתוח org בכיתה בכיתה.אביב.דוגמא.אדם למידע על אינדקס. עבודת באגים.נתונים.מונגודב.הליבה.Mongotemplate: 632 - הכנס שדות המכילים Dbobject: [_class, גיל, שם] באיסוף: מידע על אדם אורג.אביב.דוגמא.MongoApp: 30 - הכנס: אדם [ID = 4DDC6E784CE5B1EBA3CEAF5C, שם = ג'ו, גיל = 34] עבודת באגים.נתונים.מונגודב.הליבה.Mongotemplate: 1246 - Findone באמצעות שאילתה: < "_id" : < "$oid" : "4ddc6e784ce5b1eba3ceaf5c">> ב- DB.אוסף: מסד נתונים.מידע על אדם אורג.אביב.דוגמא.MongoApp: 34 - נמצא: אדם [ID = 4DDC6E784CE5B1EBA3CEAF5C, שם = ג'ו, גיל = 34] עבודת באגים.נתונים.מונגודב.הליבה.Mongotemplate: 778 - עדכון שיחות באמצעות שאילתה: < "name" : "Joe">ועדכון: < "$set" : < "age" : 35>> בגבייה: עבודת באגים באדם.נתונים.מונגודב.הליבה.Mongotemplate: 1246 - Findone באמצעות שאילתה: < "name" : "Joe">ב- DB.אוסף: מסד נתונים.מידע על אדם אורג.אביב.דוגמא.MongoApp: 39 - מעודכן: אדם [id = 4ddc6e784ce5b1eba3ceaf5c, name = joe, age = 35] עבודת באגים.נתונים.מונגודב.הליבה.Mongotemplate: 823 - הסר באמצעות שאילתה: < "id" : "4ddc6e784ce5b1eba3ceaf5c">באוסף: מידע על אדם.אביב.דוגמא.MongoApp: 46 - מספר האנשים =: 0 עבודת באגים.נתונים.מונגודב.הליבה.Mongotemplate: 376 - אוסף נפל [מסד נתונים.אדם]

הייתה המרה מרומזת באמצעות MongoConverter בין מחרוזת ל- ObjectID כפי שמאוחסנת בבסיס הנתונים והכרת מוסכמה של שם המאפיין “מזהה”.

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

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

5.5.1 כיצד מטפלים בשדה ‘_ID’ בשכבת המיפוי

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

להלן מתאר איזה נכס ימפה לשדה המסמך ‘_ID’:

  • נכס או שדה המוצג באמצעות @ID (org.SpringFramework.נתונים.ביאור.ID) ימפה לשדה ‘_ID’.
  • נכס או שדה ללא הערה אך מזהה שנקרא ימופה לשדה ‘_ID’.

להלן מתאר איזה סוג המרה, אם בכלל, תיעשה על הנכס הממופה לשדה המסמך _ID בעת השימוש ב- MappingMongoConverter, ברירת המחדל עבור mongotemplate .

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

אם לא נוכחים שדה או נכס שצוינו לעיל בכיתת Java, אז ייוצר קובץ ‘_ID’ מרומז על ידי הנהג אך לא ימפה לנכס או שדה של כיתת Java.

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

5.5.2 מיפוי סוג

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

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

דוגמא 5.7. הקלד מיפוי

פּוּמְבֵּי מעמד לִטעוֹם < Contact value; >פּוּמְבֵּי תַקצִיר מעמד איש קשר < … >פּוּמְבֵּי מעמד אדם משתרע איש קשר < … >לדוגמא מדגם = חָדָשׁ לִטעוֹם(); לִטעוֹם.ערך = חָדָשׁ אדם(); Mongotemplate.שמור (לדוגמא); < "_מעמד" : "com.שִׂיא.לִטעוֹם", "ערך" : < "_מעמד" : "com.שִׂיא.אדם" >>

כפי שאתה יכול לראות אנו מאחסנים את המידע מסוג עבור מחלקת השורשים בפועל, כמו גם עבור הסוג המקונן שכן הוא מורכב ותת -סוג של קשר . אז אם אתה משתמש עכשיו ב- mongotemplate.FindAll (אובייקט.כיתה, “דוגמה”) אנו יכולים לגלות שהמסמך המאוחסן יהיה מופע מדגם. אנו יכולים גם לגלות כי נכס הערך יהיה אדם בפועל.

התאמה אישית של מיפוי סוג

במקרה שתרצה להימנע מכתיבת כל שם הכיתה של Java כמידע סוג, אלא תרצה להשתמש במפתח כלשהו אתה יכול להשתמש בהערה @TypeAlias ​​בשיעור הישות שנמשך. אם אתה צריך להתאים אישית את המיפוי עוד יותר עיין בממשק TypeInformationMapper. ניתן להגדיר מופע של ממשק זה ב- DefaultMongotyPemapper אותו ניתן להגדיר בתורו ב- MappingMongoConverter .

5.5.3 שיטות לחיסכון והכנסת מסמכים

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

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

המקרה הפשוט של שימוש בפעולת השמירה הוא לשמור פוג’ו. במקרה זה שם האוסף ייקבע בשם (לא מוסמך במלואו) של הכיתה. אתה יכול גם להתקשר לפעולת השמירה עם שם אוסף ספציפי. האוסף לאחסון האובייקט יכול להיות מוגזם באמצעות מיפוי מטא נתונים.

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

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

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

יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.קריטריונים.איפה; יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.קריטריונים.שאילתא; ... אדם p = חָדָשׁ אדם("בוב", 33); Mongotemplate.הכנס (p); אדם qp = mongotemplate.FindOne (שאילתה (איפה ("גיל").IS (33)), אדם.מעמד);

פעולות הכנס/שמירה העומדות לרשותך מופיעות להלן.

  • בָּטֵל להציל (אובייקט אובייקט TOSAVE) שמור את האובייקט באוסף ברירת המחדל.
  • בָּטֵל להציל (אובייקט ObjectTosave, String CollectionName) שמור את האובייקט לאוסף שצוין.

קבוצה דומה של פעולות הכניסה מופיעה להלן

  • בָּטֵל לְהַכנִיס (אובייקט אובייקט TOSAVE) הכנס את האובייקט לאוסף ברירת המחדל.
  • בָּטֵל לְהַכנִיס (Object ObjectTosave, String CollectionName) הכנס את האובייקט לאוסף שצוין.

לאיזה אוסף ישמרו המסמכים שלי?

ישנן שתי דרכים לנהל את שם האיסוף המשמש להפעלה במסמכים. שם אוסף ברירת המחדל המשמש הוא שם הכיתה שהשתנה כדי להתחיל עם אותיות נמוכה יותר. אז com.מִבְחָן.כיתת אדם הייתה מאוחסנת באוסף “האדם”. אתה יכול להתאים אישית זאת על ידי מתן שם איסוף אחר באמצעות ביאור @document. אתה יכול גם לעקוף את שם האוסף על ידי מתן שם אוסף משלך כפרמטר האחרון לשיחות Mongotemplate שנבחרו.

הכנסת או שמירת אובייקטים בודדים

מנהל ההתקן MongoDB תומך בהכנסת אוסף של מסמכים לפעולה אחת. השיטות בממשק Mongooperations התומכות בפונקציונליות זו מופיעות להלן

  • לְהַכנִיס הכנס חפץ. אם יש מסמך קיים עם אותו מזהה, נוצרת שגיאה.
  • הכנס לוקח אוסף של חפצים כפרמטר הראשון. שיטה זו מציינת כל אובייקט ומכניסה אותו לאוסף המתאים על סמך הכללים שצוינו לעיל.
  • להציל שמור את האובייקט באמצעות כתיבת כל אובייקט שעשוי להתקיים עם אותו מזהה.

הכנסת מספר חפצים לאצווה

מנהל ההתקן MongoDB תומך בהכנסת אוסף של מסמכים לפעולה אחת. השיטות בממשק Mongooperations התומכות בפונקציונליות זו מופיעות להלן

  • לְהַכנִיס שיטות שלוקחות אוסף כטיעון הראשון. זה מכניס רשימה של אובייקטים באצווה אחת כותבת למסד הנתונים.

5.5.4 עדכון מסמכים באוסף

לקבלת עדכונים אנו יכולים לבחור לעדכן את המסמך הראשון שנמצא בשיטה של ​​Mongooperation UpdateFirst או שנוכל לעדכן את כל המסמכים שנמצאו תואמים את השאילתה בשיטה עדכון . להלן דוגמה לעדכון של כל חשבונות החיסכון בו אנו מוסיפים $ 50 $.00 בונוס ליתרה באמצעות מפעיל $ INC.

דוגמא 5.9. עדכון מסמכים באמצעות Mongotemplate

יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.קריטריונים.איפה; יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.שאילתא; יְבוּא סטָטִי אורג.SpringFramework.נתונים.מונגודב.הליבה.שאילתא.עדכון; . WRITESULT WR = Mongotemplate.UpdateMulti (חָדָשׁ שאילתה (איפה ("חשבונות.סוג החשבון").הוא (חשבון.סוּג.חיסכון)), חָדָשׁ עדכון().INC ("חשבונות.$.איזון", 50.00), חשבון.מעמד);

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

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

שיטות לביצוע עדכונים למסמכים

  • UpdateFirst מעדכן את המסמך הראשון התואם את קריטריוני מסמך השאילתה עם המסמך המעודכן שסופק.
  • UpdateMulti מעדכן את כל האובייקטים התואמים את קריטריוני מסמך השאילתה עם המסמך המעודכן שסופק.

תחילת העבודה עם MongoDB ו- Java – הדרכה לתפעול CRUD

רישום מנהל ההתקן של MongoDB Java מופעל כעת באמצעות ממשק ה- API הפופולרי של SLF4J אז הוספתי Logback ב- POM.XML וכניסה לקבצי תצורה.XML .

מבוא

תג ג'אווה

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

בפוסטים עתידיים בבלוג, נעבור ונעבוד:

עסקאות חומצה מרובת-דוקטורטים.

נהג הזרמים המגיבים של Java Mongodb.

למה מונגודב וג’אווה?

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

תנאים מוקדמים

כדי לעקוב אחריה, אתה יכול להשתמש בכל סביבה שאתה אוהב ובסביבת הפיתוח המשולבת לבחירתך. אני אשתמש ב- Maven 3.6.2 ו- Java OpenJDK 13, אך כל הקוד יתאים לגרסאות Java 8 עד 13, אז אל תהסס להשתמש ב- JDK לבחירתך ולעדכן את גרסת ה- Java בהתאם לפום.קובץ XML אנו עומדים להגדיר.

עבור אשכול MongoDB, אנו נשתמש באשכול MongoDB של Tier Tier Free מ- MongoDB Atlas . אם אין לך כבר אחד, בדוק את התחלתי עם פוסט בלוג אשכול M0.

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

בואו נקפוץ פנימה ונסתכל על כמה טוב ג’אווה ומונגוד עובדים יחד.

מתקין

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

באמצעות מאגר GIT

אם תבחר להשתמש ב- GIT, תקבל את כל הקוד מייד. אני עדיין ממליץ לך לקרוא את ההתקנה הידנית.

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

או שתוכל להוריד את המאגר כקובץ מיקוד .

הגדרת ידנית

אתה יכול להשתמש ב- IDE המועדף עליך כדי ליצור עבורך פרויקט Maven חדש או שאתה יכול ליצור את פרויקט Maven באופן ידני. כך או כך, עליכם לקבל את ארכיטקטורת התיקיות הבאה:

הפום.קובץ XML אמור להכיל את הקוד הבא:

כדי לוודא שהכל עובד נכון, אתה אמור להיות מסוגל ליצור ולהפעיל “שלום mongodb פשוט!” תכנית. ב- SRC/Main/Java/COM/MongoDB/QuickStart, צור את Hellomongodb.קובץ Java:

לאחר מכן קח ופעל אותו עם ה- IDE שלך או השתמש בשורת הפקודה בספריית השורש (היכן שתיגת SRC נמצאת):

התוצאה צריכה להיראות כך:

הערה: אם אתה רואה כמה אזהרות מפני גישה רפלקטיבית לא חוקית מ- Guice.ג’אווה, בטוח להתעלם מהם. Guice משמש את Maven וצריך עדכון. אתה יכול לקרוא עוד על זה בגיליון Github זה . אזהרות אלה ייעלמו בשחרור עתידי של Guice and Maven.

חיבור עם Java

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

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

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

ב- SRC/Main/Java/com/mongodb, צור את החיבור.קובץ Java:

כפי שאתה יכול לראות, מחרוזת החיבור MongoDB מאוחרת מה- מאפייני מערכת , אז אנחנו צריכים להגדיר את זה. לאחר שאחזר את מחרוזת חיבור ה- MongoDB Atlas שלך, אתה יכול להוסיף את MongoDB.מאפיין מערכת URI ל- IDE שלך. הנה התצורה שלי עם IntelliJ למשל.

או אם אתה מעדיף להשתמש ב- Maven בשורת הפקודה, הנה שורת הפקודה המקבילה שתוכל להריץ בספריית השורש:

הערה: אל תשכח את הציטוטים הכפולים סביב ה- Mongodb Uri כדי למנוע הפתעות מהקליפה שלך.

הפלט הסטנדרטי צריך להיראות כך:

הכנס פעולות

מתקין

בקטע הקשר עם Java, יצרנו את הכיתות hellomongodb וחיבור . עכשיו נעבוד על כיתת היצירה.

אם לא הגדרת את האשכול החינמי שלך ב- Mongodb Atlas, עכשיו זה זמן נהדר לעשות זאת. קבל את ההוראות ליצירת האשכול שלך .

בדיקת מודל האיסוף והנתונים

במערך הנתונים לדוגמא, אתה יכול למצוא את מסד הנתונים לדוגמה_, המכיל ציוני אוסף . כל מסמך באוסף זה מייצג ציוני סטודנט לכיתה מסוימת.

הנה ייצוג JSON של מסמך במעטפת המונגו .

והנה ייצוג ה- JSON המורחב של אותו סטודנט. אתה יכול לאחזר אותו במצפן MongoDb, כלי ה- GUI החינמי שלנו, אם אתה רוצה.

JSON מורחב הוא הגרסה הקריאה האנושית של מסמך BSON ללא אובדן מידע מסוג. תוכלו לקרוא עוד על נהג ה- Java ו- BSON בתיעוד מנהל ההתקן של MongoDB Java .

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

יש לנו 10,000 סטודנטים (Student_id מ- 0 ל- 9999) כבר באוסף זה וכל אחד מהם לקח 10 שיעורים שונים, מה שמוסיף עד 100,000 מסמכים באוסף זה. בואו נגיד סטודנט חדש (Student_ID 10,000) בדיוק הגיע לאוניברסיטה זו וקיבל חבורה של ציונים (אקראיים) בכיתה הראשונה שלו. בואו נכניס מסמך סטודנט חדש זה באמצעות Java ו- MongoDB Java Driver.

באוניברסיטה זו, class_id משתנה בין 0 ל 500, כך שאוכל להשתמש בכל ערך אקראי בין 0 ל 500.

שילוב Java MongoDB: 12 ​​צעדים פשוטים

התחל עם פעולות Crud MongoDB בפייתון: 3 שלבים פשוטים צבירה של Substring MongoDB (Substr) מחבר MongoDB JavaScript (NodeJS) מפושט 101

תוכן העניינים

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

תוכן העניינים

מה זה mongodb?

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

מושגי ה- MongoDB העיקריים הם:

  • תְעוּדַת זֶהוּת: מזהה הוא שם שדה המשמש לייצוג אובייקט ייחודי ב- MongoDB. זה יכול להיווצר במפורש על ידי המשתמש או באופן מרומז על ידי שרת MongoDB.
  • אוסף: זהו דלי המאחסן קבוצה של מסמכי MongoDB. זה נופל תחת מסד נתונים בהיררכיה.
  • מאגר מידע: זוהי הרמה העליונה ביותר של ארגון הנתונים במופע MongoDB. אוספי מאגרי מסד הנתונים ומופע MongoDB יכולים להכיל מסדי נתונים רבים.
  • מסמך: הרשומות המאוחסנות באוסף MongoDB נקראות מסמכים. הם מכילים מפתחות וערכים. הערכים יכולים להיות מיתרים, מספרים שלמים, בוליאנים, תאריכים כמו גם מסמכים משובצים אחרים.
  • שדה: זה מתייחס לזוג המפתח/הערך במסמך.

לפתור את בעיות שכפול הנתונים שלך עם צינורות אוטומטיים אמינים, ללא קוד ואוטומטי עם 150+ מחברים.

מאפייני מפתח של mongodb

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

תומך בשאילתות של Adhoc

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

אינדקס

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

בסיס נתונים ללא סכמה

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

למידע נוסף על MongoDB, בקרו כאן.

מה זה ג’אווה?

ג’אווה היא שפת תכנות פופולרית ש&rsquo;s משמש בעיקר לפיתוח בצד השרת כמו גם לפיתוח אפליקציות סלולריות. בעיצובו, Java היא שפה מוכוונת אובייקטים שמשמעותה פשוט שכל הנתונים והשיטות מיוצגים כמעמדות ואובייקטים.

ניתן היה לערוך או לפרש את Java, כלומר, ניתן לבצע את התרגום של קוד ה- Java ל- ByTecode או לפורמט בינארי באמצעות מהדר או מתורגמן. מאז&rsquo;זה שפה מורכבת, זה&rsquo;s מהר מאוד בזמן ריצה וגם קל מאוד לניפוי באגים.

כמה מקרי השימוש המובילים ב- Java כוללים פיתוח:

  • יישומי אנדרואיד
  • יישומי GUI שולחניים
  • יישומי אינטרנט
  • יישומים מדעיים
  • יישומים בצד השרת הפיננסי
  • מערכות מוטמעות

מאפייני מפתח של Java

התכונות הבאות מעניקות ל- Java יתרון על שפות תכנות אחרות:

  • מונחה עצמים: שפת תכנות Java מתייחסת לכל דבר כאובייקט. זה יכול בקלות למפות תרחישים בעולם האמיתי לקוד על ידי התייחסות ישויות בודדות כאל אובייקטים.
  • פלטפורמה עצמאית: בניגוד לשפות תכנות-כמו C ו- C ++, Java אינו מורכב במכונה ספציפית לפלטפורמה. הוא מייצר קוד בתים עצמאי לפלטפורמה המופץ דרך האינטרנט ומפורש על ידי ה- Java Virtual Machine (JVM) המותקן בכל מערכת כלשהי.
  • בִּטָחוֹן: עם תכונת האבטחה של שפת התכנות של Java, היא מאפשרת לך לפתח מערכות חסינות חבלה ונטולות וירוסים. כמו כן, היא משתמשת בטכניקות אימות מבוססות קריפטוגרפיה ציבורית כדי לשמור על הקוד והנתונים שלך בטוחים.
  • נייד: Java היא שפת תכנות לא תלויה באדריכלות. אז קל להעביר קוד שנכתב בשפת תכנות Java למעבדים שונים.
  • חָסוֹן: Java היא שפת תכנות השואפת לבטל מקרים המועדים לשגיאות באמצעות בדיקת שגיאות בזמן קומפילציה ובדיקת זמן ריצה.

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

פשט את ניתוח הנתונים שלך עם צינור הנתונים של ה- HEVO

נתוני Hevo, צינור נתונים אוטומטי ללא קוד עוזר לטעון נתונים מכל מקור נתונים כגון מסדי נתונים, יישומי SaaS, אחסון ענן, SDK, S ושירותי סטרימינג ומפשט את תהליך ה- ETL. זה תומך במאה+ מקורות נתונים כמו מונגודב וטוען את הנתונים על מחסן הנתונים הרצוי, מעשיר את הנתונים והופך אותם לצורה מוכנה לניתוח מבלי לכתוב שורה אחת של קוד.

הצינור האוטומטי לחלוטין שלה מציע נתונים שיועברו בזמן אמת ללא הפסד ממקור ליעד. הארכיטקטורה הסובלנית והניתנת להרחבה שלה מבטיחה כי הנתונים מטופלים בצורה מאובטחת ועקבית עם אובדן נתונים אפס ותומך בצורות שונות של נתונים. הפתרונות הניתנים עקביים ועובדים עם כלים שונים של בינה עסקית (BI).

בדוק מדוע Hevo הוא הבסT:

  • לבטח: ל- Hevo יש ארכיטקטורה סובלנית לתקלות שמבטיחה כי הנתונים מטופלים בצורה מאובטחת ועקבית עם אפס אובדן נתונים.
  • ניהול סכימות: הוו מסיר את המשימה המייגעת של ניהול סכמות ומזהה אוטומטית את הסכימה של נתונים נכנסים וממפה אותם לסכימת היעד.
  • למידה מינימלית: HEVO, עם ממשק המשתמש הפשוט והאינטראקטיבי שלו, פשוט מאוד עבור לקוחות חדשים לעבוד עליהם ולבצע פעולות.
  • Hevo בנוי בקנה מידה: ככל שמספר המקורות ונפח הנתונים שלך גדל, HEVO מידה אופקית, ומטפלים במיליוני רשומות בדקה עם מעט מאוד חביון.
  • עומס נתונים מצטבר: HEVO מאפשר העברת נתונים ששונו בזמן אמת. זה מבטיח ניצול יעיל של רוחב הפס בשני הקצוות.
  • תמיכה בזמן אמת: צוות HEVO זמין מסביב לשעון כדי להרחיב תמיכה יוצאת דופן ללקוחותיו באמצעות שיחות צ’אט, דוא”ל ותמיכה.
  • ניטור חי: HEVO מאפשר לך לפקח על זרימת הנתונים ולבדוק היכן הנתונים שלך נמצאים בנקודת זמן מסוימת.

מהם הצעדים להגדרת שילוב Java MongoDB?

יש לקוות שעד עכשיו, רכשת הבנה בסיסית כלשהי של MongoDB ו- Java כמו גם מדוע הם&rsquo;משמש בפיתוח אפליקציות. עכשיו תן&rsquo;צלל פנימה ותסתכל על הצעדים שמשתמשים בהם אתה יכול להקים Mongodb Java שילוב:

  • שלב 1: התקן את חבילת OpenJDK
  • שלב 2: הגדר את משתנה הסביבה של java_home
  • שלב 3: התקן את MongoDB
  • שלב 4: התקן IDE או עורך
  • שלב 5: הגדר פרויקט Java חדש
  • שלב 6: התקן את ספריית הלקוחות של MongoDB Java
  • שלב 7: השתמש בספריית הלקוחות של MongoDB Java
  • שלב 8: צור אוסף mongodb
  • שלב 9: צור מסמכים
  • שלב 10: מסמכי שאילתה
  • שלב 11: עדכן מסמכים
  • שלב 12: מחק מסמכים

שלב 1: התקן את חבילת OpenJDK

לעקוב אחריה&rsquo;תחילה צריך להכין את המכונה המקומית שלך לפיתוח Java. לשם כך, עליך להתקין תחילה את חבילת OpenJDK 8 (ערכת פיתוח Java).

1) לינוקס

אם אתה&rsquo;המשך על דביאן או אובונטו, פתח את שורת הפקודה שלך והפעל את הפקודה הבאה:

$ sudo apt-get התקנה OpenJDK-8-JDK

עבור CentOS, Red Hat, Oracle, Fedora והפצות לינוקס דומות אחרות משתמשים בפקודה הבאה:

$ su -c "yum התקן java -1.8.0-openjdk-devel "

2) מקוס

אם אתה&rsquo;RE ב- MacOS השתמש בפקודה הבאה:

% Brew התקן OpenJDK@8

ואז צור קישור סמלי כך שעטיפת Java תוכל למצוא אותו:

% sudo ln -sfn/usr/local/opt/openjdk@8/libexec/openjdk.JDK/ספרייה/Java/JavavirtualMachines/OpenJDK-8.JDK 

3) חלונות

  • הורד את המתקין מבוסס MSI מקישור זה.
  • חלץ את קבצי ה- zip לתיקיה.
  • הפעל את OpenJDK 8 עבור מתקין Windows.
  • עקוב אחר ההנחיות על ההתקנה על המסך.

שלב 2: הגדר את משתנה הסביבה של java_home

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

1) לינוקס

  1. פתח את המסוף והסוג שלך:

sudo nano /etc /פרופיל

  1. ואז עבור לסוף הקובץ והסוג:

ייצוא java_home =/usr/lib/jvm/java-8-openjdk-amd64/bin/java נתיב ייצוא = $ java_home/bin: $ נתיב

  1. שמור את הקובץ והיציאה (Ctrl+O, Ctrl+x).

2) מקוס

  1. פתח את המסוף והסוג שלך:

emacs .פּרוֹפִיל

  1. ואז עבור לסוף הקובץ והסוג:

Java_home =/ספריה/Java/ייצוא בית Java_home;

  1. שמור וצא (Ctrl-X, Ctrl-S; Ctrl-X, Ctrl-C).

3) חלונות

כדי להגדיר את משתנה הסביבה במחשב Windows שלך, פתח את שורת הפקודה באמצעות הרשאות מנהל והפעל את הפקודה הבאה:

setx -m java_home "c: propra ~ 1javajdk1.8.0_xx "

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

הד %java_home %

שלב 3: התקן את MongoDB

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

1) לינוקס

  1. פתח מסוף והנפיק את הפקודה הבאה לייבא את המפתח הציבורי MongoDB ממערכת ניהול החבילות:

wget -qo - https: // www.מונגודב.org/static/pgp/server-5.0.ASC | sudo apt-key add -

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

הד "deb [arch = amd64, arm64] https: // repo.מונגודב.org/apt/אובונטו מוקד/mongodb-org/5.0 Multiverse "| sudo tee/etc/apt/מקורות.רשימה.d/mongodb-org-5.0.רשימה

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

עדכון sudo apt-get

  1. הפעל את הפקודה הבאה להתקנת MongoDB:

sudo apt-get התקנה -y mongodb-org

  1. התחל mongodb:

sudo systemctl התחל mongod

  1. ודא ש- MongoDB פועל:

sudo systemctl סטטוס mongod

MongoDB צריך לרוץ על יציאה 27017.

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

2) מקוס

  1. הוצא את הפקודה הבאה להורדת הנוסחה של Bomebrew עבור MongoDB:

Brew Tap mongodb/brew

  1. התקן את MongoDB באמצעות הפקודה הבאה:

מבשלים התקן [email protected]

  1. עבור מחשבי MacOS המריצים מעבדי אינטל, התחל את MongoDB באמצעות הפקודה הבאה:

מונגוד -קונפיג/usr/מקומי/וכו '/מונגוד.conf -fork

  1. עבור מחשבי MacOS המריצים מעבדי M1, השתמש בפקודה הבאה:

Mongod -Config/opt/Homebrew/etc/mongod.conf -fork

3) חלונות

  1. הורד את המתקין מבוסס MongoDB MSI מקישור זה.
  1. הפעל את המתקין על ידי לחיצה כפולה על .קובץ MSI.
  1. עקוב אחר ההנחיות על ההתקנה על המסך.

שלב 4: התקן IDE או עורך

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

מתחתיך&rsquo;תמצא רשימה של כמה עורכים פופולריים המשמשים לפיתוח אפליקציות Java ויתאים לך Mongodb Java שילוב:

  • אטום מאת Github
  • רעיון אינטליג ‘על ידי JetBrains
  • קוד Visual Studio מאת Microsoft
  • Eclipse על ידי קרן Eclipse

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

שלב 5: הגדר פרויקט Java חדש

באמצעות ה- IDE המועדף עליך, צור פרויקט Maven או Gradle חדש. אם אתה&rsquo;מחדש באמצעות maven, עליך לקבל את מבנה התיקיה הבא:

java-Quick-Start.xml â â â בלה â â â בלה â Â â â â â â â â â â â â â â â â ou â â â â â â ou â â â â â â ou â â â ou Quickstart 

אם אתה משתמש ב- Gradle, עליך להיות בעל מבנה התיקיה הבא:

לבנות.gradle â â &rdquo;â â â בלה â â â â â â â â בלה â â

שלב 6: התקן את ספריית הלקוחות MongoDB עבור Java

ספריית הלקוחות של MongoDB עבור Java מאפשרת לך להתחבר ולתקשר עם מופע MongoDB שלך מיישום Java.

אם אתה משתמש ב- Maven, הוסף את ספריית הלקוחות של MongoDB Java לרשימת התלות שלך ב- שלך פום.XML קוֹבֶץ.

  אורג.מונגודב MongoDB-Driver-Sync 4.4.1   

שֶׁלְךָ פום.XML כעת הקובץ צריך להיראות כך:

  4.0.0 com.מונגודב התחלת ג'אווה-מהירה 1.0-snapshot 8 8 UTF-8 4.4.1 3.10.0   אורג.מונגודב MongoDB-Driver-Sync $    אורג.אפאצ'י.Maven.תוספים Maven-Compiler-Plugin $ $ $     

אם אתה&rsquo;מחדש באמצעות Gradle, הוסף את קטע הקוד הבא שלך לִבנוֹת.גראד רשימת תלות לשילוב Java שלך ב- MongoDB:

תלות

שֶׁלְךָ לִבנוֹת.גראד הקובץ צריך להידמות לקובץ הבא:

תוספים < id 'base' >יבוא אורגני.גראד.הפצה.הורדת גרסת Gradle = '0.1 'תלות < compile 'org.mongodb:mongodb-driver-sync:4.4.1' >משימות.הרשמה ('הורדת Gradle', הורד Gradle) < description = 'Downloads the Gradle distribution with a given version.' gradleVersion = '4.6' >משימות.הרשמה ('CreateCustomGradleDlustution', zip) < description = 'Builds custom Gradle distribution and bundles initialization scripts.' dependsOn downloadGradle def projectVersion = project.version archiveFileName = downloadGradle.gradleVersion.map < gradleVersion ->"MyCompany-Gradle-$-$-bin.zip "> מ- Ziptree (הורד Gradle.DestinationFile) מ- ('src/init.D ') < into "$/init.d" > > 

שלב 7: שימוש בספריית הלקוחות של MongoDB Java

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

הוסף את הצהרות הייבוא ​​הבאות לאתחול הספרייה:

יבוא סטטי com.מונגודב.לָקוּחַ.דֶגֶם.פילטרים.Eq; יבוא אורגני.BSON.מסמך; יבוא com.מונגודב.לָקוּחַ.Mongoclient; יבוא com.מונגודב.לָקוּחַ.Mongoclients; יבוא com.מונגודב.לָקוּחַ.MongoCollection; יבוא com.מונגודב.לָקוּחַ.Mongodatabase;

שלב 8: צור אוסף mongodb

עם זה מהדרך, זה&rsquo;עכשיו הזמן שהאינטגרציה שלך ב- MongoDB Java מקיימת אינטראקציה עם מסד הנתונים. לתת&rsquo;התחלתי תחילה ביצירת אוסף. אתה יכול ליצור אוסף mongoDB על ידי ציון מסד הנתונים של היעד באמצעות getDatabase () שיטה ואז קריאת CreateCollection () שיטה של com.מונגודב.לָקוּחַ.Mongodatabase מִמְשָׁק. שיטה זו מקבלת ערך מחרוזת מילולית עם שם האוסף. אם בסיס הנתונים אינו קיים, MongoDB ייצר אותו באופן מרומז.

קטע הקוד הבא יוצר אוסף במסד נתונים של MongoDB:

יבוא ג'אווה.שימוש.מערכים; יבוא אורגני.BSON.מסמך; יבוא אורגני.BSON.סוגים.ObjectID; יבוא com.מונגודב.Mongoexception; יבוא com.מונגודב.לָקוּחַ.Mongoclient; יבוא com.מונגודב.לָקוּחַ.Mongoclients; יבוא com.מונגודב.לָקוּחַ.MongoCollection; יבוא com.מונגודב.לָקוּחַ.Mongodatabase; יבוא com.מונגודב.לָקוּחַ.תוֹצָאָה.Insertoneresult; CreateCollection מעמד ציבורי < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; // Create a MongoDB Client MongoClient mongoClient = MongoClients.create(uri)); // Create a MongoDB database MongoDatabase database = mongoClient.getDatabase("usersDB"); // Create a MongoDB Collection MongoCollectioncollection = database.createCollection("users"); System.out.println("Collection Created Successfully!"); > >

שלב 9: צור מסמכים

הקטע הבא משתמש ב Insertone () שיטה להכנסת מסמך למשתמש&rsquo;אוסף S שיצרת בשלב הקודם. אם מסד הנתונים או האוסף לא קיימים, MongoDB ייצרו את שניהם.

יבוא ג'אווה.שימוש.מערכים; יבוא אורגני.BSON.מסמך; יבוא אורגני.BSON.סוגים.ObjectID; יבוא com.מונגודב.Mongoexception; יבוא com.מונגודב.לָקוּחַ.Mongoclient; יבוא com.מונגודב.לָקוּחַ.Mongoclients; יבוא com.מונגודב.לָקוּחַ.MongoCollection; יבוא com.מונגודב.לָקוּחַ.Mongodatabase; יבוא com.מונגודב.לָקוּחַ.תוֹצָאָה.Insertoneresult; אינסרטון בכיתה ציבורית < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); try < InsertOneResult result = collection.insertOne(new Document() .append("_id", new ObjectId()) .append("username", "vitali@30") .append("phonenumber", 2501345876) .append("email", "[email protected]) ); System.out.println("Success! Inserted document id: " + result.getInsertedId()); >לתפוס (MongoException ME) < System.err.println("Unable to insert due to an error: " + me); >>>> 

ניתן גם להכניס מסמכים מרובים לאוסף באחד על ידי קריאתו Insertmany () שיטה. כדי להכניס מסמכים מרובים, עליך להוסיף אותם לרשימה ולהעביר את הרשימה כמערך. קטע הקוד הבא ממחיש כיצד תוכל להשתמש ב Insertmany () שיטה להשגת זאת.

יבוא ג'אווה.שימוש.מערכים; יבוא ג'אווה.שימוש.רשימה; יבוא אורגני.BSON.מסמך; יבוא com.מונגודב.Mongoexception; יבוא com.מונגודב.לָקוּחַ.Mongoclient; יבוא com.מונגודב.לָקוּחַ.Mongoclients; יבוא com.מונגודב.לָקוּחַ.MongoCollection; יבוא com.מונגודב.לָקוּחַ.Mongodatabase; יבוא com.מונגודב.לָקוּחַ.תוֹצָאָה.InsertManyresult; תוספות בכיתה ציבורית < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); List userList = Arrays.asList( new Document().append("username", "owen hart"), new Document().append("username", "jack grealish")); try < InsertManyResult result = collection.insertMany(userList); System.out.println("Inserted document ids: " + result.getInsertedIds()); >לתפוס (MongoException ME) < System.err.println("Unable to insert due to an error: " + me); >>>> 

שלב 10: מסמכי שאילתה

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

יבוא com.מונגודב.לָקוּחַ.ניתן למצוא; יבוא com.מונגודב.לָקוּחַ.MongoCollection; יבוא com.מונגודב.לָקוּחַ.Mongodatabase; יבוא ג'אווה.שימוש.איטרטור; יבוא אורגני.BSON.מסמך; יבוא com.מונגודב.Mongoclient; ממצא מעמד ציבורי < public static void main( String[] args ) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); FindIterable iterDoc = collection.find(); Iterator it = iterDoc.iterator(); while (it.hasNext()) < System.out.println(doc.it.next()); >>>> 

שלב 11: עדכן מסמכים

ניתן לבצע עדכונים במסד נתונים MongoDB באמצעות UpdateOne () שיטה של עדכונים מעמד. בדוגמה הבאה, תעדכן את הערך של מספר הטלפון ותוסיף כתובת למסמך התואם את שם המשתמש &ldquo;Vitali@30&rdquo;.

יבוא אורגני.BSON.מסמך; יבוא אורגני.BSON.המרות.BSON; יבוא com.מונגודב.Mongoexception; יבוא com.מונגודב.לָקוּחַ.Mongoclient; יבוא com.מונגודב.לָקוּחַ.Mongoclients; יבוא com.מונגודב.לָקוּחַ.MongoCollection; יבוא com.מונגודב.לָקוּחַ.Mongodatabase; יבוא com.מונגודב.לָקוּחַ.דֶגֶם.UpdationOptions; יבוא com.מונגודב.לָקוּחַ.דֶגֶם.עדכונים; יבוא com.מונגודב.לָקוּחַ.תוֹצָאָה.UpdaterSult; UpdateOne בכיתה ציבורית < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); Document query = new Document().append("username", "vitali@30"); Bson updates = Updates.combine( Updates.set("phonenumber", 010154257), Updates.addToSet("address", "666, 5th Avenue, NYC")); UpdateOptions options = new UpdateOptions().upsert(true); try < UpdateResult result = collection.updateOne(query, updates, options); System.out.println("Modified document count: " + result.getModifiedCount()); System.out.println("Upserted id: " + result.getUpsertedId()); // only contains a value when an upsert is performed >לתפוס (MongoException ME) < System.err.println("Unable to update due to an error: " + me); >>>> 

שלב 12: מחק מסמכים

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

קטע הקוד הבא ימחק משתמש אחד באמצעות Eq () סנן כדי לזהות משתמש ספציפי עם שם המשתמש &ldquo;Vitali@30&rdquo; משילוב Java שלך ב- MongoDB:

יבוא סטטי com.מונגודב.לָקוּחַ.דֶגֶם.פילטרים.Eq; יבוא אורגני.BSON.מסמך; יבוא אורגני.BSON.המרות.BSON; יבוא com.מונגודב.Mongoexception; יבוא com.מונגודב.לָקוּחַ.Mongoclient; יבוא com.מונגודב.לָקוּחַ.Mongoclients; יבוא com.מונגודב.לָקוּחַ.MongoCollection; יבוא com.מונגודב.לָקוּחַ.Mongodatabase; יבוא com.מונגודב.לָקוּחַ.תוֹצָאָה.מחירים; DeleteOne בכיתה ציבורית < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); Bson query = eq("username", "vitali@30"); try < DeleteResult result = collection.deleteOne(query); System.out.println("Deleted document count: " + result.getDeletedCount()); >לתפוס (MongoException ME) < System.err.println("Unable to delete due to an error: " + me); >>>> 

זֶה&rsquo;זה! עכשיו אתה יכול להגדיר משלך Mongodb Java שילוב.

סיכום

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

MongoDB הוא כלי נהדר לאחסון הנתונים העסקיים שלך. עם זאת, לעיתים אתה צריך להעביר נתונים אלה למחסן נתונים לצורך ניתוח נוסף. בניית פיתרון פנימי לתהליך זה יכולה להיות משימה יקרה וגוזלת זמן. לעומת זאת, נתוני HEVO מציעים צינור נתונים ללא קוד שיכולים להפוך את תהליך העברת הנתונים שלך לאוטומטי, ומכאן לאפשר לך להתמקד בהיבטים אחרים של העסק שלך כמו ניתוח, ניהול לקוחות וכו ‘. פלטפורמה זו מאפשרת לך להעביר נתונים מ- 100+ מקורות כמו מונגודב למחסני נתונים מבוססי ענן כמו פתית שלג, Google Bigquery, Amazon Redshift וכו ‘. זה יספק לך חוויה נטולת טרחה ויקל על חיי העבודה שלך הרבה יותר.

רוצה לקחת את הוו לסיבוב? הירשם לניסיון חינם בן 14 יום וחווה את סוויטת Hevo העשרה בתכונות ממקור ראשון.

שתף את דעותיך על Mongodb Java שילוב בסעיף התגובות!

עסקאות Java MongoDB: יצירה, ניהול וזרימות עבודה מפושטות | מדריך 101

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

תוכן העניינים

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

תוכן העניינים

  1. תנאים מוקדמים
  2. מה זה mongodb?
  3. איך לרוץ mongodb עם Java?
  4. מהי עסקת mongodb?
  5. יצירת עסקאות Java MongoDB
  6. ניהול עסקאות Java MongoDB
  7. זרימת עבודה של עסקאות Java MongoDB
  8. סיכום

תנאים מוקדמים

הבנה בסיסית של מסדי נתונים.

מה זה mongodb?

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

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

MongoDB פועל על מערכות הפעלה סטנדרטיות, Windows, Linux, MacOS והענן. מהדורת MongoDB הפועלת במערכת ההפעלה היא שרת הקהילה MongoDB, והתקנת MongoDB בענן נקראת MongoDB Atlas.

איך לרוץ mongodb עם Java?

התקנת Java במערכת שלך וסביבת הפיתוח המשולבת המועדפת עליך (IDE) מוכנה. כדי להגדיר ג’אווה ו- MongoDB, ראשית, עליך להשיג את נהג ה- MongoDB Java. המשאבים להתקנת MongoDB ייאספו על ידי שני IDEs או ב- Gradle או Maven. נהגי Java MongoDB מספקים אינטראקציה סינכרונית וגם אסינכרונית כאחד.

צעדים לקבלת נהג Java MongoDB

  1. התקן את הגרסה המתאימה של מנהל ההתקן MongoDB מאתר זה. לאחר מכן, עבור למוצרים מסמל התפריט. למצוא את ה &lsquo;נתונים ישירים&rsquo; אפשרות ולחץ עליה.

צעדים לקבלת נהג Java MongoDB

  1. תופנה לדף אינטרנט אחר בו תוכל למצוא את &lsquo;קישוריות נתונים&rsquo; אפשרות בלוח הסקירה, שמתחתיו תראה את JDBC. לחץ על זה.

צעדים לקבלת נהג Java MongoDB

  1. דף אחר ייפתח. חפש MongoDB מהרשימה ולחץ עליה כדי להמשיך הלאה.

צעדים לקבלת נהג Java MongoDB

  1. יופיע דף חדש, שם תראה את אפשרות ההורדה. לחץ עליו ואז יהיו לך שתי אפשרויות; Windows ו- Linux. לפי מערכת מערכת ההפעלה שלך, לחץ עליה כדי להוריד.

צעדים לקבלת נהג Java MongoDB

  1. עליכם למלא טופס להורדה ולחץ על הורדה.
  2. לאחר ההורדה, חלץ את הקובץ שהורדת.
  3. פתח את הקובץ שחולץ כדי להתחיל את ההתקנה. לחץ על &lsquo;הַבָּא&rsquo; להמשיך.
  4. קבל את כל התנאים וההגבלות, ואז העבר קדימה על ידי לחיצה על הבא.
  5. הערה: אל תשנה דבר בשני החלונות הקרובים. לחץ על הבא כדי להמשיך.

צעדים לקבלת נהג Java MongoDB

  1. לבסוף, תגיעו להתקנת אפשרות. לחץ עליו וההתקנה תתחיל.
  2. המתן לתהליך ההתקנה.

צעדים לקבלת נהג Java MongoDB

  1. כאשר ההתקנה הושלמה, לחץ על ביצוע כדי לסיים את ההתקנה.
  2. פתח את כונן ה- C שלך ועקוב אחר הנתיב למטה. אם אתה מוצא תיקיית JDBC, ההתקנה מצליחה.

גודל של שילוב הנתונים שלך ללא מאמץ עם HEVO&rsquo;s סובלני תקלות אין צינור נתוני קוד

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

1000+ צוותי נתונים מסתמכים על HEVO&rsquo;פלטפורמת צינור הנתונים לשילוב נתונים מיותר מ -150+ מקורות תוך מספר דקות. מיליארדי אירועי נתונים ממקורות מגוונים כמו אפליקציות SaaS, מסדי נתונים, אחסון קבצים ומקורות סטרימינג ניתן לשכפל כמעט בזמן אמת עם HEVO&rsquo;ארכיטקטורה סובלנית לתקלות. מה&rsquo;S MORE-HEVO שמה שליטה מלאה בידי צוותי נתונים עם לוחות מחוונים אינטואיטיביים לניטור צנרת, ניהול שכימה אוטומטית ולוחות זמנים של בליעה/טעינה בהתאמה אישית.

זה, בשילוב עם תמחור שקוף ותמיכה של 24 × 7, הופך אותנו לתוכנת צינור הנתונים המיוחדת ביותר באתרי ביקורת.

קח את הניסיון החינמי שלנו בן 14 יום כדי לחוות דרך טובה יותר לנהל צינורות נתונים.

מהי עסקת mongodb?

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

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

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

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

יצירת עסקאות Java MongoDB

ניתן לבצע עסקאות רק במאגרי מידע הפועלים כחלק מאשכול גדול. אשכול זה יכול להיות אשכול מסד נתונים מסודר או סט העתק. בדרך כלל, עסקאות mongoDB נכתבות ומבוצעות מיישומים חיצוניים באמצעות שיטות API. הנה אנחנו&rsquo;לי ליצור עסקה באמצעות מעטפת mongoDB.

הערה: לאחר שיטת ההתחלה הראשונית ().

להלן הצעדים להמשגת סשן עסקה מההתחלה ועד הסוף.

db.מחברים.למצוא() [ < _id: ObjectId("620397dd4b871fc65c193106"), first_name: 'James', last_name: 'Joyce', title: 'Ulysses' >, < _id: ObjectId("620398016ed0bb9e23785973"), first_name: 'William', last_name: 'Gibson', title: 'Neuromancer' >, < _id: ObjectId("6203981d6ed0bb9e23785974"), first_name: 'George', last_name: 'Orwell', title: 'Homage to Catalonia' >, < _id: ObjectId("620398516ed0bb9e23785975"), first_name: 'James', last_name: 'Baldwin', title: 'The Fire Next Time' >] 

אותו דבר עם ממשק API, אתה יוצר מושב עסקה באמצעות הקוד:

var session = db.getMongo ().התחלות ()

השלב הבא הוא להתחיל את העסקה על ידי קריאת שיטת StartTransaction (). השתמש בפקודה שלהלן:

מוֹשָׁב.StartTransaction ( < "readConcern": < "level": "snapshot" >, "WriteConcern": < "w": "majority >>) 

ישנן שתי אפשרויות לשיטת StartTransaction (): קרא דאגה וכתוב דאגה.

מערך הדאגות לקריאה מתעלם בתוך העסקה ברמת האיסוף ובמסד הנתונים. לכן עליכם לקבוע את דאגת הקריאה ברמת העסקה ב- StartTransaction (). עם זאת, ברירת המחדל של דאגת הקריאה קובעת לדאגת הקריאה ברמת ההפעלה לעסקה.

אם לא מוגדרים גם דאגת קריאה ברמת העסקה וגם את הקריאה ברמת ההפעלה, אז חששות הקריאה של ברמת הלקוח מוגדרים באופן אוטומטי. דאגת הקריאה ברמת הלקוח היא &lsquo;מְקוֹמִי&rsquo; לקריאה נגד הראשי.

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

אתה יכול להגדיר את דאגת הכתיבה ברמת העסקה ב- StartTransaction (). אם דאגת הכתיבה ברמת העסקה אינה מוגדרת, היא מחליפה את דאגת הרמה של ההפעלה עבור ההתחייבות. אם חששות כתיבה ברמת העסקה וגם ברמת ההפעלה אינם מוגדרים, הדאגה לרמת העסקה עוקבת אוטומטית לדאגה לרמת הלקוח.

ניהול עסקאות Java MongoDB

ניהול כל העסקאות יכול להיות עבודה כבדה, אך הנה כמה דרכים לניהול העסקאות. אתה יכול להוסיף תמיכה בעסקאות באמצעות נתוני אביב Java ומנהלי Java Mongo. ממשק API של הנהג עושה זאת:

נסה (פגישת לקוחות = לקוח.התחלה ()) < session.startTransaction(); try < collection.insertOne(session, documentOne); collection.insertOne(session, documentTwo); session.commitTransaction(); >לתפוס (חריג ה) < session.abortTransaction(); >> 

מפגשי הלקוח שהתקבלו מלקוח.Startsession () צריך להיות קצר מועד ומשוחרר בבת אחת כשלא נחוץ עוד. לפיכך, להבטיח לכלול את הפקודה סגורה ().

הקטע שלעיל מכיל את ההפעלה (LSID) בכל שורת פקודה. &lsquo;STARTTRANSACTION&rsquo; נשלחת עם הפקודה הראשונה המייצגת את העסקה. וכשתסיים, העסקה מתבצעת על ידי שליחה &lsquo;Cumptranscation.&rsquo;

הגרסאות הקודמות של MongoDB לא תמכו בעסקאות, ולכן החלק החיוני הוא להגדיר את התצורה של MongotransactionManager ב- ApplicationContext שלך. מנהל עסקאות הוא נקודת כניסה לתמיכה בעסקת ביאור. לתצורה, השתמש בקוד שלהלן:

@Configuration Class Config מרחיב את AbstractMongoConfiguration < @Bean MongoTransactionManager transactionManager(MongoDbFactory dbFactory) < return new MongoTransactionManager(dbFactory); >> @Service Class Documentservice < private final MongoOperations operations; DocumentService(MongoOperations operations) < this.operations = operations; >@Transactional void InsertDocuments () < operations.insert(documentOne); operations.insert(documentTwo); >> 

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

זרימת עבודה של עסקאות Java MongoDB

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

מונגודב&rsquo;לעסקאות S יש מקורות צומת כתיבה יחידה, אפילו בהקשר של שבר יחיד. מנוע האחסון שלו ופרוטוקול שכפול שלו מוחלפים למסלול לעסקאות. להלן דמות המייצגת אפליקציית מסחר אלקטרוני עם 2 לקוחות MongoDB.

כאן, לקוח 1 מבצע עסקאות, ולקוח 2 קורא רשומה שעודכנה על ידי העסקה שהופעלה על ידי הלקוח 1. לקוח 1 מכניס הזמנה חדשה לאוסף ההזמנות ומעדכן את מלאי הפריט שהוזמן (בהנחה שההזמנה נשלחת בהצלחה). כעת, דאגת הכתיבה היחידה המתאימה לעמידות נתונים גבוהה היא הרוב. הרוב פירושו רוב העתקים, אני.ה., רוב העתקים הם לבצע את השינויים לפני שהראשוני יכיר בהצלחת הכתיבה ללקוח.

העסקה תיחסם עד שלפחות משני אחד או שניים ימשכו את העדכון מהראשון באמצעות שכפול. תהליך זה הופך את MongoDB&rsquo;S עסקת חניך יחיד כותבת מעט איטית יותר מ- NOSQLs עסקיים אחרים.

סיכום

עברנו באמצעות MongoDB בג’אווה ובעסקה&rsquo;S יצירה, ניהול וזרימת עבודה. שימוש בעסקאות Java MongoDB במאגרי נתונים מבטיח כי בסיס נתונים יחזיק מצב עקבי לאחר הפעלת קבוצת פעולות.

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

נתוני Hevo, צינור נתונים ללא קוד, יכולים להעביר נתונים בצורה חלקה מים עצום של 100+ מקורות כמו MongoDB & אטלס מונגודב למחסן נתונים או יעד לבחירתך לדמיין בכלי BI. זהו שירות אמין, אוטומטי לחלוטין ומאובטח שאינו&rsquo;לא מחייב אותך לכתוב קוד כלשהו!

אם אתה משתמש MongoDB כמערכת ניהול מסדי הנתונים של NOSQL שלך וחיפוש אחר אלטרנטיבה ללא פגיעה לשילוב נתונים ידני, ואז הו יכול לאוטול את זה ללא מאמץ עבורך. HEVO, עם שילובו החזק עם 100+ מקורות וכלים BI (כולל 40+ מקורות בחינם), מאפשר לך לא רק לייצא ולהעמיס נתונים אלא גם לשנות ולהעשיר את הנתונים שלך ולהפוך אותם למוכנים לניתוח בג’יפי.

רוצה לקחת את Hevo לרכיבה? הירשם ל ניסיון חינם של 14 יום ופשט את תהליך שילוב הנתונים שלך. עיין בפרטי התמחור כדי להבין איזו תוכנית ממלאת את כל הצרכים העסקיים שלך.

ספר לנו על החוויה שלך ללמוד על עסקת Java MongoDB! שתף את המחשבות שלך איתנו בקטע התגובות למטה.

האם Moneylion עובד עם Varo? האם מונופוד עומד בפני עצמו?

Related Posts

how_to_stay_safe_on_onlyfans_5

Νίσα

OnlyFans Free Pages vs Paid: How Access Differs

onlyfans_help_center

Νίσα

Budgeting Tips and PPV Across Free OnlyFans Pages

6a0b117e02549eec1a0db52c_infographic_user_growth_bar_chart-1

Νίσα

Safe Browsing Protocols for Zero-Dollar OnlyFans Pages

banner
banner

PROMO

racavedigger.com
© racavedigger.com 2026