Utiliser Hibernate OGM pour intégrer Hibernate à MongoDB

1. Hiberner OGM dans MongoDB
2. Importance d’utiliser Hibernate OGM
3. Utiliser Hibernate OGM pour intégrer Hibernate à MongoDB

Dans cet article, nous allons apprendre l’importance d’Hibernate Object/Grid Mapper (OGM) et l’utiliser pour intégrer Hibernate à MongoDB.

Hiberner OGM dans MongoDB

Hibernate Object/Grid Mapper (OGM) nous fournit la prise en charge de l’API Java Persistence (JPA) pour les datastores NoSQL. N’oubliez pas que NoSQL est le terme parent qui couvre toute la variété enfant de stockage de données.

Par exemple, il comprend des documents, des banques de données de valeurs-clés, orientées graphiques et orientées colonnes.

Importance d’utiliser Hibernate OGM

Pour comprendre son importance, vous devez connaître n’importe quelle base de données relationnelle, Hibernate et MongoDB à un niveau de base. En supposant que vous ayez des connaissances de base sur tout (au moins une base de données relationnelle, Hibernate et MongoDB).

Hibernate mappe les objets Java, plus précisément les propriétés (également appelées champs), aux colonnes d’une table de base de données. Prenons un exemple où un students peut avoir plusieurs courses.

Dans une base de données relationnelle, nous pouvons modéliser cela en contenant une table students et courses où plusieurs entrées dans la table courses peuvent correspondre à un étudiant dans la table students.

create table students {
    id integer(10),
    name varchar(100),
    department varchar(100)
}

create table courses {
    id integer(10),
    course1 varchar(50),
    course2 varchar(50),
}

create table student_courses {
    student_id  integer(10),
    course_id  integer(10)
}

Nous pouvons représenter une relation similaire en Java, quelque chose comme suit.

@OneToMany(cascade=CascadeType.ALL)
  @JoinTable(name="student_courses", joinColumns={@JoinColumn(name="student_id ", referencedColumnName="id")}
  , inverseJoinColumns={@JoinColumn(name="course_id", referencedColumnName="id")})
  private Set<CoursesEntity> courses;

Alors que MongoDB est une base de données NoSQL, il stocke et accède aux données via des paires clé-valeur. N’oubliez pas que la section de valeur est stockée sous forme de document au format JSON/XML.

Si nous stockons l’exemple précédent de students et courses, il ressemblera à ceci dans MongoDB.

{
    id: 1,
    name: "John",
    department: "Comptuer Science"
    courses: [
        {
            course1: "C Programming",
            course2: "Machine Learning"
        },
        {
            course1: "Recommender Systems",
            course2: "Data Science"
        }
   ]
}

Comme nous pouvons voir que MongoDB a des champs imbriqués qui peuvent aller encore plus en profondeur, nous ne pouvons pas utiliser Hibernate avec MongoDB en suivant les méthodes traditionnelles pour mapper les champs/propriétés Java à un document.

C’est là que nous avons besoin d’Object/Grid Mapper (OGM). Hibernate nous fournit une implémentation de moteur OGM qui étend ses fonctionnalités et fonctionnalités pour prendre en charge les magasins de données NoSQL, par exemple, MongoDB.

L’OGM offre également l’avantage d’interroger des données en utilisant des requêtes natives du langage de notre base de données NoSQL spécifique avec Java Persistence Query Language (JPQL), également appelé Java Persistence API (JPA).

Le principal avantage de l’utilisation d’OGM est la cohérence de l’API Java Persistence entre NoSQL et les datastores relationnels. L’OGM Hibernate peut fournir une abstraction sur divers magasins de données NoSQL grâce à deux interfaces clés, GridDialect et DatastoreProvider.

C’est pourquoi chaque nouveau datastore NoSQL supporté par Hibernate OGM est livré avec l’implémentation des interfaces DatastoreProvider et GridDialect.

À ce jour, bien qu’Hibernate OGM ne supporte pas tous les magasins de données NoSQL, mais est capable de travailler avec beaucoup d’entre eux, y compris Infinispan (valeur-clé), Neo4j (graphique) et MongoDB (document).

Utiliser Hibernate OGM pour intégrer Hibernate à MongoDB

Nous devons configurer les éléments suivants pour utiliser Hibernate OGM afin d’intégrer Hibernate à MongoDB.

