Use Hibernate OGM para integrar Hibernate con MongoDB
- OGM de Hibernate en MongoDB
- Importancia de usar Hibernate OGM
- Use Hibernate OGM para integrar Hibernate con MongoDB
En este artículo, aprenderemos la importancia de Hibernate Object/Grid Mapper (OGM) y lo usaremos para integrar Hibernate con MongoDB.
OGM de Hibernate en MongoDB
Hibernate Object/Grid Mapper (OGM) nos proporciona compatibilidad con la API de persistencia de Java (JPA) para los almacenes de datos NoSQL. Recuerde que NoSQL es el término principal que cubre toda la variedad secundaria de almacenamiento de datos.
Por ejemplo, incluye documentos, valores clave, almacenes de datos orientados a gráficos y orientados a columnas.
Importancia de usar Hibernate OGM
Para comprender su importancia, debe conocer cualquier base de datos relacional, Hibernate y MongoDB en un nivel básico. Suponiendo que tenga conocimientos básicos de todos (al menos una base de datos relacional, Hibernate y MongoDB).
Hibernate asigna objetos Java, más precisamente propiedades (también se refiere a campos), a las columnas en una tabla de base de datos. Tomemos un ejemplo en el que un estudiante puede tener varios cursos.
En una base de datos relacional, podemos modelar esto al contener una tabla de students y courses donde múltiples entradas en la tabla de courses pueden asignarse a un estudiante en la tabla de 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)
}
Podemos representar una relación similar en Java, algo así.
@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;
Si bien MongoDB es una base de datos NoSQL, almacena y accede a los datos a través de pares clave-valor. Recuerde que la sección de valores se almacena como un documento en formato JSON/XML.
Si almacenamos el ejemplo anterior de students y courses, se verá de la siguiente manera en MongoDB.
{
id: 1,
name: "John",
department: "Comptuer Science"
courses: [
{
course1: "C Programming",
course2: "Machine Learning"
},
{
course1: "Recommender Systems",
course2: "Data Science"
}
]
}
Como podemos ver que MongoDB tiene campos anidados que pueden profundizar aún más, no podemos usar Hibernate con MongoDB siguiendo los métodos tradicionales para asignar campos/propiedades de Java a un documento.
Aquí es donde necesitamos Object/Grid Mapper (OGM). Hibernate nos proporciona una implementación de motor OGM que amplía su funcionalidad y características para admitir almacenes de datos NoSQL, por ejemplo, MongoDB.
El OGM también ofrece el beneficio de consultar datos mediante el uso de consultas nativas del lenguaje de nuestra base de datos NoSQL específica junto con el lenguaje de consulta de persistencia de Java (JPQL), también conocido como API de persistencia de Java (JPA).
La principal ventaja de usar OGM es la consistencia de la API de persistencia de Java en NoSQL y almacenes de datos relacionales. Hibernate OGM puede proporcionar una abstracción sobre varios almacenes de datos NoSQL debido a dos interfaces clave, GridDialect y DatastoreProvider.
Es por eso que cada nuevo almacén de datos NoSQL compatible con Hibernate OGM viene con la implementación de las interfaces DatastoreProvider y GridDialect.
A día de hoy, aunque Hibernate OGM no es compatible con todos los almacenes de datos NoSQL, es capaz de trabajar con muchos de ellos, incluidos Infinispan (clave-valor), Neo4j (gráfico) y MongoDB (documento).
Use Hibernate OGM para integrar Hibernate con MongoDB
Necesitamos configurar lo siguiente para usar Hibernate OGM para integrar Hibernate con MongoDB.
- Java (estamos usando Java 18.0.1.1).
- Servidor MongoDB (estamos usando MongoDB 5.0.8).
- Editor de código o IDE de Java (usamos Apache NetBeans IDE 13).
- Dependencias usando Maven o Gradle (estamos usando Maven).
Aquí crearemos una clase llamada Student que será tratada como una Entidad, y las propiedades de la clase Student serán tomadas como nombres de campos en MongoDB. Usamos anotaciones para asignar las clases Java a las entidades y las propiedades a los campos.
Preparemos los archivos necesarios para eso primero. Escriba el archivo pom.xml (este archivo contiene todas las dependencias requeridas):
<?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>
Escriba el archivo persistence.xml (aquí, configuramos la unidad persistente JPA dada):
<?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>
Asegúrese de tener el archivo persistence.xml en el directorio src/main/resources/META-INF. De lo contrario, puede obtener errores.
Cree la clase Student.java (esta clase se mapeará como una entidad y sus variables como campos en 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;
}
}
Puede notar que usamos las anotaciones @Entity y @Id para decirle a MongoDB que crea una entidad para esta clase y la nombra como Student donde la clave principal sería id. Puede encontrar todas las anotaciones de JPA aquí.
Crear clase principal de 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();
}
}
Aquí hay una captura de pantalla para conocer la ubicación correcta de todos los archivos en Java Project.
Ahora, ejecuta el programa. Puede observar el siguiente resultado para ver cómo ejecutamos y asegurarnos de que todo funciona bien.
Producción:
