¿Qué es JPA?

JPA significa Jakarta Persistence API (anteriormente, Java Persistence API). Es una especificación de una API para conectividad de bases de datos desde aplicaciones Java. Dado que JPA es solo una especificación, necesitas una implementación para poder usarla. La implementación más popular es Hibernate ORM.

ORM significa Mapeo Objeto/Relacional (Object-Relational Mapping) y es una técnica para representar tablas SQL en objetos Java (o de cualquier otro lenguaje de programación) y viceversa. Por ejemplo, tal vez tienes una tabla programming_language en la base de datos y quieres leer filas de allí y almacenarlas en objetos Java de una clase que creaste, por ejemplo, ProgrammingLanguage. Lo que tienes que hacer es usar anotaciones JPA (o configuraciones XML equivalentes, que, para ser honesto, hace años que no veo un proyecto usando XML en lugar de anotaciones JPA) para decirle al framework ORM cómo poner los datos de la base de datos en los campos Java y cómo poner datos de los campos Java en la tabla SQL. El siguiente es un ejemplo:

import jakarta.persistence.*;

@Entity
@Table(name = "programming_language")
public class ProgrammingLanguage {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "pl_id")
    private Integer id;

    @Column(name = "pl_name")
    private String name;

    @Column(name = "pl_rating")
    private Integer rating;

    ... equals, hashCode, setters, getters ...
}

Esto te permite leer y escribir datos. Por ejemplo:

EntityManagerFactory entityManagerFactory =
    Persistence.createEntityManagerFactory("jpa-demo-local");

EntityManager entityManager = entityManagerFactory.createEntityManager();
EntityTransaction transaction = entityManager.getTransaction();

transaction.begin();

// escribir datos:
entityManager.persist(new ProgrammingLanguage("Java", 10));

// leer datos:
List<ProgrammingLanguage> list = entityManager.createQuery(
		"select p from ProgrammingLanguage p where p.rating > 5",
		ProgrammingLanguage.class
).getResultList();

transaction.commit(); // o transaction.rollback();

Para que esto funcione, también necesitas definir una Unidad de Persistencia (Persistence Unit). Esto lo puedes hacer en un archivo XML llamado persistence.xml en el que se define el nombre utilizado para crear el EntityManagerFactory en el fragmento de código anterior más los detalles de conexión de la base de datos:

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
    <persistence-unit name="jpa-demo-local" transaction-type="RESOURCE_LOCAL">
        <properties>
            <property name="jakarta.persistence.jdbc.url" value="jdbc:mariadb://localhost:3306/jpa_demo"/>
            <property name="jakarta.persistence.jdbc.user" value="usuario"/>
            <property name="jakarta.persistence.jdbc.password" value="contraseña"/>
            <property name="jakarta.persistence.schema-generation.database.action" value="drop-and-create"/>
        </properties>
    </persistence-unit>
</persistence>

Realmente, esta fue una introducción extremadamente corta, pero tengo un video más detallado aunque introductorio que demuestra cómo usar JPA con Hibernate. Échale un vistazo: