1. Qué es Java Persistence API
• Es la API de persistencia desarrollada para la
plataforma Java EE e incluida en el estándar EJB3
• JPA es un Estándar ORM (Object Relational Mapping)
• Disponible para JSE y JEE.
• Definida en javax.persistence.
• Definido según el estándar JSR 220 y JSR 317. (Contrato)
• Es la materialización de experiencias de distintas soluciones
de ORM para java.
– Basado en Hibernate y Java Data Object (JDO) entre otros.

2. Por que usar JPA
• Facilita la persistencia desde el punto de vista del
desarrollador.
• Encapsula el uso de SQL, JDBC y otras tecnologías
subyacentes.
• Incrementa la respuesta al cambio de las aplicaciones.
• No requiere de un servidor de aplicaciones para su uso.
• Reducción dramática en código de acceso a datos.
• Permite concentrarse en el modelo de objeto y no en el
modelo de datos.

3. Capas Aplicativos

4. Palabras Clave
• Entidad: Objeto con las anotaciones adecuadas
para realizar la persistencia a la BBDD.
• POJO: Plain Old Java Object
• Anotación: Añadir metadatos (datos descriptivos)
al código fuente.
• JPQL: Java Persistence Query Languaje
• NamedQuery: Consultas JPQL
• NativeQuery: Consultas en SQL Nativo que se
traducen a objetos entidad.

5. Problemas de JPA
• Incrementa el uso de recursos para el acceso a datos, ya
que agrega elementos por encima de JDBC para mejorar su
eficiencia.
• Ofrece nuevos retos en cuanto a manejo de Caches y
concurrencia.
• Abstrae de tan alto nivel de persistencia que las
optimizaciones de DBMS no se implementan fácilmente.
• No implementa el uso de StoredProcedures, pero por
medio de NativeQuery se puede realizar la invocación.

6. Implementaciones JPA
• En el mercado hay varios proveedores para el API
de JPA:
• Hibernate.
• OpenJPA.
• Oracle TopLink.
• JPOX
• CocoBase
• EclipseLink
• Amber
• Si se respeta el uso de las anotaciones estándar,
la solución puede ser interoperable entre
proveedores sin cambios traumáticos.

7. Versión de JPA
• En el mercado hay dos especificaciones JPA actualmente las cuales
corresponden al JSR 220 (JPA 1.0) y JSR 317 (JPA 2.0)
• JPA 2.0 agrega características como:
– Colecciones de objetos embebidos.
– Listas ordenadas.
– Criteria API para consultas dinámicas.
– Estandarización de query hints (extensiones que se agregan a las
consultas para poder realizar el manejo de la concurrencia sobre los
registros)
– Estandarización de meta-datos para Data Definition Lenguaje - DDL.
(p.j que el esquema de BBDD que se genere sea similar entre
proveedores )
– Validación, similar a lo que realiza HibernateValidator
– Mejoras en JPQL

8. Arquitectura JPA
• Relación entre los componentes principales de
la Arquitectura JPA:

9. Excepciones JPA
PersistenceException EntityNotFoundException
TransactionRequiredException NoResultException
OptimisticLockException NonUniqueResultException
PessimisticLockException QueryTimeoutException
LockTimeoutException
RollbackException
EntityExistsException

10. Definición de Entidades
• La entidades son clases Java simples conocidas como POJOS.
• Sus atributos pueden ser tipos primitivos (p.j. int) wrapers de tipos
primitivos (p.j. Integer), enumeraciones o otras entidades.
• Puede contener atributos no persistentes (p.j. valores que se deben
calcular y que no interesa almacenarlos en la BBDD)
• Se pueden heredar desde objetos entidades o no entidades.
• Implementan la interface serializable.
• Se pueden traspasar entre capas de la aplicación (No se requiere un
VO)

11. Ciclo de vida de la Entidad

12. Ciclo de vida de la entidad
• Estos son métodos llamados durante el uso de
una entidad en su ciclo de vida.
Anotación Anotación
@PostLoad @PrePersist
@PostPersist @PreRemove
@PostRemove @PreUpdate
@PostUpdate

