¿Qué es JPA (Java Persistence API)?

JPA es una especificación de API para la gestión de la persistencia de datos en aplicaciones Java. Proporciona una forma estándar de mapear objetos Java a bases de datos relacionales (u otros almacenes de datos) y viceversa. JPA es parte de la plataforma Java EE (ahora Jakarta EE) y también puede usarse en aplicaciones independientes.

Componentes clave de JPA:

• Entidad: Clases Java normales (POJO), marcadas con la anotación @Entity, que representan datos en la base de datos.
• EntityManager: Interfaz para interactuar con el contexto de persistencia. Se usa para buscar, crear, actualizar y eliminar entidades.
• Contexto de Persistencia: Conjunto de entidades gestionadas por EntityManager. Aquí se rastrean los cambios en las entidades antes de sincronizarlos con la base de datos.
• JPQL (Java Persistence Query Language): Lenguaje de consultas orientado a objetos, similar a SQL, pero que opera con entidades y sus relaciones en lugar de tablas y columnas.
• Criteria API: API orientada a objetos para realizar consultas dinámicas.
• persistence.xml: Archivo de configuración que describe las unidades de persistencia y sus propiedades (por ejemplo, información de conexión a la base de datos, estrategias de mapeo).

JPA no es una implementación concreta de ORM (Object-Relational Mapping), sino que define contratos y API. Existen varios proveedores de JPA que implementan esta especificación, siendo los más populares:

• Hibernate
• EclipseLink
• Apache OpenJPA

Ejemplo de definición de entidad:

// Entidad que representa un registro en la tabla `products`
@Entity
// Nombre de la tabla en la base de datos
@Table(name = "products")
public class Product {

    // Clave primaria
    @Id
    // Estrategia de generación de clave primaria
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Columna `name` en la tabla
    private String name;

    // Columna `price` en la tabla
    private BigDecimal price;

    // Constructores, getters y setters
    // ...
}

Ejemplo de uso de EntityManager:

// Obtención de EntityManager desde EntityManagerFactory
EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPersistenceUnit");
EntityManager em = emf.createEntityManager();

try {
    // Inicio de transacción
    em.getTransaction().begin();

    // Creación de una nueva entidad
    Product newProduct = new Product();
    newProduct.setName("Laptop");
    newProduct.setPrice(new BigDecimal("1200.00"));

    // Guardar la entidad en la base de datos
    em.persist(newProduct);

    // Buscar una entidad por clave primaria
    Product foundProduct = em.find(Product.class, 1L);
    System.out.println("Producto encontrado: " + foundProduct.getName());

    // Ejecutar consulta JPQL
    List<Product> allProducts = em.createQuery("SELECT p FROM Product p", Product.class).getResultList();
    for (Product p : allProducts) {
        System.out.println(p.getName());
    }

    // Confirmar transacción
    em.getTransaction().commit();

} catch (Exception e) {
    // Revertir transacción en caso de error
    if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
    }
    e.printStackTrace();
} finally {
    // Cerrar EntityManager
    em.close();
    // Cerrar EntityManagerFactory
    emf.close();
}

El objetivo principal de JPA es simplificar el desarrollo de aplicaciones que trabajan con bases de datos, abstraiendo los detalles de bajo nivel del trabajo con JDBC y SQL, proporcionando un enfoque orientado a objetos para la persistencia. Esto aumenta la portabilidad del código y reduce su dependencia de una base de datos específica.