JPA Remove y Objetos gestionados

¿Te gustaría Java desde cero?
Tenemos los diplomados que necesitas.¡Haz clic aquí!

El concepto de JPA Remove y sus peculiaridades . Java Persistence API siempre tiene curiosidades incluso en el manejo de operaciones que nos pueden parecer esenciales o básicas . Vamos a ver un ejemplo del uso de JPA remove para eliminar entidades de una base de datos. Supongamos que disponemos de la clase Libro.

1. package com.arquitecturajava.jpabasico.dominio;
3. import java.util.Date;
5. import javax.persistence.Entity;
6. import javax.persistence.Id;
8. @Entity
9. public class Libro {
10. @Id
11. private String isbn;
12. private String titulo;
13. private String autor;
14. private Date fecha;
15. private int precio;
17. public String getIsbn() {
18. return isbn;
19. }
21. public void setIsbn(String isbn) {
22. this.isbn = isbn;
23. }
25. public String getTitulo() {
26. return titulo;
27. }
29. public void setTitulo(String titulo) {
30. this.titulo = titulo;
31. }
33. public String getAutor() {
34. return autor;
35. }
37. public void setAutor(String autor) {
38. this.autor = autor;
39. }
41. public Date getFecha() {
42. return fecha;
43. }
45. public void setFecha(Date fecha) {
46. this.fecha = fecha;
47. }
49. public int getPrecio() {
50. return precio;
51. }
53. public void setPrecio(int precio) {
54. this.precio = precio;
55. }
57. public Libro(String isbn, String titulo, String autor, Date fecha, int precio) {
58. super();
59. this.isbn = isbn;
60. this.titulo = titulo;
61. this.autor = autor;
62. this.fecha = fecha;
63. this.precio = precio;
64. }
68. public Libro(String isbn) {
69. super();
70. this.isbn = isbn;
71. }
73. public Libro() {
74. super();
75. }
77. @Override
78. public String toString() {
79. return «Libro [isbn=» + isbn + «, titulo=» + titulo + «, autor=» + autor + «]»;
80. }
82. }

Esta clase esta construida con los métodos set y get y las anotaciones de JPA que nos permiten persistirla en la base de datos . Evidentemente tendremos que configurar nuestro proyecto para que sea un proyecto Maven e incluya las dependencias necesarias.

1. <project xmlns=«http://maven.apache.org/POM/4.0.0»
2. xmlns:xsi=«http://www.w3.org/2001/XMLSchema-instance»
3. xsi:schemaLocation=«http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd»>
4. <modelVersion>4.0.0</modelVersion>
5. <groupId>com.arquitecturajava</groupId>
6. <artifactId>jpabasico</artifactId>
7. <version>0.0.1-SNAPSHOT</version>
8. <dependencies>
10. <!– https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.1-api –>
11. <dependency>
12. <groupId>org.hibernate.javax.persistence</groupId>
13. <artifactId>hibernate-jpa-2.1-api</artifactId>
14. <version>1.0.2.Final</version>
15. </dependency>
16. <!– https://mvnrepository.com/artifact/org.hibernate/hibernate-core –>
17. <dependency>
18. <groupId>org.hibernate</groupId>
19. <artifactId>hibernate-core</artifactId>
20. <version>5.4.11.Final</version>
21. </dependency>
22. <!– https://mvnrepository.com/artifact/mysql/mysql-connector-java –>
23. <dependency>
24. <groupId>mysql</groupId>
25. <artifactId>mysql-connector-java</artifactId>
26. <version>6.0.6</version>
27. </dependency>
30. </dependencies>
31. </project

Una vez tenemos todas las dependencias instaladas. Es momento de construir el fichero persistence.xml que quedará ubicado dentro de la carpeta /resources/META-INF

1. <?xml version=»1.0″ encoding=»UTF-8″?>
2. <persistence version=»2.1″ xmlns=»http://xmlns.jcp.org/xml/ns/persistence» xmlns:xsi=»http://www.w3.org/2001/XMLSchema-instance» xsi:schemaLocation=»http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd»>
4. <persistence-unit name=»unidadLibros»>
5. <class>com.arquitecturajava.jpabasico.dominio.Libro</class>
6. <properties>
7. <property name= «hibernate.show_sql» value=»true» />
8. <property name=»hibernate.dialect» value=»org.hibernate.dialect.MySQLDialect» />
9. <property name=»javax.persistence.jdbc.driver» value=»com.mysql.jdbc.Driver» />
10. <property name=»javax.persistence.jdbc.user» value=»root» />
11. <property name=»javax.persistence.jdbc.password» value=»root» />
12. <property name=»javax.persistence.jdbc.url» value=»jdbc:mysql://localhost/jpa1″ />
13. </properties>
15. </persistence-unit>
16. </persistence>