13. Ejemplo de Entidad
Anotación que marca el objeto como una
@Entity entidad
public class Usuario implements Serializable {
private Long idUsuario;
private static final long serialVersionUID = 1L;
Constructor sin parámetros siempre
requerido
public Usuario() {
super();
} Marca la propiedad como el id de la
@Id entidad
public Long getIdUsuario() {
return this.idUsuario;
}
public void setIdUsuario(Long idUsuario) {
this.idUsuario = idUsuario;
}
}

14. Distinciones de Entidad
• Las entidades se configuran a base de anotaciones.
• Estas anotaciones representan:
– Tablas
– Columnas
– Relaciones
– Multiplicidad
– Estrategias de generación de valores (auto incrementales)
– Querys
– Cache
– Herencia
– DDL
– CallBacks (eventos de persistencia – antes de guardar, después de eliminar,
etc…)

15. Anotaciones
 Es una forma de añadir metadatos (datos que describen otros datos) al código
fuente Java que están disponibles para la aplicación en tiempo de ejecución.
@Entity @Column @EmbeddedId
@id
@JoinTable
@ManyToOne
@OneToOne
@Enumerated
@ManyToMany @Basic
@Table

16. Anotaciones de Entidad
• Anotaciones que describen el
comportamiento por defecto de una entidad
JPA, le indican al motor ORM de instrumentar
la clase como almacenable.
Anotación Descripción
@Entity Agrega la clase como una
entidad administrada por el
motor ORM

17. Anotaciones para el Esquema
de base de datos
• Las anotaciones de esquema de base de datos
ayudan a definir el modelo de
almacenamiento de los datos desde las clases
java.
• Definen el nombre de los objetos de la base
de datos que usa o genera las entidades JPA.
Anotación Descripción
@Table Define la tabla exacta que representa la
entidad
@SecondaryTable Define una tabla espejo donde se
almacenaran los datos de la entidad

18. Anotaciones para el Esquema
de base de datos
Anotación Descripción
@SecondaryTables Define una colección de tablas espejo para
almacenar los datos de la entidad
@Column Define exactamente que columna de la tabla
representa la propiedad
@JoinColumn Define una columna Join para una relación
@JoinColumns Define una colección de columnas Join para una
relación

19. Anotaciones para el Esquema
de base de datos
Anotación Descripción
@PrimaryKeyJoinColumns Define una colección de llaves primarias de
relación de herencia cuando la herencia es
JOIN
@PrimaryKeyJoinColumn Define la llave primaria de relación de
herencia cuando la herencia es JOIN
@JoinTable Establece una tabla Join para una relación
@UniqueConstraint Define un índice único sobre un campo

20. Identidad
• Anotaciones que definen la identidad de una
entidad, definen su primaryKey
Anotación Descripción
@Id Define el atributo id o primary key de una entidad
@IdClass Define los atributos de una llave compuesta para
una clase, solo implementa los campos y en la clase
que la usa como llave primaria se referencia como
@IdClass(com.efibs.empleadoPK.class)
@EmbeddedId Define una llave compuesta tal como lo hace
@IdClass, solo que lo atributos usados como llave
primaria no se marcan con @Id.

21. Identidad
Anotación Descripción
@GeneratedValue Establece una columna con un valor
autoincremental o autogenerado
@SequenceGenerator Establece de donde la anotacion
@GeneratedValuea va a tomar sus secuencias,
pudiendo definir propiedades mas especificas
como el nombre de la secuencia donde se
generaran los valores autonuericos.
@TableGenerator Es igual que @SequenceGenerator, solo que
define una tabla para los valores autonumericos.

22. Mapeos Directos
• Estas anotaciones, definen valores directos
para las columnas o establecen propiedades
adicionales sobre los atributos marcados
como Column.
Anotación Descripción
@Basic Se utiliza para configurar el tipo inicialización de
las entidades asociadas.
@Enumerated Se utiliza para marcar los atributos los cuales se
usan con enumeraciones (Activo, Inactivo; 0,1,2)
@Temporal Se utiliza para manejar la precisión en las fechas.

23. Mapeos Directos
Anotación Descripción
@Lob Mapeo un campo Blob de la base de datos
@Transient Define un campo no persistente en la base
de datos. Solo es utilizado por Java

24. Mapeo de Relaciones
• El mapeo de relaciones equivale a reflejar en
las entidades las relaciones del repositorio
relacional.
Anotación Descripción
@OneToOne Representa una relación uno a uno
@OneToMany Representa una relación uno a muchos, se usa
para identificar la parte única
@ManyToOne Representa una relación uno a muchos, identifica
la parte muchos

25. Mapeo de Relaciones
Anotación Descripción
@ManyToMany Representa una relación de muchos a muchos, se define en
una Join Table.
@MapKey Las relaciones donde el resultado son muchas
entidades(como @OneToMany o @ManyToMany) estas
entidades se pueden encontrar en objetos Set, List,
Collection o Map, en este ultimo caso se usa @MapKey
para definir la llave de este objeto llave-valor por la cual se
accezan las entidades
@MapKey(“cedula”)
Map<Long, Empleado> empleados;
En el ejemplo anterior en el map se almacenara como llave
la cedula en en vez del Id.

26. Mapeo de Relaciones
Anotación Descripción
@OrderBy Representa el campo por el cual se ordena la relación

27. Composición
• Algunos objetos no se diseñan para existir
como una unidad, sino como parte de una
entidad.
Anotación Descripción
@Embeddable Define una clase que hace parte de una entidad,
comparte su id pero no su almacenamiento
@Embedded Una clase @Embeddable se puede usar como
@EmbeddedId si quiere que sea una llave primaria
compuesta y @Embedded si se desea que esos
campos sean solo unos campos mas de la clase que
contiene la anotacion @Embedded

28. Herencia
• Las anotaciones de herencia, nos permiten
modificar el comportamiento de los objetos,
los cuales heredan de un objeto ya anotado.
Anotación Descripción
@Inheritance Establece la configuración de herencia, se usa
en conjunto con @DiscriminatorColumn,
@DiscriminatorValue
@DiscriminatorColumn Define como se identifican distintas clases
heredadas almacenadas en una tabla.
@DiscriminatorValue Define el valor que tiene esta clase en la
columna @DiscriminatorColumn

29. Herencia
Anotación Descripción
@MappedSuperclass Define una clase padre para heredar a sus hijos
las anotaciones sobre sus campos, pero no
existe como tabla en la base de datos al no
estar anotada como @entity
@AssociationOverride Las clases padre, ya sean marcadas como
@entity o no heredan a sus hijos las relaciones
(@OneToOne, @OneToMany), con esta
anotación podemos cambiar la definición de
esas asociaciones.
@AssociationOverrides Colección de @AssociationOverride, para
cambiar varias relaciones en la misma clase

30. Herencia
Anotación Descripción
@AttributeOverride Esta anotacion cambia la definicion de un
campo de un hijo de la clase padre. Por
ejemplo:
Padre @Column(name=“id”);
Hijo @AttributeOverride(name=“id”,
column=@Column(name=“identificacion”);
La columna id del padre en la clase hijo ahora
se conocera como identificacion.
@AttributeOverrides Colección de @AttributeOverride
Se usa cuando hay múltiples
@AttributeOverride

31. Bloque y
Control de Versiones de registro
• Esta anotación se usa para definir manejo de concurrencia
Anotación Descripción
@Version Establece un campo para el control de
versiones de una entidad, asi entre
operaciones update este valor aumenta
con el tiempo, esto asi para identificar
posibles problemas de modificacion
concurrente
• Lista de Anotaciones:
http://www.oracle.com/technetwork/middleware/ias/to
plink-jpa-annotations-096251.html

32. Orm.xml
• Todas la anotaciones realizadas sobre las
entidades pueden ser sobre escritas por este
archivo.

33. Persistencia

34. Persistence.xml
• El archivo persitence.xml contiene la
configuración del motor de persistencia y
define las conexiones a la base de datos y sus
entidades en unidades de trabajo llamadas
persistenceUnit.

35. Persistance Manager
• El mundo JPA se rige por dos objetos
principales:
– EntityManagerFactory
– EntityManager
• Los cuales se encargan de realizar la
manipulación y búsqueda de entidades desde:
• El EntityManagerFactory existe uno por aplicación, es un objeto pesado y debe
abrirse y cerrarse en cada inicio de la aplicación pero no durante su ejecución.
• El EntityManager es un objeto liviano, el cual nos provee la interface para gestionar
las entidades.

36. Persistiendo una Entidad
1
2
3

37. Creación de un Proyecto JPA - Eclipse

38. Inicialización del Contexto de
Persistencia

39. Operaciones con Entidades
Creación
• EntityManager.persist(Entidad)
Entidades son simples POJOS hasta que entran
en estado managed (manejado) y luego
hechos persistentes por un EntityManager.
Si el objeto ya existe se lanzará una RunTime
exception, EntityExistsException

40. Operaciones con Entidades
Búsqueda
• EntityManager.find(class, object)
El método find(…) recibe por parámetros la
clase de la entidad y valor de la llave primaria
para buscar un solo objeto entidad.
Si el objeto a buscar no puede ser localizado
por la clase EntityManager, entonces este
método simplemente retornará null.

41. Operaciones con Entidades
Búsqueda
• EntityManager.getReference(class, object)
Similar al método find(…), solo que en lugar
de retornar null cuando no se encuentra la
entidad, éste método lanza una
EntityNotFoundException.
Otra diferencia es que algunos datos de la
entidad extraída pueden presentar carga
perezosa (Lazy Loading) al ser accedidos la
primera vez.

42. Operaciones con Entidades
Eliminando
• EntityManager.remove(Entidad)
Sirve para eliminar una entidad de la base de
datos.
Luego de invocar este método, la entidad
entrará a la fase DETACHED del contexto de
persistencia y ya no será una entidad
manejada.

43. Operaciones con Entidades
Actualizando
• EntityManager.merge(Entidad)
Toma una entidad en estado DETACHED y la
asocia al contexto de persistencia del
EntityManager, actualizando los datos del
objeto en la base de datos.

44. Operaciones con Entidades
Actualizando
Toma el objeto y lo pasa a un estado manejado, y todos los
cambios realizados al objeto serán visibles al contexto de
persistencia del EntityManager

45. Operaciones con Entidades
flush y Refresh
• EntityManager.flush()
Sincroniza los datos de una entidad y los hace persistentes
en la base de datos.
• EntityManager.refresh(Entidad)
Contrario al flush(), este método vuelve a cargar los datos
originales de la base de datos a la entidad.

46. Relaciones
• Las entidades como abstracción de la base
de datos relacional, nos traducen estas
relaciones a relaciones entre los objetos.
 Relaciones Unidireccionales.
 Relaciones Bidireccionales.
 Las relaciones se pueden representar por medio de objetos:
» Set
» Map
» List
» Collection

47. Relaciones
• Las relaciones Representadas como Colecciones
pueden establecerse en dos modos:
– LEAZY FETCH: Obtiene únicamente los datos
relacionados la entidad que se consulta y no sus
entidades asociadas, estas últimas se obtienen en el
momento de utilizar el atributo:
– EAGER FETCH: Contrario de Leazy.

48. Asociaciones
• Existen 4 tipos de relaciones: uno a uno, uno a
muchos, muchos a uno y muchos a muchos.
Uno a Uno Uno a Muchos …
Muchos a Uno
…
… Muchos a Muchos …

49. Asociación @OneToOne
• @OneToOne
Cada entidad se relaciona con una sola
instancia de otra entidad. Donde ambas se
referencian por la misma llave PK.

50. Asociación @OneToOne

51. Asociación @OneToMany
• @OneToMany
Una entidad, puedes estar asociada con varias
instancias de otras entidades.

52. Asociación @OneToMany

53. Asociación @ManyToOne
• @ManyToOne
Múltiples instancias de una entidad pueden estar
relacionadas con una sola instancia de otra
entidad.
Una ciudad solo puede estar en un país, pero un país puede tener varias ciudades.

54. Asociación @ManyToOne

55. Asociación @ManyToMany
• @ManyToMany
Varias instancias de una entidad pueden
relacionarse con múltiples instancias de otras
entidades.

56. Asociación @ManyToMany

57. Relaciones y Generación de DDL

58. Objetos embebidos
Son relaciones Lógicas y no físicas
(Relaciones de Necesidad de Información)

59. Herencia
• El uso de entidades anotadas posibilita la
herencia de los objetos persistentes.
• No solo las clases anotadas se pueden
heredar.

60. Estrategias de Herencia
Single Table
• Todas la entidades heredadas se
almacenan en la misma tabla de la
base de datos
Joined
• Los atributos compartidos se
almacenan en una tabla, los atributos
particulares se almacenan en otra
tabla.
Table per class
• Cada clase se almacena en una tabla
separada

61. Estrategias de identidad
• Simple
– @Id : Un campo marcado con @Id será la llave primaria de la entidad,
pero si no tiene otra anotación, este valor deberá ser ingresado antes
de almacenar
– @GeneratedValue: se usa en conjunto con @Id, así los valores para la
llave primaria se generaran automáticamente y no se deberá ingresar
antes de almacenar
• Definida por el usuario
– @EmbeddedId, la clase usada debe marcarse como @Embeddable y
se usa para definir entidades con llaves compuestas
– @IdClass, funciona igual que @EmbeddedId, solo que ya la clase
usada como llave compuesta no hace parte del objeto que tiene llave
compuesta, solamente se usara @IdClass(llaveCompuesta.class) y en
el cuerpo de la clase entidad, se marcaran variables identicas a las
seleccionadas como llave compuesta por la clase usada como
@IdClass

62. Estrategias de identidad

63. Java Persistence Query Languaje
• Las consultas JPQL son muy similares a SQL
• Soportan consultas SELECT, DELETE, UPDATE
• Soporta SELECT con GROUP BY, HAVING, JOIN,
LEFT JOIN, RIGTH JOIN, IN
• Permite navegación de Collecciones Leazy
usando JOIN FETCH

64. Palabras Reservadas JPQL

65. Funciones Predefinidas de JPQL

66. Querys
• Las consultas en JPA se expresan en JPQL
Query o Native Query, en ambos tipos existen
consultas persistentes y continuas llamadas
Named Query.
– Named Query : Consultas comunes escritas en
JPQL

67. Querys
– Named Native Query : Consultas comunes
expresadas en SQL especifico del motor de base
de datos

68. Querys
– Las Native Querys pueden ser complejas y cambiar el
nombre de las columnas dependiendo de su uso.
– @SqlResultSetMapping mapea los resultados de la
consulta a atributos de las entidades resultantes de la
búsqueda.

69. Criteria API
• Criteria API nos permite generar complejas
consultas sin la necesidad de construirlas a
través de condiciones o valores tomados
directamente desde la interface de usuario.
• Para realizar búsquedas complejas, Criteria
API se puede apoyar sobre las clases
MetaModels.

70. Criteria API
CriteriaQuery<Persona> cq = cb.createQuery(Persona.class)
Root<Persona> from = cq.from(Persona.class);
from.join("expediente").join("expRepAdministrativaSet");
cq.where(cb.equal(from.get("identificacion"), "12345"));
Query query = em.createQuery(cq);
print(query.getResultList());

71. Criteria API
select
persona0_.IDENTIFICACION as IDENTIFI1_14_,
persona0_.CORREO as CORREO14_,
persona0_.IDCATEGORIA as IDCATEGO7_14_,
persona0_.IDTIPOGENERO as IDTIPOGE8_14_,
persona0_.IDTIPOIDENTIFICACION as IDTIPOID9_14_,
persona0_.IDTIPONACIONALIDAD as IDTIPON10_14_,
persona0_.NOMBRE as NOMBRE14_,
persona0_.NUMUNIVERSITARIO as NUMUNIVE4_14_,
persona0_.PRIMERAPELLIDO as PRIMERAP5_14_,
persona0_.SEGUNDOAPELLIDO as SEGUNDOA6_14_
from
PERSONA persona0_
inner join
EXPEDIENTE expediente1_
on persona0_.IDENTIFICACION=expediente1_.IDPERSONA
inner join
EXP_REP_ADMINISTRATIVA exprepadmi2_
on expediente1_.IDEXPEDIENTE=exprepadmi2_.IDEXPEDIENTE
where
persona0_.IDENTIFICACION=?

72. Ejemplo Criteria API

73. JPA VALIDATOR
• JPA Validator nos permite agregar validaciones a
los setters de nuestras entidades, evitando así
errores de datos comunes.
• Esta validaciones están disponibles siempre en
cuando se disponga de la librería
javaxi.validation
• Esta librería puede ser implementada con
HibernateValidator

74. Hibernate Validator
• Hibernate Validator es la implementación para el
JSR 303 (Bean Validation)
• Define el uso de anotaciones o archivos XML
como fuente de validaciones para los beans
(entidades JPA).
• Hibernate Validator se puede usar en cualquier
clase, no solo en entidades JPA, pero es
especialmente útil en estas ultimas.
• Se debe contar con las librerías:
– Validation-api
– Hibernate-validator-processor

75. Implementando validaciones
• Las validacione sse pueden hacer en 3 niveles
– Validaciones por campo: esta validaciones se establecen
directamente en la variable, esto hace que hibernate validator
invoque directamente la variables y no invoque su getter y
setter
– Validaciones por propiedad: estas validaciones se establecen
sobre las propieadades (getter y setter) de la clase, cuando esto
sucede, hibernate validator, usa el getter y setter de la
propiedad para obtener acceso al valor a validar, esto es útil
cuando por algún motivo en el getter o setter modificamos el
valor de una variables.
– Validaciones a nivel de clase: Las validaciones a nivel de clase
son utilizes cuando estas contienen clases que deben ser
validadadas en su interior o cuando se desea realizar
validaciones personalizadas sobre las clases

76. Validaciones
• Las Validaciones son heredables entre clases.
• Las validaciones agregadas a una clase hijo
son sumadas a las de su padre (no sustituyen
las heredada)
• Las validaciones pueden ser recursivas y se
pueden realizar sobre objetos colección
(Collection, List, Set, Map)

77. JPA VALIDATOR

78. JPA VALIDATOR
Anotación Descripción
@DecimalMax El valor de la variables debe ser menor o
igual a el valor de la anotacion
@DecimalMin El valor de la variables debe ser mayor o
igual a el valor de la anotacion
@Digits(integer=, fraction=) El valor de la variable anotada debes tener
una parte decimal y otra entera
@Future El valor de la fecha debe ser en el futuro

79. JPA VALIDATOR
Anotación Descripción
@Max Verifica si el valor de la variables anotada es
menor o igual a el valor proveído por la
anotación
@Min Verifica si el valor de la variables anotada es
mayor o igual a el valor proveído por la
anotación
@Size(min=, max=) Verifica si el elemento anotado esta entre el
tamaño proveído por la anotación

80. JPA VALIDATOR
Anotación Descripción
@Null La propiedad debe ser null
@NotNull La propiedad no debe ser null
@AssertFalse La propiedad debe ser false
@AssertTrue La propiedad debe ser true
@Past La Fecha debe ser en el pasado
@Pattern(regex=, flag=) Debe cumplir con expresión regular
@Valid Valida que los objetos asociados cumplan
con sus validaciones

81. Validaciones

82. Validaciones
•Las validaciones pueden ser a nivel de clase, esta validación permite validar la
cantidad de pasajeros que contiene la variables passagers

83. Validaciones sobre colecciones
•Las validaciones pueden ser recursivas a los objetos contenidos dentro de
nuestra clase, esa tarea se facilita con la anotación @Valid

84. Validando
• Si se usa JPA y las librerías de Hibernate
validator están disponibles, el motor JPA se
encargara de llamar las validaciones antes de
persistir en la base de datos.
• Si se usa fuera de JPA se debe llamar
manualmente las validaciones y verificar sus
resultados:
– ClassValidator<Book> validator = new ClassValidator<Book>(Car.class); InvalidValue[] invalidValues = validator
.getInvalidValues(carInstance);