Overview
En esta guía, aprenderá a crear entidades ORM de Hibernate que representan colecciones de MongoDB. Las entidades son clases Java que definen la estructura de sus datos. Al usar la extensión ORM de Hibernate, puede asignar cada entidad a una colección de MongoDB y usar estas entidades para interactuar con los documentos de la colección.
Tip
Tutorial de entidades
Para ver un tutorial que muestra cómo modelar relaciones de uno a muchos mediante el uso de entidades y la extensión ORM de Hibernate, consulte Modelado de relaciones con Hibernate ORM y MongoDB Entrada del blog de Foojay.
Campos BSON de MongoDB
MongoDB organiza y almacena documentos en una representación binaria llamada BSON, que permite un procesamiento de datos flexible. Esta sección describe la compatibilidad de la extensión ORM de Hibernate con los campos BSON, que puede incluir en sus entidades.
Tip
Para obtener más información sobre cómo MongoDB almacena datos BSON, consulte Tipos BSON en el manual del servidor MongoDB.
La siguiente tabla describe los tipos de campos BSON admitidos y sus equivalentes de extensión ORM de Hibernate que puede usar en sus entidades ORM de Hibernate:
Tipo de campo BSON | Tipo de campo de extensión | Descripción de BSON |
|---|---|---|
|
| Represents a null value or absence of data. |
|
| Stores binary data with subtype 0. |
|
| Stores UTF-8 encoded string values. |
|
| Stores 32-bit signed integers. |
|
| Stores 64-bit signed integers. |
|
| Stores floating-point values. |
|
| Stores true or false values. |
|
| Stores 28-bit decimal values. |
|
| Stores unique 12-byte identifiers that MongoDB uses as primary keys. |
|
| Stores dates and times as milliseconds since the Unix epoch. |
|
| Stores embedded documents with field values mapped according to their respective
types. @Struct aggregate embeddables might also contain array or Collection
attributes. |
|
| Stores array values with elements mapped according to their respective types. Character arrays require setting the hibernate.type.wrapper_array_handling configuration property. |
Definir una entidad
Para crear una entidad que represente una colección de MongoDB, cree un nuevo archivo Java en el directorio del paquete base de su proyecto y añada su clase de entidad a él. En la clase de entidad, especifique los campos que desea almacenar y el nombre de la colección. El elemento name de la anotación @jakarta.persistence.Table representa el nombre de su colección de MongoDB. Utilice la siguiente sintaxis para definir una entidad:
public class <EntityName> { // Specify your primary key field here private <field type> <field name>; // Include additional fields here private <field type> <field name>; // Parameterized constructor public <EntityName>(<parameters>) { // Initialize fields here } // Default constructor public <EntityName>() { } // Getter and setter methods public <field type> get<FieldName>() { return <field name>; } public void set<FieldName>(<field type> <field name>) { this.<field name> = <field name>; } }
Para usar sus entidades, puede consultarlas en los archivos de su aplicación. Para obtener más información sobre las operaciones CRUD en la extensión ORM de Hibernate, consulte Realizar guía de operaciones CRUD.
Ejemplo
Esta clase de entidad de muestra Movie.java define una entidad Movie que incluye la siguiente información:
@Entityanotación que marca la clase como una entidad ORM de Hibernate@Tableanotación que asigna la entidad a lamoviescolección de los conjuntos de datos de muestra del Atlas@Idy@ObjectIdGeneratoranotaciones que designan el campoidcomo clave principal y configuran la generación automática deObjectIdTip
Valores de clave principal
Este ejemplo especifica el campo
ObjectIdcomo la clave principal de la entidad, pero también puede establecer los camposString,IntoUUIDcomo la clave principal utilizando la anotación@Id.Campos privados que representan datos de películas
Constructores predeterminados y parametrizados para la instanciación de entidades
Métodos getter y setter que proporcionan acceso a los campos de la entidad
package org.example; import com.mongodb.hibernate.annotations.ObjectIdGenerator; import org.bson.types.ObjectId; import java.util.List; import jakarta.persistence.Entity; import jakarta.persistence.Id; import jakarta.persistence.Table; public class Movie { private ObjectId id; private String title; private String plot; private int year; private List<String> cast; public Movie(String title, String plot, int year, List<String> cast) { this.title = title; this.plot = plot; this.year = year; this.cast = cast; } public Movie() { } public ObjectId getId() { return id; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getPlot() { return plot; } public void setPlot(String plot) { this.plot = plot; } public int getYear() { return year; } public void setYear(int year) { this.year = year; } public List<String> getCast() { return cast; } public void setCast(List<String> cast) { this.cast = cast; } }
Tip
Para obtener más información sobre los campos utilizados en la definición de la clase de entidad, consulte la sección Campos BSON de MongoDB de esta guía.
Datos incrustados
La extensión ORM de Hibernate admite documentos incrustados mediante anotaciones ORM @Embeddable de Hibernate. Con estos documentos, se pueden crear relaciones uno a muchos, muchos a uno y uno a uno dentro de documentos MongoDB. Este formato es ideal para representar datos a los que se accede frecuentemente de forma conjunta.
Para representar documentos incrustados, use las anotaciones @Struct y @Embeddable en una clase para crear un incrustable agregado @Struct. A continuación, incluya el tipo de incrustable en su entidad principal como campo. La extensión ORM de Hibernate permite incrustar objetos individuales, matrices y colecciones de incrustables.
Tip
Para obtener más información sobre embebibles agregados @Struct, consulta @Struct mapeo agregable embebido en la documentación de Hibernate ORM.
Relaciones uno a uno
Una relación uno a uno se produce cuando un registro de una base de datos se asocia con exactamente un registro de otra. En MongoDB, se puede crear una colección con un campo de documento incrustado para modelar una relación uno a uno. La extensión ORM de Hibernate permite crear campos de documento incrustados mediante el uso de incrustables agregados @Struct.
El ejemplo define un campo con un @Struct tipo incrustable agregado en una entidad similar al ejemplo "Definir una entidad" de esta guía. La clase de entidad de ejemplo Movie.java incluye la siguiente información:
@Entityy@Tableanotaciones que definen la entidad y la asignan a la colecciónmovies@Idy las anotaciones@ObjectIdGeneratorque designan el campoidcomo la llave primariaCampo de cadena que representa el título de la película.
@Structcampos integrables agregados que representan premios de películas e información del estudio
El siguiente ejemplo representa una relación uno a uno porque cada entidad Movie está asociada con un elemento integrable Awards y un elemento integrable Studio:
public class Movie { private ObjectId id; private String title; private Awards awards; private Studio studio; public Movie(String title, Awards awards, Studio studio) { this.title = title; this.awards = awards; this.studio = studio; } public Movie() { } // Getter and setter methods }
El siguiente código de muestra crea un elemento incrustable agregado Awards @Struct:
public class Awards { private int wins; private int nominations; private String text; public Awards(int wins, int nominations, String text) { this.wins = wins; this.nominations = nominations; this.text = text; } public Awards() { } // Getter and setter methods }
El siguiente código de muestra crea un elemento incrustable agregado Studio @Struct:
public class Studio { private String name; private String location; private int foundedYear; public Studio(String name, String location, int foundedYear) { this.name = name; this.location = location; this.foundedYear = foundedYear; } public Studio() { } // Getter and setter methods }
Relaciones de uno a muchos
Una relación uno a muchos se produce cuando un registro de una base de datos se asocia con varios registros de otra. En MongoDB, se puede definir un campo de colección que almacena una lista de documentos incrustados para modelar una relación uno a muchos. La extensión ORM de Hibernate permite crear campos de documentos incrustados mediante una lista de @Struct incrustables agregados.
El ejemplo define un campo que almacena una lista de @Struct elementos incrustables agregados en una entidad similar al ejemplo "Definir una entidad" de esta guía. La clase de entidad de ejemplo Movie.java incluye la siguiente información:
@Entityy@Tableanotaciones que definen la entidad y la asignan a la colecciónmovies@Idy las anotaciones@ObjectIdGeneratorque designan el campoidcomo la llave primariaCampo de cadena que representa el título de la película.
Campo de lista que almacena varios
Writer@Structembebidos agregados, lo cual representa información de autor
El siguiente ejemplo representa una relación de uno a muchos porque cada entidad Movie está asociada con múltiples elementos integrables Writer:
public class Movie { private ObjectId id; private String title; private List<Writer> writers; public Movie(String title, List<Writer> writers) { this.title = title; this.writers = writers; } public Movie() { } // Getter and setter methods }
El siguiente código de muestra crea un elemento incrustable agregado Writer @Struct:
public class Writer { private String name; public Writer() { } public Writer(String name) { this.name = name; } // Getter and setter methods }
Información Adicional
Para aprender a usar sus entidades para ejecutar operaciones de base de datos, consulte las siguientes guías en la sección Interactuar con datos:
Para obtener más información sobre los campos ORM de Hibernate, consulte la sección Tipos de mapeo en la documentación ORM de Hibernate.
Para obtener más información sobre las entidades ORM de Hibernate, consulte Modelos POJO en la documentación de Hibernate ORM.