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 uno-a-muchos utilizando entidades y la extensión Hibernate ORM, consulta la 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 los datos BSON, consulta BSON Types en el manual de MongoDB Server.
La siguiente tabla describe los tipos de campos BSON admitidos y sus equivalentes de la extensión Hibernate ORM que se pueden usar en las entidades de Hibernate ORM:
Tipo de campo BSON | Tipo de campo de extensión | Descripción de BSON |
|---|---|---|
|
| Representa un valor nulo o la ausencia de datos. |
|
| Almacena datos binarios con el subtipo 0 o valores UUID con el subtipo 4. |
|
| Almacena valores de string codificados en UTF-8. Los tipos |
|
| Almacena enteros de 32bits con signo. |
|
| Almacena enteros de 64bits con signo. |
|
| Almacena valores de punto flotante. |
|
| Almacena valores de |
|
| Almacena valores decimales de 28bits. Los valores de |
|
| Almacena identificadores únicos de 12bytes que MongoDB utiliza como claves primarias. |
|
| Almacena fechas y horas como milisegundos desde el Unix epoch. |
|
| Almacena documentos incrustados con valores de campo asignados según sus tipos respectivos. |
|
| Almacena valores de arreglo con elementos mapeados según sus tipos respectivos. Los arreglos de caracteres requieren la configuración de la propiedad de configuración |
Nota
La anotación @JdbcTypeCode no se admite
La extensión Hibernate ORM no admite la anotación @org.hibernate.annotations.JdbcTypeCode y lanza una excepción si utiliza esta anotación para anular la asignación de tipos de un campo.
Tipos de campos no soportados
Hibernate ORM serializa cualquier tipo de Java que implementa java.io.Serializable a datos binarios cuando no tiene otra asignación para ese tipo. Para evitar que sus datos se almacenen en este formato, la extensión Hibernate ORM rechaza los siguientes tipos y lanza una excepción cuando se inicia su aplicación. Esta comprobación se aplica a llaves primarias, campos ordinarios, atributos incrustables y elementos de colección.
La siguiente tabla describe los tipos de campo no admitidos y sus alternativas admitidas:
Categoría | Tipos no admitidos | Alternativa compatible |
|---|---|---|
Fecha y hora |
| Utilice |
BSON Values |
| Utilice |
Documentos BSON |
| Utilice un |
Define 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 agregue su clase de entidad al nuevo archivo. En su 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. También puede establecer el elemento opcional schema para anteponer el nombre de la colección, como se describe en la sección Calificadores de esquema de esta guía. 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 utilizar tus entidades, puedes consultarlas en tus archivos de aplicación. Para obtener más información sobre las operaciones CRUD en la extensión Hibernate ORM, consulta la guía Realizar operaciones CRUD.
Importante
El nombre del campo de la llave primaria debe ser _id
MongoDB requiere que el campo de llave primaria se asigne al campo _id. Puede establecer explícitamente el nombre de columna del campo @Id mediante el uso de una anotación @Column o una anulación orm.xml. Si establece este nombre en algo distinto de _id, la extensión Hibernate ORM lanza un FeatureNotSupportedException durante el arranque. Para resolver este error, remover la anotación @Column o establecer su nombre en _id.
Esta validación no se aplica a los mapeos XML de Hibernate Mapping (HBM) heredados. Si asigna su entidad mediante HBM XML, la extensión Hibernate ORM cambia el nombre de la columna de identificador a _id sin previo aviso en lugar de generar una excepción.
Calificadores de esquema
La anotación @Table acepta un elemento schema opcional que antepone a su nombre de colección. Cuando se configuran ambos elementos, la extensión Hibernate ORM mapea la entidad a una colección denominada <schema name>.<collection name>.
Un calificador de esquema solo cambia el nombre de la colección. Un esquema no es una base de datos de MongoDB independiente. Cada colección calificada por esquema reside en la base de datos a la que se conecta su instancia de SessionFactory. Dado que estas colecciones comparten una base de datos, una transacción puede abarcar varios esquemas.
Utilice la siguiente sintaxis para aplicar un calificador de esquema:
@Entity@Table(schema = "<schema name>", name = "<collection name>")public class <EntityName> {
// Define your fields, constructors, and methods here
}Nota
Limitaciones del calificador de esquema
La extensión Hibernate ORM rechaza el elemento catalog de la anotación @Table y la propiedad de configuración hibernate.default_catalog en el arranque. Si su aplicación debe acceder a varias bases de datos de MongoDB, cree una instancia SessionFactory separada para cada base de datos.
La extensión Hibernate ORM rechaza un punto (.) en un nombre de tabla o un nombre de esquema al iniciar. Esta restricción se aplica a los nombres de tablas primarias, secundarias, de unión y de colección, y a los nombres de esquema establecidos por el atributo schema o la propiedad de configuración hibernate.default_schema.
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 llave primaria
Este ejemplo especifica el campo
ObjectIdcomo la llave primaria de la entidad, pero también puede establecer los camposStringointcomo la llave primaria mediante el uso de la anotación@Id. Para aprender más, consulte Tipos de campo no compatibles.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;
@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; private List<String> directors;
public Movie(String title, String plot, int year, List<String> cast, List<String> directors) { this.title = title; this.plot = plot; this.year = year; this.cast = cast; this.directors = directors; }
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; }
public List<String> getDirectors() { return directors; }
public void setDirectors(List<String> directors) { this.directors = directors; }}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.
ID generados por secuencia
La extensión Hibernate ORM puede asignar ID numéricos crecientes a sus entidades automáticamente. Algunos números podrían faltar si se revierte una transacción o si una aplicación no utiliza todos los ID que reservó.
La extensión Hibernate ORM admite ID generados por secuencia para los tipos short, int y long, y para los tipos boxed Short, Integer y Long.
Agregue identificadores generados por secuencia a su entidad
Puede utilizar las anotaciones @GeneratedValue y @SequenceGenerator para añadir ID generados por secuencia a su entidad. El siguiente ejemplo reserva ID en bloques de 50 del contador movies_SEQ:
@Id@GeneratedValue( strategy = GenerationType.SEQUENCE, generator = "movies_SEQ")@SequenceGenerator( name = "movies_SEQ", sequenceName = "movies_SEQ", allocationSize = 50)private Long id;Las anotaciones controlan cómo la extensión Hibernate ORM crea el ID:
@GeneratedValueindica a la extensión Hibernate ORM que cree el valor del campoid. Sus atributosstrategyygeneratordefinen cómo la extensión crea el ID:strategy:AUTOoSEQUENCE. ConAUTO, la extensión de Hibernate ORM utiliza una secuencia y no tiene que declarar un@SequenceGenerator. ConSEQUENCE, la extensión Hibernate ORM utiliza el generador de secuencias denominado por el atributogenerator.generator: El nombre del@SequenceGeneratora utilizar. Si omite este atributo, la extensión Hibernate ORM nombra la secuencia según la tabla de la entidad, comomovies_SEQpara la tablamovies.
@SequenceGeneratordefine el generador de secuencias:name: El nombre al que hace referencia el atributo@GeneratedValuegenerator.sequenceName: El nombre del documento de contador. Si lo omite, la extensión Hibernate ORM utiliza elnamedel generador.initialValue: El valor desde el que comienza el primer ID generado. Se establece por defecto en1.allocationSize: El número de ID reservados en cada bloque.
Dónde se almacenan los ID
La extensión Hibernate ORM almacena documentos de contador en una colección fija denominada hibernate_sequences. Cada secuencia utiliza un documento contador que tiene los siguientes campos:
_ides el nombre de la secuencia.next_valuees el valor del contador que la extensión Hibernate ORM avanza para producir los siguientes ID. Debe coincidir con elinitialValuedel generador de secuencias, que por defecto es1.incrementes el número de ID reservados a la vez. Debe coincidir con el valorallocationSizedel generador de secuencias. Si no es así, elSessionFactoryno se inicia.
La extensión Hibernate ORM obtiene identificadores en bloques. Esto reduce el número de veces que debe ponerse en contacto con la base de datos. Cada solicitud simultánea recibe un ID diferente.
Importante
Requisitos del documento contador
Ambos next_value y increment deben ser enteros de 64bits (BSON Int64). Un documento contador al que le falta alguno de los campos, o que almacena un valor como un entero de 32bits, no puede asignar ID. Si la gestión de esquemas está deshabilitada, debe crear un documento contador para cada secuencia antes de que su aplicación pueda asignar ID.
Habilitar la gestión de esquemas
La gestión de esquemas es la forma en que Hibernate ORM crea los objetos de la base de datos que necesitan sus entidades. La extensión de Hibernate ORM lo utiliza para crear los documentos de contador para los ID generados por secuencia.
Para habilitar la gestión de esquemas, establezca la propiedad jakarta.persistence.schema-generation.database.action en su archivo hibernate.properties o persistence.xml. Utilice uno de los siguientes valores:
create: Crea los documentos de contador y los mantiene cuando elSessionFactoryse cierra.create-drop: Crea los documentos de contador cuando se abre elSessionFactoryy los descarta cuando se cierra.
El siguiente ejemplo utiliza create:
jakarta.persistence.schema-generation.database.action=createDeshabilitar la gestión de esquemas y configurar manualmente los contadores
Si prefiere desactivar la gestión de esquemas, puede crear manualmente documentos de contador para ID generados por secuencia. Establezca la siguiente propiedad:
jakarta.persistence.schema-generation.database.action=noneA continuación, cree un documento de contador en la colección hibernate_sequences para cada secuencia. El _id del documento de contador debe coincidir con el sequenceName del generador de secuencias.
El siguiente ejemplo utiliza el driver Java de MongoDB para insertar el documento de contador movies_SEQ en la colección hibernate_sequences de la base de datos que indique:
// Replace the placeholders with your connection string and database name.MongoClient client = MongoClients.create("<connection string>");MongoDatabase database = client.getDatabase("<database name>");
database.getCollection("hibernate_sequences").insertOne( new Document("_id", "movies_SEQ") .append("next_value", new BsonInt64(1)) .append("increment", new BsonInt64(50)));La inserción crea el documento contador mostrado. Establezca next_value en el initialValue del generador y increment en su allocationSize.
Guardar una entidad y leer su ID generado
El siguiente ejemplo guarda una nueva entidad Movie e imprime su ID generado. El ID depende del punto de partida de la secuencia. Para un nuevo contador que comienza en 1, la salida es:
var movie = new Movie();movie.setTitle("The Matrix");session.persist(movie);System.out.println("Movie created with ID: " + movie.getId());Configuraciones no admitidas
La extensión de Hibernate ORM no admite las siguientes estrategias, tipos y configuraciones relacionados con secuencias:
IDENTITYy estrategias de generación deTABLEBigIntegeryBigDecimaltipos de identificador generadosNombres de secuencia o esquema que contienen un carácter
.Nombres de secuencia calificados por un catálogo, como un nombre de tres partes o el atributo
catalogSecuencia
options@GenericGeneratory generadores@TableGenerator, generadores personalizados que utilizan una anotación@IdGeneratorType, y generadores heredados con nombre comoidentity,tableoincrementMapear una entidad a la colección
hibernate_sequencesinsert ... selectinstrucciones que requieren asignación en línea de ID generados
IDs generados por UUID
Un UUID es un estandarizado object identifier único de 16bytes que la extensión Hibernate ORM puede generar para sus entidades. Para generar identificadores UUID, anote el campo @Id de su entidad con la anotación @UuidGenerator o establezca el elemento strategy de la anotación @GeneratedValue en UUID. El siguiente ejemplo define una entidad con un ID generado por UUID:
package org.example;
import jakarta.persistence.Entity;import jakarta.persistence.Id;import jakarta.persistence.Table;import java.util.UUID;import org.hibernate.annotations.UuidGenerator;
@Entity@Table(name = "items")public class UuidItem {
@Id @UuidGenerator // or: @GeneratedValue(strategy = GenerationType.UUID) private UUID id;
private String title;
public UuidItem(String title) { this.title = title; }
public UuidItem() { }
// Getter and setter methods}Dónde se almacenan los UUID
La extensión de Hibernate ORM almacena un valor java.util.UUID como un valor BSON Binary con el subtipo 4. El siguiente documento de ejemplo tiene un campo _id con un UUID generado:
{ "_id": { "$binary": { "base64": "FXvL4sBrQoueEByraiJUmA==", "subType": "04" } }, "title": "The Matrix"}Si el campo @Id es un String, la extensión de Hibernate ORM almacena el UUID generado como un String de BSON en lugar de un valor Binary de BSON.
Para aprender más sobre las asignaciones de tipos de campo BSON, consulta la sección Campos BSON de MongoDB de esta guía.
Guardar una entidad y leer su UUID generado
El siguiente ejemplo guarda una nueva entidad UuidItem e imprime su ID generado:
var item = new UuidItem();item.setTitle("The Matrix");session.persist(item);System.out.println("UuidItem created with ID: " + item.getId());Limitaciones de UUID
La extensión de Hibernate ORM tiene las siguientes limitaciones cuando se utilizan ID generados por UUID:
La extensión Hibernate ORM no admite los nombres de generador de identificadores heredados
uuid,uuid.hex,uuid2yguid. Si especifica uno de estos nombres, la extensión Hibernate ORM lanza unFeatureNotSupportedExceptioncuando se inicia su aplicación. Utilice@UuidGeneratoro@GeneratedValue(strategy = GenerationType.UUID)en su lugar.Si asignas el valor de un campo
@UuidGenerator@Idantes de persistir la entidad, la extensión de Hibernate ORM lanza unajakarta.persistence.EntityExistsException. Para asignar valores UUID tú mismo, remover la anotación del generador del campo@Id.
Llaves primarias compuestas
Para clavear una entidad en más de un campo, defina una llave primaria compuesta. Cree una clase o registro @Embeddable simple que contenga los componentes clave. Luego, anote el campo identificador de su entidad con la anotación @jakarta.persistence.EmbeddedId.
El siguiente BookId incrustable define una clave que consta de un componente publisherId y un componente bookNo:
@Embeddablepublic record BookId(long publisherId, long bookNo) {}La siguiente entidad Book utiliza BookId como su llave primaria:
@Entity(name = "Book")@Table(name = "books")public class Book { @EmbeddedId private BookId id; private String title;
public Book() {
}
public Book(BookId id, String title) { this.id = id; this.title = title; }
// Getter and setter methods
}Debe asignar los valores de clave compuesta en su aplicación antes de persistir una entidad. La extensión Hibernate ORM no genera valores de clave compuesta.
Almacenamiento de clave compuesta
La extensión Hibernate ORM almacena una clave compuesta como un subdocumento _id. La entidad precedente Book produce documentos en el siguiente formato:
{ "_id": { "bookNo": 2, "publisherId": 10 }, "title": "My Book"}La extensión Hibernate ORM ordena los componentes del subdocumento _id alfabéticamente por nombre de componente, en lugar de en el orden en que los declara. Este orden es el mismo ya sea que declare el incrustable como una clase o como un registro.
Importante
El orden de los componentes afecta la coincidencia de documentos
MongoDB compara los subdocumentos por orden de campo, por lo tanto, dos valores _id que contienen los mismos componentes en un orden diferente no coinciden. Dado que la extensión Hibernate ORM siempre guarda componentes en el mismo orden, este comportamiento solo le afecta si también lee o guarda estos documentos fuera de la extensión Hibernate ORM, como a través del driver Java de MongoDB.
Limitaciones de la clave compuesta
La extensión Hibernate ORM lanza un FeatureNotSupportedException cuando se inicia la aplicación si declara una clave compuesta de cualquiera de las siguientes maneras:
Un identificador no agregado, declarado con la anotación
@jakarta.persistence.IdClasso con múltiple@Idatributos. Declare la clave con@EmbeddedIden su lugar.Un agregado
@Structincrustable como identificador. Utilice un simple@Embeddableen su lugar.Un componente que no es un valor básico, como un
@Embeddableanidado o una colección. Cada componente de una clave compuesta debe ser un valor básico.Una asociación dentro del identificador, incluida la identidad derivada que utiliza la anotación
@jakarta.persistence.MapsId.
Tampoco se puede comparar un identificador compuesto completo mediante el uso de un operador de ordenación como > o <. Compare los componentes individuales en su lugar.
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 agregados integrables que representan premios de películas e información de los estudios
El siguiente ejemplo representa una relación uno a uno porque cada entidad Movie se asocia con un Awards incrustable y un Studio incrustable:
@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 embebible 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 una Studio @Struct agregada incrustable:
@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
}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:
@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 una Writer @Struct agregada incrustable:
@Embeddable@Struct(name = "Writer")public class Writer { private String name;
public Writer() { }
public Writer(String name) { this.name = name; }
// Getter and setter methods
}Embeddables anidados
Puede anidar un incrustable aplanado dentro de un incrustable agregado @Struct. Un incrustable aplanado es una clase que incluye una anotación @Embeddable pero no una anotación @Struct. La extensión Hibernate ORM almacena los campos de un incrustable aplanado como campos del documento incrustado principal en lugar de como un documento anidado independiente.
El siguiente código de muestra crea un incrustable agregado Studio @Struct que incluye un incrustable aplanado Address como campo:
@Embeddable@Struct(name = "Studio")public class Studio { private String name; private Address address;
public Studio() { }
public Studio(String name, Address address) { this.name = name; this.address = address; }
// Getter and setter methods
}El siguiente código de muestra crea el incrustable aplanado Address. La clase omite la anotación @Struct:
@Embeddablepublic class Address { private String city; private String country;
public Address() { }
public Address(String city, String country) { this.city = city; this.country = country; }
// Getter and setter methods
}Cuando se persiste una entidad que incluye un campo Studio, los campos Address se convierten en campos del documento incrustado del campo Studio. El siguiente documento de ejemplo tiene un campo Studio denominado studio que almacena los campos de su incrustable aplanado Address:
{ "_id": { "$oid": "..." }, "title": "Breathless", "studio": { "name": "Les Films Impéria", "city": "Paris", "country": "France" }}Información Adicional
Para aprender a asignar una jerarquía de clases a una colección de MongoDB, consulte la guía Asignar una jerarquía de herencia de entidades.
Para aprender a usar tus entidades para ejecutar operaciones de base de datos, consulta 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.