Docs Menu
Docs Home
/ /

Crear entidades para representar colecciones

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.

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

null

null

Represents a null value or absence of data.

Binary

byte[]

Stores binary data with subtype 0.

String

char, java.lang.Character, java.lang.String o char[]

Stores UTF-8 encoded string values.

Int32

int or java.lang.Integer

Stores 32-bit signed integers.

Int64

long or java.lang.Long

Stores 64-bit signed integers.

Double

double or java.lang.Double

Stores floating-point values.

Boolean

boolean or java.lang.Boolean

Stores true or false values.

Decimal128

java.math.BigDecimal

Stores 28-bit decimal values.

ObjectId

org.bson.types.ObjectId

Stores unique 12-byte identifiers that MongoDB uses as primary keys.

Date

java.time.Instant

Stores dates and times as milliseconds since the Unix epoch.

Object

@org.hibernate.annotations.Struct agregado incrustable

Stores embedded documents with field values mapped according to their respective types. @Struct aggregate embeddables might also contain array or Collection attributes.

Array

Array, java.util.Collection (o subtipo) de los tipos admitidos

Stores array values with elements mapped according to their respective types. Character arrays require setting the hibernate.type.wrapper_array_handling configuration property.

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:

@Entity
@Table(name = "<collection name>")
public class <EntityName> {
@Id
// 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.

Esta clase de entidad de muestra Movie.java define una entidad Movie que incluye la siguiente información:

  • @Entity anotación que marca la clase como una entidad ORM de Hibernate

  • @Table anotación que asigna la entidad a la movies colección de los conjuntos de datos de muestra del Atlas

  • @Id y @ObjectIdGenerator anotaciones que designan el campo id como clave principal y configuran la generación automática de ObjectId

    Tip

    Valores de clave principal

    Este ejemplo especifica el campo ObjectId como la clave principal de la entidad, pero también puede establecer los campos String, Int o UUID como 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;
@Entity
@Table(name = "movies")
public class Movie {
@Id
@ObjectIdGenerator
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.

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.

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:

  • @Entity y @Table anotaciones que definen la entidad y la asignan a la colección movies

  • @Id y las anotaciones @ObjectIdGenerator que designan el campo id como la llave primaria

  • Campo de cadena que representa el título de la película.

  • @Struct campos 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:

@Entity
@Table(name = "movies")
public class Movie {
@Id
@ObjectIdGenerator
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:

@Embeddable
@Struct(name = "Awards")
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:

@Embeddable
@Struct(name = "Studio")
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
}

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:

  • @Entity y @Table anotaciones que definen la entidad y la asignan a la colección movies

  • @Id y las anotaciones @ObjectIdGenerator que designan el campo id como la llave primaria

  • Campo de cadena que representa el título de la película.

  • Campo de lista que almacena varios Writer @Struct embebidos 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:

@Entity
@Table(name = "movies")
public class Movie {
@Id
@ObjectIdGenerator
@Column(name = "_id")
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:

@Embeddable
@Struct(name = "Writer")
public class Writer {
private String name;
public Writer() {
}
public Writer(String name) {
this.name = name;
}
// Getter and setter methods
}

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.

Volver

Empezar

En esta página