Útmutató a hibernált OGM-hez
1. Áttekintés
Ebben az oktatóanyagban áttekintjük a Hibernate Object / Grid Mapper (OGM) alapjait.
A hibernált OGM Java Persistence API (JPA) támogatást nyújt a NoSQL adattárolókhoz. A NoSQL egy átfogó kifejezés, amely az adattárolás sokféle változatát lefedi. Ide tartoznak például a kulcsérték, a dokumentum, az oszloporientált és a grafikonorientált adattárolók.
2. A Hibernate OGM architektúrája
A Hibernate hagyományosan egy Object Relational Mapping (ORM) motort kínál a relációs adatbázisokhoz. A hibernált OGM motor kibővíti funkcionalitását, hogy támogassa a NoSQL adattárolókat. A használat elsődleges előnye a JPA felület konzisztenciája a relációs és a NoSQL adattárolók között.
A hibernált OGM két fő interfész miatt képes számos NoSQL adattárolón keresztül absztrakciót biztosítani, DatastoreProvider és GridDialect. Ezért minden új NoSQL adattároló, amelyet támogat, ezen interfészek megvalósításával jár.
A mai napig nem támogatja az összes NoSQL adattárat, de sokukkal képes együttműködni, például az Infinispan és Ehcache (kulcsérték), a MongoDB és a CouchDB (dokumentum), valamint a Neo4j (grafikon).
Teljes mértékben támogatja a tranzakciókat és képes együttműködni a standard JTA szolgáltatókkal. Először is, ezt a Jakarta EE tárolón keresztül lehet megadni mindenféle egyértelmű konfiguráció nélkül. Sőt, a Java SE környezetben használhatunk egy önálló JTA tranzakciókezelőt, mint például a Narayana.
3. Beállítás
Ehhez az oktatóanyaghoz a Maven segítségével fogjuk felhívni a szükséges függőségeket a Hibernate OGM használatához. Használjuk a MongoDB-t is.
Hogy tisztázzuk, nézzük meg, hogyan állítsuk be őket az oktatóanyaghoz.
3.1. Maven-függőségek
Nézzük meg a Hibernate OGM és a MongoDB együttműködéséhez szükséges függőségeket:
org.hibernate.ogm hibernate-ogm-mongodb 5.4.0. Végső org.jboss.narayana.jta narayana-jta 5.9.2.Final
Itt Mavenen keresztül húzzuk meg a szükséges függőségeket:
- Hibernálja az OGM dialektust a MongoDB számára
- Narayana Transaction Manager (a JTA tényleges szolgáltatója)
3.2. Perzisztencia egység
Nekünk is muszáj lesz meghatározza az adattár részleteit a Hibernátumban kitartás.xml:
org.hibernate.ogm.jpa.HibernateOgmPersistence
Vegye figyelembe az itt megadott definíciókat:
- az attribútum tranzakciótípus értéke „JTA” (ez azt jelenti, hogy JTA entitáskezelőt szeretnénk a EntityManagerFactory)
- a szolgáltató, ami HibernateOgmPersistence a hibernált OGM számára
- néhány további részlet a DB-vel kapcsolatban (ezek általában eltérnek az egyes adatforrásoktól)
A konfiguráció feltételezi, hogy a MongoDB fut, és alapértelmezés szerint elérhető. Ha nem ez a helyzet, akkor szükség szerint mindig megadhatunk részleteket. Egyik korábbi cikkünk részletesen kitér a MongoDB beállítására is.
4. Entitásmeghatározás
Most, hogy átéltük az alapokat, definiáljunk néhány entitást. Ha korábban Hibernate ORM-mel vagy JPA-val dolgoztunk együtt, akkor ehhez már nincs mit hozzáfűzni. Ez a Hibernate OGM alapvető előfeltétele. Azt azt ígéri, hogy különböző NoSQL adattárolókkal fogunk dolgozni, csupán a JPA ismeretében.
Ehhez az oktatóanyaghoz meghatározunk egy egyszerű objektum modellt:
Meghatározza Cikk, Szerző és Szerkesztő osztályok a kapcsolataikkal együtt.
Definiáljuk őket Java-ban is:
@Entity public class Article {@Id @GeneratedValue (generator = "uuid") @GenericGenerator (name = "uuid", strategy = "uuid2") private String ArticleId; privát karakterlánc cikkTitle; @ManyToOne magánszerző szerző; // kivitelezők, alátétek és beállítók ...}
@Entity public class Author {@Id @GeneratedValue (generator = "uuid") @GenericGenerator (név = "uuid", stratégia = "uuid2") privát karakterlánc authorId; privát karakterlánc szerző neve; @ManyToOne privát szerkesztő szerkesztő; @OneToMany (mappedBy = "szerző", cascade = CascadeType.PERSIST) privát készlet authoredArticles = új HashSet (); // kivitelezők, szerelők és szerelők ...}
@Entity public class Editor {@Id @GeneratedValue (generator = "uuid") @GenericGenerator (név = "uuid", stratégia = "uuid2") privát karakterlánc-szerkesztőId; privát karakterlánc-szerkesztőNév; @OneToMany (mappedBy = "szerkesztő", kaszkád = CascadeType.PERSIST) privát halmaz kijelöltAuthors = új HashSet (); // kivitelezők, szerelők és szerelők ...}
Most meghatároztuk az entitásosztályokat, és azokat JPA szabványos megjegyzésekkel jegyeztettük:
- @Entity hogy közös parlamenti közgyűlésként létrehozzák őket
- @Id elsődleges kulcsok előállításához az UUID-vel rendelkező entitások számára
- @Egy a sokhoz és @ManyToOne kétirányú kapcsolatok kialakítása az entitások között
5. Műveletek
Most, hogy létrehoztuk az entitásainkat, nézzük meg, hogy tudunk-e valamilyen műveletet végrehajtani rajtuk. Első lépésként elő kell állítanunk néhány tesztadatot. Itt létrehozunk egy Szerkesztő, néhány Szerző, és néhány Cikk. Megállapítjuk a kapcsolataikat is.
Ezt követően, mielőtt bármilyen műveletet elvégezhetnénk, szükségünk lesz egy példányra EntityManagerFactory. Ezt felhasználhatjuk az alkotáshoz EntityManager. Ezzel együtt alkotnunk kell TransactionManager a tranzakciós határok kezelésére.
Nézzük meg, hogyan használhatjuk ezeket a korábban létrehozott entitások megőrzéséhez és visszakereséséhez:
private void persistTestData (EntityManagerFactory entitásManagerFactory, Szerkesztőszerkesztő) dobja a Kivétel {TransactionManager tranzakciókezelő = com.arjuna.ats.jta.TransactionManager.transactionManager (); actionManager.begin (); EntityManager entitásManager = entitásManagerFactory.createEntityManager (); entitásManager.persist (szerkesztő); entitásManager.close (); tranzakcióManager.commit (); }
Itt használjuk EntityManager hogy fenntartsuk a gyökér entitást, amely minden kapcsolatához hozzárendel. Ezt a műveletet egy meghatározott tranzakciós határon belül is végrehajtjuk.
Most készen állunk az éppen kitartó entitás betöltésére és annak tartalmának ellenőrzésére. Tesztet futtathatunk ennek ellenőrzésére:
@Test public void givenMongoDB_WhenEntitiesCreated_thenCanBeRetrieved () dobja a Kivételt {EntityManagerFactory entitásManagerFactory = Persistence.createEntityManagerFactory ("ogm-mongodb"); Szerkesztőszerkesztő = generatorTestData (); persistTestData (entitásManagerFactory, szerkesztő); TransactionManageractionManager = com.arjuna.ats.jta.TransactionManager.transactionManager (); actionManager.begin (); EntityManager entitásManager = entitásManagerFactory.createEntityManager (); Szerkesztő loadingEditor = entitásManager.find (Szerkesztő.osztály, editor.getEditorId ()); assertThat (loadedEditor) .isNotNull (); // Egyéb állítások az entitások és kapcsolatok ellenőrzésére}
Itt használjuk a EntityManager ismét megtalálja az adatokat és szabványos állításokat hajtson végre azokon. Amikor futtatjuk ezt a tesztet, az azonnali helyreállítja az adatbázist, megőrzi az entitásokat, visszakeresi és ellenőrzi.
Ismét megtettük csak a JPA-t használta az entitások és kapcsolataik megőrzéséhez. Hasonlóképpen, a JPA-t használjuk az entitások visszatöltésére és mindez jól működik, még akkor is, ha az adatbázis-választásunk a hagyományos relációs adatbázis helyett MongoDB.
6. A háttérprogram váltása
A háttérprogramunkat is átkapcsolhatjuk. Derítsük ki, milyen nehéz lesz ezt megtenni.
Megváltoztatjuk a háttérrendszert Neo4j-re, amely történetesen egy népszerű grafikon-orientált adattároló.
Először tegyük hozzá a Neo4j Maven-függőségét:
org.hibernate.ogm hibernate-ogm-neo4j 5.4.0.Végső
Ezután hozzá kell adnunk a megfelelő perzisztencia egységet a kitartás.xml:
org.hibernate.ogm.jpa.HibernateOgmPersistence
Röviden, ezek a Neo4j-hez szükséges alapvető konfigurációk. Ezt szükség szerint tovább részletezhetjük.
Nos, nagyjából ezt kell tenni. Amikor ugyanazt a tesztet futtatjuk a Neo4j-vel, mint a háttér-adattárolót, akkor az elég zökkenőmentesen működik.
Ne feledje, hogy a háttérprogramunkat átállítottuk a MongoDB-ről, amely történetesen dokumentumorientált adattároló, a Neo4j-re, amely egy grafikon-orientált adattároló. És mindezt minimális változtatásokkal, anélkül, hogy bármilyen műveletünkben változtatásra lett volna szükségünk.
7. Következtetés
Ebben a cikkben áttekintettük a Hibernate OGM alapjait, beleértve annak architektúráját is. Ezt követően megvalósítottunk egy alapdomaint, és különféle műveleteket hajtottunk végre különböző DB-k segítségével.
Mint mindig, a példák kódja elérhető a GitHub oldalon.