Ú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.


$config[zx-auto] not found$config[zx-overlay] not found