Een gids voor OGM in de slaapstand

1. Overzicht

In deze tutorial bespreken we de basisprincipes van Hibernate Object / Grid Mapper (OGM).

Hibernate OGM biedt ondersteuning voor Java Persistence API (JPA) voor NoSQL-datastores. NoSQL is een overkoepelende term voor een breed scala aan gegevensopslag. Dit omvat bijvoorbeeld sleutelwaarde-, document-, kolomgeoriënteerde en grafiekgeoriënteerde datastores.

2. De architectuur van Hibernate OGM

Hibernate biedt traditioneel een Object Relational Mapping (ORM) -engine voor relationele databases. Hibernate OGM-engine breidt zijn functionaliteit uit om NoSQL-datastores te ondersteunen. Het belangrijkste voordeel van het gebruik ervan is de consistentie van de JPA-interface tussen relationele en NoSQL-datastores.

Hibernate OGM kan abstractie bieden over een aantal NoSQL-datastores vanwege twee belangrijke interfaces, DatastoreProvider en GridDialect. Daarom wordt elke nieuwe NoSQL-datastore die het ondersteunt, geleverd met een implementatie van deze interfaces.

Vanaf vandaag ondersteunt het niet alle NoSQL-datastores, maar het kan met veel van hen werken, zoals Infinispan en Ehcache (sleutelwaarde), MongoDB en CouchDB (document) en Neo4j (grafiek).

Het ondersteunt ook volledig transacties en kan werken met standaard JTA-providers. Ten eerste kan dit worden geleverd via de Jakarta EE-container zonder enige expliciete configuratie. Bovendien kunnen we een zelfstandige JTA-transactiebeheerder zoals Narayana gebruiken in de Java SE-omgeving.

3. Installatie

Voor deze zelfstudie gebruiken we Maven om de vereiste afhankelijkheden op te halen om met Hibernate OGM te werken. We zullen ook MongoDB gebruiken.

Laten we ter verduidelijking eens kijken hoe we ze voor de zelfstudie kunnen instellen.

3.1. Afhankelijkheden van Maven

Laten we eens kijken naar de afhankelijkheden die nodig zijn om met Hibernate OGM en MongoDB te werken:

 org.hibernate.ogm hibernate-ogm-mongodb 5.4.0.Final org.jboss.narayana.jta narayana-jta 5.9.2.Final 

Hier trekken we de vereiste afhankelijkheden via Maven:

  • Slaapstand OGM-dialect voor MongoDB
  • Narayana Transaction Manager (huidige aanbieder van de JTA)

3.2. Persistentie-eenheid

We zullen ook moeten definieer datastore-details in de winterslaap persistance.xml:

 org.hibernate.ogm.jpa.HibernateOgmPersistence 

Let op de definities die we hier hebben gegeven:

  • de waarde van het kenmerk transactietype als "JTA" (dit impliceert dat we een JTA-entiteitsbeheerder willen van de EntityManagerFactory)
  • de provider, dat wil zeggen HibernateOgmPersistence voor Hibernate OGM
  • een paar aanvullende details met betrekking tot de database (deze variëren doorgaans tussen verschillende gegevensbronnen)

De configuratie gaat ervan uit dat MongoDB draait en toegankelijk is op standaardinstellingen. Als dit niet het geval is, kunnen we indien nodig altijd details verstrekken. Een van onze vorige artikelen gaat ook in detail in op het instellen van MongoDB.

4. Entiteitsdefinitie

Nu we de basis hebben doorgenomen, gaan we enkele entiteiten definiëren. Als we eerder met Hibernate ORM of JPA hebben gewerkt, heeft dit niets meer toe te voegen. Dit is het fundamentele uitgangspunt van Hibernate OGM. Het belooft ons te laten werken met verschillende NoSQL-datastores met alleen de kennis van JPA.

Voor deze zelfstudie definiëren we een eenvoudig objectmodel:

Het definieert Artikel, Schrijver en Editor klassen samen met hun relaties.

Laten we ze ook in Java definiëren:

@Entity public class Artikel {@Id @GeneratedValue (generator = "uuid") @GenericGenerator (name = "uuid", strategy = "uuid2") private String articleId; private String articleTitle; @ManyToOne privé auteur auteur; // constructeurs, getters en setters ...}
@Entity public class Auteur {@Id @GeneratedValue (generator = "uuid") @GenericGenerator (name = "uuid", strategy = "uuid2") private String authorId; private String authorName; @ManyToOne privé Editor-editor; @OneToMany (mappedBy = "author", cascade = CascadeType.PERSIST) privé Set authoredArticles = nieuwe HashSet (); // constructeurs, getters en setters ...}
@Entity public class Editor {@Id @GeneratedValue (generator = "uuid") @GenericGenerator (name = "uuid", strategy = "uuid2") private String editorId; private String editorName; @OneToMany (mappedBy = "editor", cascade = CascadeType.PERSIST) private Set toegewezenAuthors = nieuwe HashSet (); // constructeurs, getters en setters ...}

We hebben nu entiteitsklassen gedefinieerd en deze geannoteerd met standaard JPA-annotaties:

