Skip to content

09. Java Persistence API (JPA)

Jump to bottom
Melissa Diaz edited this page Feb 20, 2025 · 2 revisions

JPA

JPA (Java Persistence API) es una especificación estándar de Java para la programación de persistencia, basada en el paradigma ORM (Object Relational Mapping). Su objetivo es permitir que las aplicaciones interactúen con bases de datos utilizando objetos en lugar de escribir consultas SQL manualmente.

Ventajas de JPA sobre JDBC

  • JDBC requiere escribir consultas SQL directamente, lo que puede generar errores y aumentar la complejidad.
  • JPA simplifica la persistencia de datos al mapear objetos Java a tablas de base de datos mediante anotaciones o XML.
  • Permite trabajar con bases de datos sin depender de código SQL específico.

Proveedores de JPA más conocidos

  • Hibernate
  • ObjectDB
  • EclipseLink
  • OpenJPA

Características principales de JPA

  • Usa EntityManager para manejar operaciones como insertar, actualizar y eliminar datos.
  • Proporciona JPQL (Java Persistence Query Language) para realizar consultas sin necesidad de escribir SQL.
  • Se encarga automáticamente de la conversión entre tipos Java y tipos SQL.
  • Genera y ejecuta las consultas SQL necesarias internamente, evitando que el programador escriba código JDBC manual.

Note

JPA facilita la persistencia de objetos y permite que el desarrollo en Java mantenga la orientación a objetos sin perder eficiencia al trabajar con bases de datos.

Arquitectura de JPA

JPA (Java Persistence API) está diseñada para gestionar entidades y sus relaciones en bases de datos. Sus principales componentes son:

  • Entidad (@Entity): Clase Java que representa una fila en una tabla. Cada atributo mapea una columna.
  • Persistence: Clase que obtiene instancias de EntityManagerFactory, el punto de entrada a la persistencia.
  • EntityManagerFactory: Crea y gestiona EntityManager, configurándose una sola vez en la aplicación.
  • EntityManager: Gestiona operaciones de persistencia (crear, leer, actualizar, eliminar) y consultas.
  • Query: Interfaz para ejecutar consultas JPQL y obtener resultados.
  • EntityTransaction: Maneja transacciones en la base de datos (inicio, confirmación, reversión).

Mapeo con Anotaciones en JPA

JPA permite transformar objetos en tablas mediante ORM (Object-Relational Mapping), utilizando anotaciones:

Anotaciones principales

Anotación Descripción
@Entity Declara una clase como entidad mapeada a una tabla.
@Table(name="tabla") Especifica el nombre de la tabla en la BD (opcional).
@Id Indica la clave primaria.
@GeneratedValue(strategy=GenerationType.IDENTITY) Genera automáticamente la clave primaria.
@Column(name="columna", length=50, nullable=false, unique=true) Mapea un atributo con una columna, permitiendo configurar restricciones.
@Enumerated(EnumType.STRING) Almacena un enum como STRING u ORDINAL.
@Temporal(TemporalType.DATE) Define cómo se almacenan fechas (DATE, TIME, TIMESTAMP).

Ejemplo: Definir una Entidad en JPA

Clase sin entidad

public class Empleado {
    private Long id;
    private String nombre;
}

No está vinculada a la base de datos.

Convertirla en Entidad JPA

@Entity
public class Empleado {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String nombre;
}

Ahora JPA la reconoce y la mapea a una tabla.

Clave primaria y generación automática

@Entity
public class Empleado {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String nombre;
}
  • @Id: Define la clave primaria.
  • @GeneratedValue(strategy = GenerationType.IDENTITY): Delega la generación del ID a la base de datos (autoincrementable).

Mapeo de Fechas con @Temporal

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

    private String nombre;

    @Temporal(TemporalType.DATE) // Solo almacena la fecha
    private Date fechaNacimiento;
}

Opciones de @Temporal:

  • DATE: Solo almacena la fecha.
  • TIME: Solo almacena la hora.
  • TIMESTAMP: Almacena fecha y hora.

Relaciones en JPA

En bases de datos relacionales, las tablas pueden estar relacionadas entre sí. JPA permite reflejar estas relaciones en el código mediante anotaciones.

Tipos de Relaciones en JPA

Anotación Descripción
@OneToOne Relación uno a uno.
@OneToMany Relación uno a muchos.
@ManyToOne Relación muchos a uno.
@ManyToMany Relación muchos a muchos.

Ejemplos de Relaciones

1. Relación @OneToOne

Un curso tiene un único profesor, y un profesor pertenece a un solo curso:

@Entity
public class Curso {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne
    private Profesor profesor;
}

📌 Base de datos: Se genera una tabla Curso con una clave foránea que apunta a Profesor.

2. Relación @ManyToOne

Varios álbumes pueden pertenecer a un solo autor:

@Entity
public class Album {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    private Autor autor;
}

📌 Base de datos: La tabla Album tendrá una columna que referencia a Autor.

3. Relación @ManyToMany

Cada empleado puede tener varias tareas, y cada tarea puede asignarse a varios empleados:

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

    @ManyToMany
    private List<Tarea> tareas;
}

📌 Base de datos: Se requiere una tabla intermedia para gestionar la relación.

Tablas Intermedias en Relaciones @ManyToMany

Como SQL no permite almacenar múltiples valores en una celda, se usa una tabla intermedia para gestionar relaciones muchos a muchos.

Ejemplo de estructura:

Tablas principales:

Empleado Tarea
ID, Nombre ID, Nombre

Tabla intermedia:

ID_Empleado ID_Tarea
95 624
95 915
28 567
28 624

📌 Clave primaria compuesta: La tabla intermedia almacena solo los IDs de las entidades relacionadas.

Creación de proyecto con JPA

1️⃣ Crear la Base de Datos

CREATE DATABASE nomrebasededatos;

Esto creará la base de datos vacía para el proyecto.

2️⃣ Crear un Proyecto Maven

  • Crear un proyecto Maven.
  • Configura valores:
    • groupId:
    • artifactId:

3️⃣ Agregar Dependencias en pom.xml

Incluye las siguientes dependencias esenciales:

  • Hibernate como ORM.
  • Jakarta Persistence API (jakarta.persistence-api).
  • MySQL Connector (mysql-connector-j).
  • EclipseLink (opcional).

Ejecuta:

mvn clean install

para instalar las dependencias.

4️⃣ Crear el Archivo de Persistencia (persistence.xml)

  • Ubícalo dentro de src/main/resources/META-INF/.
  • Configura la conexión a la base de datos:
<persistence-unit name="NombreBaseDeDatos" transaction-type="RESOURCE_LOCAL">
    <properties>
        <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/vivero2?serverTimezone=UTC"/>
        <property name="jakarta.persistence.jdbc.user" value="root"/>
        <property name="jakarta.persistence.jdbc.password" value="root"/>
        <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jakarta.persistence.schema-generation.database.action" value="update"/>
    </properties>
</persistence-unit>

5️⃣ Crear Entidades y Mapear Relaciones

  • Crea un paquete entidades dentro de com.egg.
  • Define una clase por cada tabla del modelo.
  • Usa las anotaciones:
    • @Entity para marcar la clase como entidad.
    • @Table(name = "nombre_tabla") para mapearla con la base de datos.
    • @Id y @GeneratedValue para la clave primaria.
    • @Column(name = "nombre_columna") para mapear atributos.
    • @ManyToOne, @OneToMany para definir relaciones.

Clone this wiki locally