Overview
En esta guía, puedes aprender cómo crear entidades de Hibernate ORM que representen colecciones de MongoDB. Las entidades son clases de Java que definen la estructura de tus datos. Cuando se utiliza la extensión Hibernate ORM, se puede asociar 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 de 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 el soporte de la extensión Hibernate ORM para 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. |
Define una entidad
Para crear una entidad que represente una colección de MongoDB, crea un nuevo archivo Java en el directorio de la base del paquete de tu proyecto y agrega tu clase de entidad al nuevo archivo. En tu clase de entidad, especifica los campos que quieres almacenar y el nombre de la colección. El elemento name de la anotación @jakarta.persistence.Table representa el nombre de tu colección MongoDB. Utiliza 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 la colecciónmoviesde los Conjuntos de datos de muestra de Atlas@Idy@ObjectIdGeneratoranotaciones que designan el campoidcomo la llave primaria y configuran la generación automática deObjectIdTip
Valores de clave principal
Este ejemplo especifica el campo
ObjectIdcomo la llave primaria de la entidad, pero también puedes configurar los camposString,IntoUUIDcomo la llave primaria utilizando la anotación@Id.Campos privados que representan datos de películas
Constructores por defecto 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 aprender más sobre los campos utilizados en la definición de la clase de entidad, consulta la sección Campos BSON de MongoDB de esta guía.
Datos incrustados
La extensión Hibernate ORM es compatible con documentos incrustados a través de anotaciones ORM Hibernate @Embeddable. Con los documentos incrustados, puedes crear relaciones Uno a Muchos, Muchos a Uno y Uno a Uno dentro de los documentos de MongoDB. Este formato es ideal para representar datos a los que se accede con frecuencia de forma conjunta.
Para representar documentos incrustados, utiliza las anotaciones @Struct y @Embeddable en una clase para crear un objeto agregable @Struct. Luego, incluye el tipo embebible en tu entidad principal como un campo. La extensión ORM de Hibernate admite la incorporación de objetos únicos, arreglos y colecciones de elementos embebibles.
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 da cuando un registro en una base de datos está asociado exactamente con un registro en otra base de datos. En MongoDB, puede crear una colección con un campo de documento incrustado para modelar una relación Uno a Uno. La extensión Hibernate ORM permite crear campos de documentos incrustados mediante el uso de agregados @Struct embebibles.
El ejemplo define un campo con un tipo embebible agregado @Struct en una entidad similar al ejemplo Definir una Entidad en esta guía. La clase de entidad de muestra 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 string 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 se asocia con un Awards incrustable y un Studio incrustable:
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 es cuando un registro en una base de datos está asociado con muchos registros en otra base de datos. En MongoDB, puedes definir un campo de colección que almacene una lista de documentos incrustados para modelar una relación uno a muchos. La extensión Hibernate ORM te permite crear campos de documentos incrustados utilizando una lista de @Struct embebibles agregados.
El ejemplo define un campo que almacena una lista de @Struct agregados embebidos en una entidad similar a la del Ejemplo de definición de entidad de esta guía. La clase de entidad de muestra 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 string 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 componibles 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 Hibernate ORM, consulte la sección Tipos de mapeo en la documentación de Hibernate ORM.
Para aprender más sobre las entidades de Hibernate ORM, consulta Modelos POJO en la documentación de Hibernate ORM.