Verwendung von Hibernate OGM zur Integration von Hibernate mit MongoDB
- OGM in MongoDB in den Ruhezustand versetzen
- Bedeutung der Verwendung von Hibernate OGM
- Verwenden Sie Hibernate OGM, um Hibernate mit MongoDB zu integrieren
In diesem Artikel lernen wir die Bedeutung von Hibernate Object/Grid Mapper (OGM) kennen und verwenden ihn, um Hibernate mit MongoDB zu integrieren.
OGM in MongoDB in den Ruhezustand versetzen
Hibernate Object/Grid Mapper (OGM) bietet uns Unterstützung für die Java Persistence API (JPA) für die NoSQL-Datenspeicher. Denken Sie daran, dass NoSQL der übergeordnete Begriff ist, der die gesamte untergeordnete Vielfalt der Datenspeicherung abdeckt.
Beispielsweise umfasst es Dokumente, Schlüsselwerte, diagrammorientierte und spaltenorientierte Datenspeicher.
Bedeutung der Verwendung von Hibernate OGM
Um seine Bedeutung zu verstehen, müssen Sie jede relationale Datenbank, Hibernate und MongoDB auf einer grundlegenden Ebene kennen. Vorausgesetzt, Sie haben grundlegende Kenntnisse über alle (mindestens eine relationale Datenbank, Hibernate und MongoDB).
Der Hibernate bildet Java-Objekte, genauer Eigenschaften (auch als Felder bezeichnet), auf die Spalten einer Datenbanktabelle ab. Nehmen wir ein Beispiel, bei dem ein students mehrere courses haben kann.
In einer relationalen Datenbank können wir dies modellieren, indem wir eine Tabelle students und courses enthalten, in der mehrere Einträge in der Tabelle courses einem Studenten in der Tabelle students zugeordnet werden können.
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)
}
Wir können eine ähnliche Beziehung in Java wie folgt darstellen.
@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;
Während MongoDB eine NoSQL-Datenbank ist, speichert und greift es auf die Daten über Schlüssel-Wert-Paare zu. Denken Sie daran, dass der Wertabschnitt als Dokument im JSON/XML-Format gespeichert wird.
Wenn wir das vorherige Beispiel von students und courses hinterlegen, sieht es in MongoDB wie folgt aus.
{
id: 1,
name: "John",
department: "Comptuer Science"
courses: [
{
course1: "C Programming",
course2: "Machine Learning"
},
{
course1: "Recommender Systems",
course2: "Data Science"
}
]
}
Da wir sehen können, dass MongoDB verschachtelte Felder hat, die noch tiefer gehen können, können wir Hibernate nicht mit MongoDB verwenden, indem wir traditionellen Methoden folgen, um Java-Felder/Eigenschaften einem Dokument zuzuordnen.
Hier brauchen wir Object/Grid Mapper (OGM). Hibernate stellt uns eine OGM-Engine-Implementierung zur Verfügung, die ihre Funktionalität und Features erweitert, um NoSQL-Datenspeicher, z. B. MongoDB, zu unterstützen.
Das OGM bietet auch den Vorteil, Daten abzufragen, indem es native Abfragen der Sprache unserer spezifischen NoSQL-Datenbank zusammen mit der Java Persistence Query Language (JPQL) verwendet, die auch als Java Persistence API (JPA) bezeichnet wird.
Der Hauptvorteil der Verwendung von OGM ist die Konsistenz der Java Persistence API über NoSQL- und relationale Datenspeicher hinweg. Das Hibernate OGM kann aufgrund zweier Schlüsselschnittstellen, GridDialect und DatastoreProvider, eine Abstraktion über verschiedene NoSQL-Datenspeicher bereitstellen.
Aus diesem Grund enthält jeder neue von Hibernate OGM unterstützte NoSQL-Datenspeicher die Implementierung der Schnittstellen DatastoreProvider und GridDialect.
Stand heute unterstützt Hibernate OGM zwar nicht alle NoSQL-Datenspeicher, kann aber mit vielen von ihnen arbeiten, darunter Infinispan (Schlüsselwert), Neo4j (Grafik) und MongoDB (Dokument).
Verwenden Sie Hibernate OGM, um Hibernate mit MongoDB zu integrieren
Wir müssen Folgendes einrichten, um Hibernate OGM für die Integration von Hibernate mit MongoDB zu verwenden.
- Java (wir verwenden Java 18.0.1.1).
- MongoDB-Server (wir verwenden MongoDB 5.0.8).
- Code Editor oder Java IDE (wir verwenden Apache NetBeans IDE 13).
- Abhängigkeiten mit Maven oder Gradle ([wir verwenden Maven]).
Hier erstellen wir eine Klasse namens Student, die als Entity behandelt wird, und die Eigenschaften der Klasse Student werden als field-Namen in MongoDB verwendet. Wir verwenden Annotationen, um Java-Klassen Entitäten und Eigenschaften Feldern zuzuordnen.
Lassen Sie uns zuerst die erforderlichen Dateien dafür vorbereiten. Schreiben Sie die Datei pom.xml (diese Datei enthält alle erforderlichen Abhängigkeiten):
<?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>
Schreiben Sie die Datei persistence.xml (Hier konfigurieren wir die angegebene JPA-Persistenzeinheit):
<?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>
Stellen Sie sicher, dass Sie die Datei persistence.xml im Verzeichnis src/main/resources/META-INF haben. Andernfalls können Fehler auftreten.
Erstellen Sie die Klasse Student.java (diese Klasse wird als Entität und ihre Variablen als Felder in MongoDB abgebildet):
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;
}
}
Sie werden vielleicht bemerken, dass wir die Annotationen @Entity und @Id verwendet haben, um der MongoDB mitzuteilen, die eine Entität für diese Klasse erstellt, und sie als Student zu benennen, wobei der Primärschlüssel id wäre. Sie können alle JPA-Annotationen hier finden.
Java-Hauptklasse erstellen:
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();
}
}
Hier ist ein Screenshot, um den korrekten Speicherort aller Dateien in Java Project zu erfahren.
Führen Sie nun das Programm aus. Sie können die folgende Ausgabe beobachten, um zu sehen, wie wir ausführen und sicherstellen, dass alles gut funktioniert.
Ausgabe:
