Para insertar datos en una base de datos usando JPA, lo primero que debemos entender es cómo crear una entidad y hacer que esta sea persistente en el sistema. En nuestro ejemplo, vamos a crear un empleado con un identificador, nombre y fecha de nacimiento. Para manejar las fechas, utilizamos la antigua API de Java, concretamente GregorianCalendar, ya que JPA no soporta directamente la nueva API de Java 8 para fechas sin añadir librerías adicionales.
Creamos un empleado llamado Pepito Pérez, con identificador 10 y fecha de nacimiento el 6 de junio de 1979, usando el siguiente código:
Empleado e = new Empleado();
e.setId(10L);
e.setApellidos("Pérez");
e.setNombre("Pepito");
GregorianCalendar gc = new GregorianCalendar(1979, Calendar.JUNE, 6);
e.setFechaNacimiento(gc.getTime());
Una vez que tenemos el objeto empleado en nuestra aplicación, el siguiente paso es iniciar una transacción para poder insertar este empleado en la base de datos. Para ello, utilizamos el EntityManager y comenzamos la transacción con getTransaction().begin(). Entre el inicio y el final de la transacción, que se marca con commit(), podemos realizar todas las operaciones que queramos que se ejecuten de forma atómica.
Las transacciones nos permiten asegurarnos de que todas las operaciones se ejecutan correctamente o, en caso de error, revertir los cambios con un rollback para mantener la integridad de la base de datos.
Para insertar el empleado, usamos el método persist del EntityManager. Este método hace que la entidad pase a estar gestionada por JPA, lo que significa que cualquier cambio posterior que hagamos sobre esta entidad será automáticamente sincronizado con la base de datos sin necesidad de llamar de nuevo a persist.
El flujo para insertar el empleado sería así:
manager.getTransaction().begin();
manager.persist(e);
manager.getTransaction().commit();
Para comprobar que el empleado se ha insertado correctamente, podemos crear un método que imprima todos los empleados almacenados en la base de datos. Este método obtiene la lista de empleados con una consulta JPQL y luego imprime sus datos:
private static void imprimirTodo() {
List<Empleado> empleados = manager.createQuery("from Empleado", Empleado.class).getResultList();
for (Empleado empleado : empleados) {
System.out.println(empleado);
}
}
Podemos insertar más empleados sin problema, por ejemplo:
Empleado e2 = new Empleado();
e2.setId(25L);
e2.setApellidos("Martínez");
e2.setNombre("José");
GregorianCalendar gc2 = new GregorianCalendar(1984, Calendar.OCTOBER, 10);
e2.setFechaNacimiento(gc2.getTime());
manager.getTransaction().begin();
manager.persist(e2);
manager.getTransaction().commit();
Es importante destacar que en este ejemplo estamos usando una base de datos en memoria (H2), por lo que los datos se perderán al cerrar la aplicación. En un entorno real, los datos se mantendrían persistentes.
Cuando una entidad está gestionada (o manager), significa que JPA la controla y cualquier cambio que hagamos sobre ella se reflejará automáticamente en la base de datos cuando se sincronice el contexto de persistencia. Esto nos facilita mucho el trabajo, ya que no tenemos que preocuparnos por llamar a persist o merge cada vez que modificamos un objeto.
En resumen, con persist hacemos que una entidad pase a estar gestionada y se inserte en la base de datos al hacer commit. Luego, cualquier cambio posterior en esa entidad será detectado y sincronizado automáticamente por JPA.
Más adelante profundizaremos en el ciclo de vida de las entidades y en qué significa exactamente que una entidad esté gestionada o esté detached, pero por ahora este es el flujo básico para insertar datos con JPA y entender cómo funcionan las transacciones y la persistencia.