Bevezetés a Morphia - Java ODM-be a MongoDB-hez

1. Áttekintés

Ebben az oktatóanyagban megértjük, hogyan kell használni a Morphia-t, egy Object Document Mappert (ODM) a Java MongoDB-hez.

Ennek során megértjük azt is, hogy mi az ODM, és hogyan segíti elő a MongoDB-vel való munkát.

2. Mi az a ODM?

Az ezen a területen avatatlanok számára A MongoDB egy dokumentum-orientált adatbázis, amelyet a természet terjesztésére építenek. A dokumentumorientált adatbázisok egyszerűen fogalmazva kezelik a dokumentumokat, amelyek nem mások a félig strukturált adatok séma nélküli rendezése. A NoSQL adatbázisok szélesebb és lazábban meghatározott esernyőjébe tartoznak, amelyeket az SQL adatbázisok hagyományos szervezésétől való látszólagos eltávozásukról neveztek el.

A MongoDB biztosítja illesztőprogramok szinte minden népszerű programozási nyelvhez, például a Java-hoz. Ezek az illesztőprogramok absztrakciós réteget kínálnak a MongoDB-vel való együttműködéshez, így nem közvetlenül a Wire Protokollal dolgozunk. Gondoljon erre úgy, hogy az Oracle biztosítja a JDBC illesztőprogram megvalósítását a relációs adatbázisukhoz.

Ha azonban felidézzük a JDBC-vel való együttműködés napjainkat, értékelhetjük, hogy milyen rendetlen lehet - főleg egy objektumorientált paradigmában. Szerencsére olyan Object Relational Mapping (ORM) keretrendszerekkel rendelkezünk, mint a Hibernate. A MongoDB esetében ez nem nagyon különbözik.

Bár minden bizonnyal együtt dolgozhatunk az alacsony szintű illesztőprogrammal, a feladat végrehajtásához sokkal több kazánra van szükség. Itt van az ORM-hez hasonló koncepció, az Object Document Mapper (ODM). Morphia pontosan kitölti ezt a helyet a Java programozási nyelv számára, és a MongoDB Java illesztőprogramjának tetején működik.

3. Függőségek beállítása

Elég elméletet láttunk ahhoz, hogy valamilyen kódba vezessenek minket. Példaként meg fogunk modellezni egy könyvtárt, és megtudhatjuk, hogyan kezelhetjük azt a MongoDB-ben a Morphia segítségével.

De mielőtt nekilátnánk, fel kell állítanunk néhány függőséget.

3.1. MongoDB

Szükségünk van egy futó MongoDB példányra, amellyel együtt dolgozhatunk. Ennek többféle módja van, a legegyszerűbb pedig a közösségi kiadás letöltése és telepítése a helyi gépünkre.

Az alapértelmezett konfigurációkat a jelenlegi állapotunkban kell hagynunk, beleértve azt a portot is, amelyen a MongoDB fut.

3.2. Morfin

A Morphia számára előre elkészített JAR-okat letölthetjük a Maven Central-ból, és felhasználhatjuk őket Java projektünkben.

A legegyszerűbb módszer azonban egy olyan függőségkezelő eszköz használata, mint a Maven:

 dev.morphia.morphia mag 1.5.3 

4. Hogyan lehet kapcsolatba lépni a Morphia használatával?

Most, hogy telepítettük és futtattuk a MongoDB-t, és beállítottuk a Morphia-t Java projektünkben, készen állunk a Morphia használatával csatlakozni a MongoDB-hez.

Lássuk, hogyan tudjuk ezt megvalósítani:

Morphia morphia = új Morphia (); morphia.mapPackage ("com.baeldung.morphia"); Datastore datastore = morphia.createDatastore (új MongoClient (), "könyvtár"); datastore.ensureIndexes ();

Nagyjából ennyi! Értsük meg ezt jobban. Két dologra van szükségünk a térképészeti műveletek működéséhez:

  1. Mapper: Ez a felelős Java POJOink feltérképezése a MongoDB gyűjteményekhez. A fenti kódrészletben: Morfin az osztály felelős ezért. Ne feledje, hogyan konfiguráljuk a csomagot, ahol POJOinkat kell keresnie.
  2. A kapcsolat: Ez a kapcsolat egy MongoDB adatbázissal, amelyen a leképező különböző műveleteket hajthat végre. Osztály Datastore paraméterként veszi a példányát MongoClient (a Java MongoDB illesztőprogramból) és a MongoDB adatbázis neve, aktív kapcsolat visszaadása a munkához.