1. Java (nous utilisons Java 18.0.1.1).
2. Serveur MongoDB (nous utilisons MongoDB 5.0.8).
3. Éditeur de code ou Java IDE (nous utilisons Apache NetBeans IDE 13).
4. Dépendances utilisant Maven ou Gradle (nous utilisons Maven).

Ici, nous allons créer une classe nommée Student qui serait traitée comme une Entity, et les propriétés de la classe Student seront prises comme des noms de field dans MongoDB. Nous utilisons des annotations pour mapper les classes Java aux entités et les propriétés aux champs.

Préparons d’abord les fichiers requis pour cela. Écrivez le fichier pom.xml (ce fichier contient toutes les dépendances requises) :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.voidtesting.hibernatewithmongodbusingogm</groupId>
    <artifactId>HibernateWithMongoDBUsingOGM</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>18</maven.compiler.source>
        <maven.compiler.target>18</maven.compiler.target>
        <exec.mainClass>
            <!--this name will be on single line, we are splitting it
            for readability purpose-->
            com.voidtesting.hibernatewithmongodbusingogm
            .HibernateWithMongoDBUsingOGM
        </exec.mainClass>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.6.Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate.ogm</groupId>
            <artifactId>hibernate-ogm-mongodb</artifactId>
            <version>5.4.1.Final</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.narayana.jta</groupId>
            <artifactId>narayana-jta</artifactId>
            <version>5.9.2.Final</version>
            <type>jar</type>
        </dependency>

        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.parboiled</groupId>
            <artifactId>parboiled-java</artifactId>
            <version>1.4.1</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.jbossts</groupId>
            <artifactId>jbossjta</artifactId>
            <version>4.16.4.Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.6.9.Final</version>
        </dependency>

    </dependencies>
</project>

Écrivez le fichier persistence.xml (ici, nous configurons l’unité persistante JPA donnée) :

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

    <persistence-unit name="ogmdemo" transaction-type="JTA">
        <!-- Use the Hibernate OGM provider: configuration will be transparent -->
        <provider>org.hibernate.ogm.jpa.HibernateOgmPersistence</provider>
        <class>com.voidtesting.hibernatewithmongodbusingogm.Student</class>
        <exclude-unlisted-classes>true</exclude-unlisted-classes>

        <properties>
           <property name="hibernate.transaction.jta.platform"
           value="org.hibernate.service.jta.platform.internal.JBossStandAloneJtaPlatform"
           />
           <!--
           Here you will pick which NoSQL technology to use, and configure it;
           in this example we use MongoDB.
           -->
           <property name="hibernate.ogm.datastore.provider" value="MONGODB"/>
           <!-- Define MongoDB access parameters here. -->
           <property name="hibernate.ogm.datastore.host" value="127.0.0.1"/>
           <property name="hibernate.ogm.datastore.port" value="27017"/>
           <property name="hibernate.ogm.datastore.create_database" value="true"/>
           <property name="hibernate.ogm.datastore.database"
                     value="HibernateMongoDBDemo"/>

     </properties>
  </persistence-unit>
</persistence>

Assurez-vous d’avoir le fichier persistence.xml dans le répertoire src/main/resources/META-INF. Sinon, vous risquez d’obtenir des erreurs.

Créez la classe Student.java (cette classe sera mappée en tant qu’entité et ses variables en tant que champs dans MongoDB) :

package com.voidtesting.hibernatewithmongodbusingogm;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Student implements Serializable {
  @Id public int id;
  public String name;

  public Student(int id, String name) {
    this.id = id;
    this.name = name;
  }

  public Student() {}

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

Vous remarquerez peut-être que nous avons utilisé les annotations @Entity et @Id pour indiquer à la base de données MongoDB qui crée une entité pour cette classe et la nommer Student où la clé primaire serait id. Vous pouvez trouver toutes les annotations JPA ici.

Créez la classe principale Java :

package com.voidtesting.hibernatewithmongodbusingogm;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class HibernateWithMongoDBUsingOGM {
  public static void main(String args[]) {
    EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("ogmdemo");
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    entityManager.getTransaction().begin();
    // perform operations here
    Student std = new Student(1, "Mehvish Ashiq");
    entityManager.persist(std);
    entityManager.getTransaction().commit();
    entityManager.close();
    entityManagerFactory.close();
  }
}

Voici une capture d’écran pour connaître l’emplacement correct de tous les fichiers dans Java Project.

Maintenant, exécutez le programme. Vous pouvez observer la sortie suivante pour voir comment nous exécutons et nous assurer que tout fonctionne correctement.

Production: