ORM - JPA

Ing. Carlos Camacho

Object Relational Mapping - ORM
● Técnica de programación para convertir el modelo de objeto a su
correspondencia con el modelo de base de datos relacional.
● Permiten ahorrar tiempo en los procesos de manipulación de la información
desde un sistema.
● Permiten utilizar conceptos de herencia y polimorfismo en el modelo
relacional.
● Incluye seguridad
Java Persistence API - JPA
● Representa una abstracción sobre JDBC que permite aplicar los conceptos
ORM en Java.
● Permite conversión de modelo objeto a relacional y viceversa.
● Puede ser utilizada en las versiones JSE y JEE.
● Representa un interfaz común entre los diferentes proveedores de
persistencia.
● Cubre tres áreas:
○ API de persistencia.
○ Java Persistence Query Language (JPQL)
○ Metadatos
● Estamos en la versión 2.2 liberada en el 2017 y actualiza al 2019, JSR 338.
Nueva versión 3, lanzada noviembre 2020.
Diferentes proveedores de persistencia
● Hibernate
● EclipseLink
● OpenJPA
● TopLink
API de Persistencia
Entidades
● Representan POJOs, anotados @Entity. Indica que dicha clase será
gestionada por el proveedor de persistencia
● Para ser considerada una clase entidad debe cumplir las siguientes reglas:
○ Tener sus propiedades accedida mediante metodos set y get (POJO).
○ Contar con un constructor por defecto
○ No puede ser Final.
○ Ser una clase de primer nivel.
○ Implementar la interface java.io.Serializable
○ Debemos indicar la propiedad que representa la clave primaria, @Id,@EmbeddedId o
@IdClass.
● Existen otras anotaciones para indicar configuración de la entidad y la tabla.
@Table, entre otras.
Ejemplo Entidad
import javax.persistence.Entity; //Clases necesarias de JPA
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity //Indica que es una entidad

public class Estudiante implements Serializable {
@Id //La propiedad Id, será la clave primaria
@GeneratedValue // indica la generación será automática
private Integer matricula;
private String nombre; //Otras propiedades.

// Getters y Setters
}
Uso de JPA
● Para configurar JPA necesitamos trabajar con el archivo de configuración
llamado persistence.xml el cual debe estar ubicado en la carpeta META-INF
del resources.
● Dicho archivo contiene la configuración necesaria para conectarnos a la base
de datos que estemos trabajando.
● Tenemos dos niveles de manejo de validaciones en transacción:
○ Manejada por la aplicación (RESOURCE_LOCAL)
○ Manejada por el contenedor (JTA) //disponible en servidores de aplicaciones.
● Los estados de una entidad:
○ Gestionadas (Managed)
○ Separadas (Detached)
Ejemplo Archivo persistence.xml
<persistence 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"
version="2.1">
<persistence-unit name="MiUnidadPersistencia" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<class>com.avathartech.sparkjavaorm.entidades.Estudiante</class>
<properties>
<property name="javax.persistence.jdbc.url" value="jdbc:h2:mem:test" />
<property name="javax.persistence.jdbc.driver" value="org.h2.Driver" />
<property name="javax.persistence.jdbc.user" value="sa" />
<property name="javax.persistence.jdbc.password" value="" />
<property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect"/>
<property name="hibernate.hbm2ddl.auto" value="create-drop" />
<property name="hibernate.show_sql" value="true"/>
<property name="eclipselink.logging.level" value="ALL" />
</properties>
</persistence-unit>
</persistence>
 Código Fuente:
https://github.com/vacax/orm-jpa
o
https://github.com/vacax/sparkjavaorm
Ejemplo de Uso
Leer una Entidad
Desde el EntityManager tenemos el método find(Class, Object), el cual nos
permite buscar una entidad:

Estudiante estudiante = em.find(Estudiante.class, 20011136);

Eliminar una Entidad
Desde el EntityManager tenemos el método remove(Object), el cual nos permite
buscar una entidad:

em.remove(estudiante); //saca del contexto de persistencia, la clase sigue viva.

Actualizar una entidad
Para actualizar una entidad, es necesario tener la referencia de un objeto
manejado por JPA, todos los cambios realizados son sincronizados en la base de
datos. Tenemos opción a “desconectar” un objeto del manejo de JPA, para eso
utilizamos el método detach() y clear(), para volver a gestionar el objeto mediante
JPA, utilizamos el método merge(). (Incluir la actualizar…)

tx.begin();
em.persist(estudiante);
tx.commit();
em.detach(estudiante);
// Actualizando datos
em.merge(estudiante)
Carga Perezosa y Carga en Línea
● La carga perezosa corresponde a una técnica utilizada en la búsqueda de
información de los objetos asociados a una entidad en el momento que son
demandados, es decir, si un objeto tiene una relación con otro objeto, este
último se carga la información cuando de forma explícita se busca alguna
información. Este comportamiento es por defecto en JPA.
● La carga en línea, indica que el objeto que es una propiedad de otro, es
cargado directamente con búsqueda del primero. En caso datos con mucha
información puede representar un problema de rendimiento
Ejemplos Carga Perezosa y Carga en Línea
//Carga Perezosa

@Basic(fetch = FetchType.LAZY)
private Profesor profesor;

//Carga en Línea.

@Basic(fetch = FetchType.EAGER)
private Profesor profesor;
@Transient
● Son propiedades de una clase marcada como entidad que no queremos que
formen parte de la persistencia. Para eso marcamos la propiedad con la
anotación @Transient.

Ejemplo:

@Transient
private int edad;
Asociaciones
● Las asociaciones es el mecanismo que nos permite mapear colecciones de
entidades su correcta definición en el mundo relacional.
● Tenemos dos tipos:
○ Unidireccionales:
■ La información viaja desde un único objeto
○ Bidireccionales:
■ La información viaje desde más de un objeto.
● Las asociaciones nos permite manejar la cardinalidad de las relaciones.
Asociaciones Unidireccionales - Uno a Uno
@Entity @Entity
public class Profesor implements Serializable { public class GrupoClase implements
@Id Serializable {
@GeneratedValue @Id
private Long id; @GeneratedValue
private String nombre; private Long id;
@OneToOne
// Getters y setters private Profesor profesor;
}
// Getters y setters
}
Asociaciones Unidireccionales - Uno a Muchos
@Entity @Entity
public class Direccion implements Serializable { public class Cliente implements Serializable {
@Id @Id
@GeneratedValue @GeneratedValue
private Long id; private Long id;
private String calle; @OneToMany
private String ciudad; private List<Direccion> direcciones;
private String pais;
// Getters y setters
// Getters y setters }
}

Configuración mostrada crea una tabla de unión para soportar la relación uno a mucho.
Asociaciones Bidireccionales - Uno a Uno
@Entity @Entity
public class Mujer implements Serializable { public class Marido implements Serializable {
@Id @Id
@GeneratedValue @GeneratedValue
private Long id; private Long id;
@OneToOne @OneToOne(mappedBy = "marido")
private Marido marido; private Mujer mujer;
}
// Getters y setters
}

La clase que no es dueña de la relación debe indicar el atributo mappedBy e indicar la propiedad
relacionada.
Asociaciones Bidireccionales - Uno a Mucho
@Entity @Entity
public class Asignatura implements Serializable public class Profesor implements Serializable {
{ @Id
@Id @GeneratedValue
@GeneratedValue private Long id;
private Long id; @OneToMany(mappedBy = "profesor")
@ManyToOne private Set<Asignatura> listaAsignatura;
private Profesor profesor;
//Getters y setters
// Getters y setters }
}

La clase que no es dueña de la relación debe indicar el atributo mappedBy e indicar la propiedad
relacionada.
Métodos Callback
● Son métodos que se ejecutan en función a los eventos del ciclo de vida de
una entidad. Las categorías que implementan son:
○ Eventos de persistencia (@PrePersists y @PostPersist)
○ Eventos de actualización (@PreUpdate y @PostUpdate)
○ Eventos de borrado (@PreRemove y @PostRemove)
○ Eventos de carga (@PostLoad)
● Las anotaciones se marcan métodos dentro de la entidad la cual se ejecuta
cuando suceda el evento.
● Las reglas:
○ No puede lanzar excepciones de tipo checked
○ No puede invocar métodos de las clases EntityManager y/o Query
○ No puede ser declarado static ni final
○ Cada anotación de ciclo de vida puede aparecer una y solo una vez en cada entidad
Métodos Callback - Ejemplos
// Clase Estudiante

@PreUpdate
@PrePersist
private void cancelarMatricula(){
if(matricula == 20011137){
throw new RuntimeException("No puede ser esa matrícula..");
}
}
Consultar vía JPQL (Java Persistence Query Language)
● Es un lenguaje de consulta orientado a objeto independiente del motor de
persistencia relacional.
● Muy parecido a SQL pero con un enfoque de objeto e inspirado en el
Hibernate Query Language.
● Nos permite realizar las operaciones de Select, Update y Delete en el motor
de persistencia.
Consultar vía JPQL (Java Persistence Query Language)
@Entity Una consulta de JPQL para obtener todos los
public class Estudiante implements Estudiante:
Serializable{
@Id SELECT e FROM Estudiante e ORDER BY e.nombre
private Integer matricula;
private String nombre; O podemos utilizar comodines en la consulta:
// otras propiedades
SELECT e FROM Estudiante e WHERE nombe like
@ManyToMany :nombre
private List<Cursos> cursos;
// Los Set y Get de las propiedades
}
Consultar vía JPQL (Java Persistence Query Language)
La forma de acceder vía el desarrollo es:

public List<Estudiantes> getEstudiantePorNombre(String nombre) {

String queryString = "SELECT e FROM Estudiante e " +
"WHERE e.nombre = :nombre";
Query query = getEntityManager().createQuery(queryString);

query.setParameter("nombre", nombre);
return query.getResultList();
}
Consultar vía JPQL (Java Persistence Query Language)
● La documentación oficial sobre JPQL:

https://docs.oracle.com/html/E13946_01/ejb3_langref.html

● La documentación sobre HQL:

https://docs.jboss.org/hibernate/orm/3.5/reference/es-ES/html/queryhql.html
Recursos
● http://www.davidmarco.es/archivo/tutorial-jpa20
● http://www.tutorialspoint.com/es/jpa/
● http://download.oracle.com/otndocs/jcp/persistence-2_1-fr-eval-spec/index.ht
ml
● http://www.mastertheboss.com/jboss-frameworks/hibernate-jpa/quickstart-tuto
rials-hibernate-jpa/jpa-21-tutorial
● https://docs.jboss.org/hibernate/orm/4.3/devguide/en-US/html/ch11.html
● http://docs.oracle.com/html/E13946_02/ejb3_langref.html