Tehát mindannyian készen állunk ennek használatára Datastore és működjön együtt entitásainkkal.

5. Hogyan kell dolgozni az entitásokkal?

Mielőtt használhatnánk a frissen vert pénzünket Datastore, meg kell határoznunk néhány tartományi entitást, amelyekkel együtt dolgozhatunk.

5.1. Egyszerű entitás

Kezdjük egy egyszerű meghatározásával Könyv entitás néhány attribútummal:

@Entity ("Könyvek") public class Book {@Id private String isbn; privát húr cím; magánhúr-szerző; @Tulajdon ("ár") magán kettős költség; // konstruktorok, getterek, beállítók és hashCode, egyenlő, toString implementációk}

Itt van néhány érdekes dolog:

  • Figyelje meg az annotációt @Entitás amely minősíti ezt a POJO-t ODM-leképezésre írta Morphia
  • A Morphia alapértelmezés szerint az entitást a MongoDB-ben lévő gyűjteményhez hozzárendeli osztályának nevével, de ezt kifejezetten felülírhatjuk (mint ahogyan ezt tettük az entitásnál is) Könyv itt)
  • A Morphia alapértelmezés szerint egy entitás változóit a MongoDB gyűjtemény kulcsaihoz kapcsolja a változó nevével, de ezt ismét felülírhatjuk (mint ahogy a változó esetében is tettük) költség itt)
  • Végül meg kell jelöljön meg egy változót az entitásban, hogy elsődleges kulcsként működjön a @ feljegyzésselId (mintha ISBN-t használnánk itt a könyvünkhöz)

5.2. Kapcsolatokkal rendelkező entitások

A való világban azonban az entitások aligha olyan egyszerűek, mint amilyennek látszanak, és összetett kapcsolatban állnak egymással. Például egyszerű entitásunk Könyv lehet egy Kiadó és hivatkozhat más kísérőkönyvekre. Hogyan modellezzük őket?

MongoDB ajánlatok két mechanizmus a kapcsolatok kiépítésére - hivatkozás és beágyazás. Ahogy a neve is sugallja, hivatkozással a MongoDB a kapcsolódó adatokat külön dokumentumként tárolja ugyanabban vagy egy másik gyűjteményben, és csak az azonosítójával hivatkozik rá.

Éppen ellenkezőleg, a beágyazással a MongoDB tárolja vagy inkább beágyazza a kapcsolatot magában a szülő dokumentumban.

Lássuk, hogyan tudjuk felhasználni őket. Kezdjük a beágyazással Kiadó miénkben Könyv:

@ Beágyazott magánkiadói kiadó;

Elég egyszerű. Most folytassuk, és adjunk hozzá hivatkozásokat más könyvekre:

@ Referencia privát lista kísérőkönyvek;

Ez az - Morphia kényelmes jegyzeteket kínál a kapcsolatok modellezéséhez, a MongoDB támogatásával. A választás a beágyazáshoz való hivatkozásnak azonban az adatmodell bonyolultságából, redundanciájából és konzisztenciájából kell származnia egyéb szempontok mellett.

A gyakorlat hasonló a relációs adatbázisok normalizálásához.

Most készen állunk néhány művelet végrehajtására Könyv felhasználásával Datastore.

6. Néhány alapművelet

Nézzük meg, hogyan kell működni néhány alapvető művelettel a Morphia használatával.

6.1. Mentés

Kezdjük a legegyszerűbb műveletekkel, létrehozva egy példányt Könyv a MongoDB adatbázisunkban könyvtár:

Publisher publisher = új Publisher (új ObjectId (), "Félelmetes Publisher"); Könyvkönyv = new Book ("9781565927186", "Learning Java", "Tom Kirkman", 3,95, kiadó); Könyvtárs = új könyv ("9789332575103", "Java Performance Companion", "Tom Kirkman", 1,95, kiadó); book.addCompanionBooks (kísérőkönyv); datastore.save (kísérőkönyv); datastore.save (könyv);