  • @Entiteit om ze op te richten als PPV-entiteiten
  • @ID kaart om primaire sleutels te genereren voor de entiteiten met UUID's
  • @Een te veel en @ManyToOne om bidirectionele relaties tussen de entiteiten tot stand te brengen

5. Operaties

Nu we onze entiteiten hebben gemaakt, gaan we kijken of we er enkele bewerkingen op kunnen uitvoeren. Als eerste stap zullen we enkele testgegevens moeten genereren. Hier maken we een Editor, een paar Schrijver, en een beetje Artikel. We zullen ook hun relaties opbouwen.

Daarna, voordat we een bewerking kunnen uitvoeren, hebben we een exemplaar van EntityManagerFactory. We kunnen dit gebruiken om te creëren EntityManager. Daarnaast moeten we creëren TransactionManager om transactiegrenzen af ​​te handelen.

Laten we eens kijken hoe we deze kunnen gebruiken om te behouden en de entiteiten op te halen die we eerder hebben gemaakt:

private void persistTestData (EntityManagerFactory entityManagerFactory, Editor editor) gooit uitzondering {TransactionManager transactionManager = com.arjuna.ats.jta.TransactionManager.transactionManager (); transactionManager.begin (); EntityManager entityManager = entityManagerFactory.createEntityManager (); entiteitManager.persist (editor); entiteitManager.close (); transactionManager.commit (); }

Hier gebruiken we EntityManager om de wortelentiteit voort te zetten, die naar al zijn relaties stroomt. We voeren deze bewerking ook uit binnen een gedefinieerde transactiegrens.

Nu zijn we klaar om de entiteit die we zojuist hebben aangehouden te laden en de inhoud ervan te verifiëren. We kunnen een test uitvoeren om dit te verifiëren:

@Test openbare leegte gegevenMongoDB_WhenEntitiesCreated_thenCanBeRetrieved () gooit uitzondering {EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory ("ogm-mongodb"); Editor-editor = GenereerTestData (); persistTestData (entityManagerFactory, editor); TransactionManager transactionManager = com.arjuna.ats.jta.TransactionManager.transactionManager (); transactionManager.begin (); EntityManager entityManager = entityManagerFactory.createEntityManager (); Editor loadedEditor = entityManager.find (Editor.class, editor.getEditorId ()); assertThat (loadedEditor) .isNotNull (); // Andere beweringen om de entiteiten en relaties te verifiëren}

Hier gebruiken we de EntityManager opnieuw om de gegevens te vinden en er standaardbeweringen op uit te voeren. Wanneer we deze test uitvoeren, wordt de datastore geïnstantieerd, worden de entiteiten bewaard, opgehaald en geverifieerd.

Nogmaals, we hebben gebruikte zojuist JPA om de entiteiten samen met hun relatie voort te zetten. Evenzo we gebruiken JPA om de entiteiten terug te laden en het werkt allemaal prima, zelfs als onze database keuze MongoDB is in plaats van een traditionele relationele database.

6. Schakelen tussen backend

We kunnen ook van backend wisselen. Laten we nu eens kijken hoe moeilijk het zal zijn om dit te doen.

We veranderen onze backend in Neo4j, wat toevallig een populaire grafiekgeoriënteerde datastore is.

Laten we eerst de Maven-afhankelijkheid voor Neo4j toevoegen:

 org.hibernate.ogm hibernate-ogm-neo4j 5.4.0.Final 

Vervolgens moeten we de relevante persistentie-eenheid toevoegen aan ons persistence.xml:

 org.hibernate.ogm.jpa.HibernateOgmPersistence 

Kortom, dit zijn de basisconfiguraties die nodig zijn voor Neo4j. Dit kan desgewenst verder worden uitgewerkt.

Nou, dat is zo ongeveer wat er moet worden gedaan. Wanneer we dezelfde test uitvoeren met Neo4j als de backend-datastore, werkt het redelijk naadloos.

Merk op dat we onze backend hebben overgeschakeld van MongoDB, wat toevallig een documentgeoriënteerde datastore is, naar Neo4j, wat een grafiekgeoriënteerde datastore is. En we hebben dit allemaal gedaan met minimale wijzigingen en zonder enige wijzigingen in onze activiteiten.

7. Conclusie

In dit artikel hebben we de basisprincipes van Hibernate OGM besproken, inclusief de architectuur. Vervolgens hebben we een basisdomeinmodel geïmplementeerd en verschillende bewerkingen uitgevoerd met behulp van verschillende DB's.

Zoals altijd is de code voor de voorbeelden beschikbaar op GitHub.


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