Tutorial Hibernate: Tipos de datos en Hibernate

Introducción

A través de su sistema de tipos, Hibernate puede convertir, por ejemplo, una cadena en Java (String) a un tipo VARCHAR en una base de datos y viceversa. 

Sin embargo, no siempre es tan sencillo, y es por eso que Hibernate ofrece una amplia variedad de tipos de datos, así como la capacidad de definir tipos personalizados, permitiendo a los desarrolladores controlar cómo se realizan estas conversiones y adaptarlas a las necesidades específicas de su aplicación.

Tipos básicos

Los tipos básicos en Hibernate son una categoría de tipos que corresponden directamente a los tipos Java estándar. Estos tipos están diseñados para ofrecer un mapeo simple y directo entre las columnas de la base de datos y los campos de las entidades Java.

La ventaja de estos tipos básicos es que facilitan el proceso de mapeo y requieren una configuración mínima. Hibernate ya conoce cómo mapear estos tipos de datos, y para la mayoría de las aplicaciones, estos mapeos predeterminados son suficientes.

Algunos ejemplos comunes de tipos básicos en Hibernate incluyen:

Tipos primitivos de Java y sus contrapartes envolventes:

• int y Integer: se mapean generalmente a columnas de tipo INTEGER en bases de datos.
• long y Long: se mapean a BIGINT o equivalentes.
• boolean y Boolean: suelen mapearse a BOOLEAN o, en algunas bases de datos, a BIT o TINYINT.
• char y Character: pueden mapearse a columnas CHAR de longitud 1.

Objetos comunes en Java:

• String: generalmente se mapea a VARCHAR o TEXT, dependiendo de la longitud.
• Date y Timestamp de java.util: a menudo se mapean a columnas de tipo DATE o TIMESTAMP en bases de datos.

Tipos numéricos de precisión arbitraria:

• BigInteger: se mapea a columnas BIGINT.
• BigDecimal: se mapea a columnas de tipo DECIMAL o NUMERIC.

Arrays y Colecciones:

• Listas, conjuntos y mapas (List, Set, Map) tienen tipos específicos en Hibernate para manejar colecciones de entidades o valores.

Ejemplo

Ejemplo de tipos de datos sobre una entidad Employee

import jakarta.persistence.*;

@Entity
@Table(name = "employee")
public class Empleado {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "titulo", length = 200)
    private String titulo;

    @Temporal(TemporalType.DATE)
    @Column(name = "fecha_publicacion")
    private Date fechaPublicacion;
    
    @Temporal(TemporalType.TIME)
    @Column(name = "wake_time")
    private Date wakeTime;
    
    @Column(name="test_date")
    private Instant testDate;
    
    @Enumerated(EnumType.STRING)
    private ContractType type;
    
    @ElementCollection
    @CollectionTable(
            name = "employee_phones",
            joinColumns = @JoinColumn(name = "id_employee")
    )
    private List<String> phones= new ArrayList<>();
    
    @Column(columnDefinition = "boolean default false")
    private Boolean active;

    // constructor vacío
    // getters y setters...
}

El campo id es de tipo Long en Java y, por defecto, Hibernate lo mapeará a una columna de tipo BIGINT en la base de datos.

El campo titulo es de tipo String y se mapeará a una columna VARCHAR con una longitud máxima de 200 caracteres.

El campo fechaPublicacion es del tipo Date de java.util. Al usar la anotación @Temporal, se indica a Hibernate que debe mapearse a una columna DATE en la base de datos.

Es importante notar que, si bien estos tipos básicos cubren una amplia gama de necesidades comunes, hay situaciones en las que se pueden requerir mapeos más complejos o personalizados. Es en esos casos donde los tipos personalizados y otros mecanismos avanzados de Hibernate entran en juego.