Ez elég ahhoz, hogy Morphia létrehozhasson egy gyűjteményt a MongoDB adatbázisunkban, ha még nem létezik, és elvégezzen egy felfutási műveletet.

6.2. Lekérdezés

Lássuk, képesek vagyunk-e lekérdezni a most létrehozott könyvet a MongoDB-ben:

Könyvek listája = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .find () .toList (); assertEquals (1, books.size ()); assertEquals (könyv, könyvek.get (0));

A morfiai dokumentum lekérdezése azzal kezdődik, hogy egy lekérdezést hoz létre Datastore majd deklaratívan hozzáadva a szűrőket, a funkcionális programozásban szerelmesek örömére!

A Morphia sokkal összetettebb lekérdezés-összeállítást támogat szűrőkkel és operátorokkal. Ezenkívül a Morphia lehetővé teszi az eredmények korlátozását, kihagyását és sorrendjét a lekérdezésben.

Mi több, a Morphia lehetővé teszi számunkra, hogy a Java-illesztőprogrammal írt nyers lekérdezéseket használjuk a MongoDB-hez a további ellenőrzéshez, ha erre szükség van.

6.3. Frissítés

Bár egy mentési művelet képes kezelni a frissítéseket, ha az elsődleges kulcs megegyezik, a Morphia lehetőséget kínál a dokumentumok szelektív frissítésére:

Lekérdezés = datastore.createQuery (Book.class) .field ("title") .contains ("Java tanulás"); UpdateOperations updates = datastore.createUpdateOperations (Book.class) .inc ("ár", 1); datastore.update (lekérdezés, frissítések); Könyvek listája = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .find () .toList (); assertEquals (4,95, books.get (0) .getCost ());

Itt egy lekérdezést és egy frissítési műveletet építünk, hogy eggyel növeljük a lekérdezés által visszaadott összes könyv árát.

6.4. Töröl

Végül a létrejöttet törölni kell! Ismét Morphiával ez nagyon intuitív:

Lekérdezés = datastore.createQuery (Book.class) .field ("title") .contains ("Java tanulás"); datastore.delete (lekérdezés); Könyvek listája = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .find () .toList (); assertEquals (0, könyvek.méret ());

A lekérdezést hasonlóan hozzuk létre, mint korábban, és futtatjuk a törlési műveletet a Datastore.

7. Haladó használat

A MongoDB rendelkezik néhány fejlett művelet, például összesítés, indexelés és még sok más. Noha mindezt nem lehet Morphia használatával végrehajtani, ebből bizonyos is biztosan megvalósítható. Mások számára sajnos vissza kell térnünk a MongoDB Java illesztőprogramjához.

Koncentráljunk néhány ilyen speciális műveletre, amelyeket Morphián keresztül hajthatunk végre.

7.1. Összesítés

A MongoDB összesítése lehetővé teszi számunkra, hogy meghatározzuk a folyamatban lévő műveletsorozat, amely dokumentumok halmazán működhet és összesített kimenetet képes előállítani.

A Morphia rendelkezik API-val, amely támogatja az ilyen összesítési folyamatot.

Tegyük fel, hogy könyvtári adatainkat úgy szeretnénk összesíteni, hogy az összes könyvet szerzőjük csoportosítsa:

Iterátor iterátor = datastore.createAggregation (Könyv.osztály) .csoport ("szerző", csoportosítás ("könyvek", nyomás ("cím"))) .out (Szerző.osztály);

Szóval, hogy működik ez? Először egy aggregációs csővezeték létrehozásával kezdjük ugyanazt a régit felhasználva Datastore. Meg kell adnunk azt az entitást, amelyen összesítési műveleteket szeretnénk végrehajtani, például Könyv itt.

Ezután a dokumentumokat „szerző” szerint szeretnénk csoportosítani, és a „címüket” egy „könyvek” nevű kulcs alatt összesíteni. Végül itt egy ODM-mel dolgozunk. Tehát meg kell határoznunk egy entitást az összesített adatok összegyűjtésére - esetünkben ez az Szerző.

