Construyendo una Entity

Para crear una entidad JPA en Java que nos permita almacenar datos en una base de datos, lo primero que debemos hacer es definir una clase que represente nuestro modelo de datos. En este caso, vamos a crear una clase llamada Empleado, que contendrá campos básicos como un código de empleado, apellidos, nombre y fecha de nacimiento. Estos campos serán los atributos que queremos persistir.

Al definir esta clase, es importante importar las clases necesarias, como java.util.Date para la fecha de nacimiento, y tener en cuenta que JPA y Hibernate manejan internamente la conversión de tipos comunes de Java a los tipos adecuados en la base de datos. Por ejemplo, saben cómo trabajar con cadenas, números, fechas e incluso arrays de bytes, aunque para colecciones más complejas o relaciones entre entidades necesitaremos anotaciones adicionales.

Un aspecto fundamental para que Hibernate funcione correctamente es que nuestra entidad tenga un constructor vacío. Esto es necesario porque el framework utiliza este constructor para crear instancias de la entidad cuando recupera datos de la base. Además, por comodidad y para facilitar la creación de objetos, podemos añadir constructores que reciban parámetros para inicializar los campos directamente.

También debemos implementar los métodos getter y setter para cada uno de los campos, ya que JPA los utiliza para acceder y modificar los valores de la entidad. Un método toString puede ser útil para imprimir rápidamente la información de un empleado durante pruebas o depuración.

Aunque no siempre es obligatorio, es recomendable que nuestra entidad implemente la interfaz Serializable. Esto es especialmente importante si la entidad va a ser transmitida de forma remota o almacenada en sesiones, evitando problemas relacionados con la serialización. Al implementar esta interfaz, debemos definir un identificador de versión serialVersionUID.

Para que JPA reconozca nuestra clase como una entidad, debemos anotarla con @Entity del paquete javax.persistence. Es importante usar las anotaciones estándar de JPA y no las específicas de un proveedor como Hibernate, para mantener la portabilidad del código.

Luego, para indicar cómo se mapea esta entidad a la base de datos, usamos la anotación @Table, también de javax.persistence. Podemos dejar que JPA asigne un nombre por defecto a la tabla o especificar uno explícitamente con el atributo name. Por ejemplo, podemos indicar que la tabla se llame empleado o table_empleado.

Cada campo que queremos persistir debe estar anotado con @Column, donde podemos definir detalles como el nombre de la columna, la longitud para cadenas de texto, la precisión para números decimales o si el valor debe ser único. Esto nos permite controlar cómo se crean las columnas en la base de datos y aplicar restricciones.

Un requisito indispensable es que toda entidad tenga un identificador único, que se marca con la anotación @Id. En nuestro ejemplo, el campo codigo será el identificador. Esto es crucial para que JPA pueda distinguir cada registro y realizar operaciones como búsquedas o actualizaciones. Más adelante, podemos configurar la generación automática de estos identificadores para que se asignen secuencialmente o mediante otras estrategias, pero por ahora basta con declararlo.

Con estos pasos, ya tenemos nuestra entidad Empleado lista para ser utilizada con JPA y Hibernate, pudiendo crear, guardar y recuperar objetos de la base de datos de forma sencilla y estructurada.

Un ejemplo básico de cómo quedaría esta clase es el siguiente:

package com.ejemplo.modelo;

import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.Column;
import java.io.Serializable;
import java.util.Date;

@Entity
@Table(name = "empleado")
public class Empleado implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @Column(name = "codigo")
    private Long codigo;

    @Column(name = "apellidos", length = 50)
    private String apellidos;

    @Column(name = "nombre", length = 50)
    private String nombre;

    @Column(name = "fecha_nacimiento")
    private Date fechaNacimiento;

    public Empleado() {
        // Constructor vacío necesario para JPA
    }

    public Empleado(Long codigo, String apellidos, String nombre, Date fechaNacimiento) {
        this.codigo = codigo;
        this.apellidos = apellidos;
        this.nombre = nombre;
        this.fechaNacimiento = fechaNacimiento;
    }

    public Long getCodigo() {
        return codigo;
    }

    public void setCodigo(Long codigo) {
        this.codigo = codigo;
    }

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public Date getFechaNacimiento() {
        return fechaNacimiento;
    }

    public void setFechaNacimiento(Date fechaNacimiento) {
        this.fechaNacimiento = fechaNacimiento;
    }

    @Override
    public String toString() {
        return "Empleado{" +
                "codigo=" + codigo +
                ", apellidos='" + apellidos + '\'' +
                ", nombre='" + nombre + '\'' +
                ", fechaNacimiento=" + fechaNacimiento +
                '}';
    }
}

Con esta estructura, ya podemos empezar a trabajar con nuestra entidad, persistiendo objetos Empleado en la base de datos y realizando consultas. Más adelante, veremos cómo configurar la generación automática de identificadores y cómo interactuar con el sistema de persistencia para guardar y recuperar datos.