JPA Remove y EntityManager

El fichero se encarga de configurar de forma rápida la conexión a la base de datos. Una vez hecho esto es cuestión de construir un programa main que sea el encargado de realizar un JPA remove. La primera casuística es muy sencilla:

1. package com.arquitecturajava.jpabasico;
3. import javax.persistence.EntityManager;
4. import javax.persistence.EntityManagerFactory;
5. import javax.persistence.Persistence;
7. import com.arquitecturajava.jpabasico.dominio.Libro;
9. public class Principal3Borrar {
11. public static void main(String[] args) {
15. EntityManagerFactory emf = Persistence.createEntityManagerFactory(«unidadLibros»);
17. EntityManager em = emf.createEntityManager();
18. Libro miLibro = em.find(Libro.class, «1A»);
19. try {
20. em.getTransaction().begin();
21. em.remove(miLibro);
22. em.getTransaction().commit();
23. } catch (Exception e) {
24. e.printStackTrace();
25. } finally {
26. em.close();
28. }
30. }
31. }

En este caso se usa el EntityManagerFactory para obtener la conexión a la base de datos y el EntityManager como gestor de entidades para buscar la entidad en la base de datos y abrir una transacción que se encargue de borrarla.

Si ejecutamos nuestro código este borrará un elemento de la base de datos. Hasta aquí todo correcto. Ahora bien que pasará cuando ejecutemos el código sin usar previamente el EntityManager para buscar la entidad .

1. package com.arquitecturajava.jpabasico;
3. import javax.persistence.EntityManager;
4. import javax.persistence.EntityManagerFactory;
5. import javax.persistence.Persistence;
7. import com.arquitecturajava.jpabasico.dominio.Libro;
9. public class Principal3Borrar2 {
11. public static void main(String[] args) {
15. EntityManagerFactory emf = Persistence.createEntityManagerFactory(«unidadLibros»);
17. EntityManager em = emf.createEntityManager();
18. Libro miLibro = new Libro(«1A»);
19. try {
20. em.getTransaction().begin();
21. em.remove(miLibro);
22. em.getTransaction().commit();
23. } catch (Exception e) {
24. e.printStackTrace();
25. } finally {
26. em.close();
28. }
30. }
31. }

La realidad es que el código falla y se lanza una excepción.

JPA y Merge

Mucha gente cuando comienza con JPA no entiende muy bien que es lo que esta sucediendo. Sin embargo es totalmente normal ya que la entidad no esta siendo gestionada por el EntityManager previamente y una entidad que no este gestionada no puede ser borrada .

Para solventar este problema debemos usar el método Merge del API del EntityManager para previamente poner la entidad bajo el control de JPA

1. package com.arquitecturajava.jpabasico;
3. import javax.persistence.EntityManager;
4. import javax.persistence.EntityManagerFactory;
5. import javax.persistence.Persistence;
7. import com.arquitecturajava.jpabasico.dominio.Libro;
9. public class Principal5BorrarMerge {
11. public static void main(String[] args) {
13. Libro miLibro = new Libro(«1A»);
15. EntityManagerFactory emf = Persistence.createEntityManagerFactory(«unidadLibros»);
16. EntityManager em = emf.createEntityManager();
19. try {
20. em.getTransaction().begin();
21. em.remove(em.merge(miLibro));
22. em.getTransaction().commit();
23. } catch (Exception e) {
24. e.printStackTrace();
25. } finally {
26. em.close();
28. }
30. }
31. }

De esta forma si que JPA será capaz de eliminar la entidad de la base de datos .

Otros artículos relacionados

• Ejemplo JPA
• JPA EntityGraph
• Open Session in View
• Java Persistence API

Te esperamos en los siguientes artículos en donde hablaremos mas acerca de estos temas, los cuales hoy en día son de vital importancia en el mundo de la tecnología.

¿Te gustaría Java desde cero?
Tenemos los diplomados que necesitas.¡Haz clic aquí!