Természetesen meg kell határoznunk az úgynevezett entitást Szerző a könyvek nevű változóval:

@Entity public class Author {@Id private String név; magánlista könyvek; // egyéb szükséges getterek és beállítók}

Ez természetesen csak megkarcolja a MongoDB által biztosított nagyon erős konstrukció felületét, és további részletekért felfedezhető.

7.2. Kivetítés

A MongoDB-ben való vetítés lehetővé teszi számunkra, hogy csak azokat a mezőket válassza ki, amelyeket lekérdezéseink dokumentumaiból be akarunk tölteni. Abban az esetben, ha a dokumentum szerkezete összetett és nehéz, ez valóban hasznos lehet, ha csak néhány mezőre van szükségünk.

Tegyük fel, hogy csak a címükkel rendelkező könyveket kell lekérnünk lekérdezésünkben:

Könyvek felsorolása = datastore.createQuery (Book.class) .field ("title") .contains ("Learning Java") .project ("title", true) .find () .toList (); assertEquals ("Java tanulása", books.get (0) .getTitle ()); assertNull (books.get (0) .getAuthor ());

Itt, mint láthatjuk, csak a címet kapjuk vissza eredményünkben, a szerzőt és más mezőket nem. Viszont körültekintően kell eljárnunk a kivetített kimenet felhasználásával a MongoDB-re történő mentéskor. Ez adatvesztést okozhat!

7.3. Indexelés

Az indexek nagyon fontos szerepet játszanak a lekérdezések optimalizálásában az adatbázisokkal - relációs és sok nem relációs adatbázissal is.

MongoDB indexeket határoz meg a gyűjtemény szintjén, az alapértelmezett elsődleges kulcson létrehozott egyedi indexekkel. Ezenkívül a MongoDB lehetővé teszi indexek létrehozását a dokumentum bármely mezőjén vagy részterületén. Az index létrehozását a kulcson kell választanunk, a létrehozni kívánt lekérdezéstől függően.

Például a példánkban érdemes létrehozni egy indexet a (z) címe mezőben Könyv mivel gyakran kérdezünk rá:

@Indexes ({@Index (mezők = @Field ("cím"), opciók = @IndexOptions (név = "könyv_cím"))}}) public class Book {// ... @Property private String title; // ...}

Természetesen átadhatunk további indexelési lehetőségeket a létrehozott index árnyalatainak testreszabására. Ne feledje, hogy a mezőt @ -gal kell jelölniIngatlan indexben használható.

Sőt, az osztályszintű indexen kívül, Morphiának van annotációja egy mezőszintű index meghatározására is.

7.4. Séma érvényesítése

Van lehetőségünk biztosítani az adatellenőrzési szabályok egy olyan gyűjteményhez, amelyet a MongoDB használhat egy frissítési vagy beillesztési művelet végrehajtása közben. Morphia ezt támogatja az API-jukon keresztül.

Tegyük fel, hogy nem akarunk érvényes ár nélkül könyvet behelyezni. Ennek eléréséhez felhasználhatjuk a séma érvényesítését:

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

A MongoDB által rendelkezésre bocsátott validációk gazdag sorozata alkalmazható itt.

8. Alternatív MongoDB ODM-ek

A Morphia nem az egyetlen elérhető Java MongoDB ODM. Számos más alkalmazható az alkalmazásunkban. A Morphiával való összehasonlításról itt nem lehet megbeszélést folytatni, de mindig hasznos ismerni a lehetőségeinket:

  • Spring Data: Tavaszi alapú programozási modellt biztosít a MongoDB-vel való együttműködéshez
  • MongoJack: Közvetlen leképezést biztosít a JSON-tól a MongoDB objektumokig

Ez nem teljes a MongoDB ODM-ek Java-hoz listája, de vannak érdekes alternatívák!

9. Következtetés

Ebben a cikkben megértettük a MongoDB alapvető részleteit és egy ODM használatát a MongoDB csatlakoztatásához és működtetéséhez olyan programozási nyelvből, mint a Java. Tovább kutattuk Morphiát, mint a Java MongoDB ODM-jét és a benne rejlő különféle lehetőségeket.

Mint mindig, a kód megtalálható a GitHubon.