CURSO JAVA DEVELOPER
Java Persistence Api
Que es ORM ?
JPA
Mapeo Objeto Relacional
(ORM) ,en otras palabras
persistir los objetos Java
en una base de datos rela-
cional - ha tenido su ma-
yor cambio recientemen-
te, gracias, en parte a la
proliferación de métodos
avanzados que intentan
hacer esta tarea mas fácil .
Entre estas tecnologías
están los Entity Beans
2.x , TopLink , Hiberna-
te , JDO , y también
JDBC con DAO . Con
muchas alternativas in-
Como trabaja JPA ?
Inspirado en los frame-
works como Hibernate ,
JPA usa anotaciones para
mapear objetos a la base
de datos relacional. Estos
objetos , usualmente lla-
mados entidades, no tie-
nen nada en común con
los Entity Beans 2.x . Las
entidades JPA son clases
POJOs, no extienden de
ninguna clase y no imple-
mentan ninguna interface.
Usted no necesita archi-
vos descriptores XML
para hacer los mapeos . Si
uno se fija en el API ( java
doc ) uno observara que
esta compuesto de pocas
compatibles , el grupo
Java EE experto toma
inspiración de estos fra-
meworks populares y creo
el api de persistencia de
Java (JPA) , el cual se
puede usar desde aplica-
ciones Java EE o SE.
En pocas palabras JPA ,
usa el modelo de progra-
mación POJO para la
persistencia. A pesar de
que este modelo esta in-
cluido en la especificación
EJB 3 , JPA puede ser
usado fuera de un conte-
nedor EJB , y esta es la
forma que será usada en
este articulo . “Plain Old
Java Objects” ( POJO )
ejecutándose en una apli-
cación Java SE.
clases e interfaces.
La mayoría del contenido
de el paquete javax.persitence
son anotaciones. Con esto
explicado , veremos el
siguiente ejemplo de códi-
go :
LINKS DE INTERES :
En este articulo , modela-
re un simple libro de di- ♦ EJB3 : http://www.jcp.org/
recciones (Address book ) en/jsr/detail?id=220
para una compañía de
música ficticia llamada ♦ JPA API : http://
Watermelon , para guar-
dar las direcciones de los java.sun.com/javaee/5/
clientes en la base de da- docs/api/javax/persistence/
tos . Watermelon vende y package-summary.html
distribuye artículos de
música así como instru- ♦ DAO: http://java.sun.com/
mentos , amplificadores y blueprints/
libros . Voy a usar una corej2eepatterns/Patterns/
incremental e iterativa
aproximación para des- DataAccessObject.html
arrollar y persistir el mo-
delo del negocio.
@Entity
public class Customer {
@Id
private Long id;
private String firstname;
private String lastname;
private String telephone;
private String email;
private Integer age;
// constuctors, getters,
setters
}
 JAVA PERSISTENCE API Page 2

Lo mínimo necesario ...

@Entity
public class Customer {
@Id
private Long id;
private String firstname;
private String lastname;
private String telephone;
private String email;
private Integer age;
// constuctors,
//getters, setters
} Después de crear el
// métodos CRUD
public void createCustomer() {
// Gets an entity manager
EntityManagerFactory emf = Persisten-
ce.createEntityManagerFactory("watermelonPU");
EntityManager em = emf.createEntityManager();
EntityTransaction trans = em.getTransaction
();
// Instantiates a customer object
Customer customer = new Customer(1L, "John",
"Lennon", "441909", "john@lenon.com", 66);
// Persists the customer
trans.begin();
em.persist(customer);
trans.commit();
// Finds the customer by primary key
customer = em.find(Customer.class, 1L);
System.out.println(customer.getEmail());
simple . Esta tiene un identifi-
cador (id) , un nombre ( first-
name) , apellido ( lastname) un
numero de teléfono ( telep-
hone ) , mail ( email ) y edad
del cliente ( age ) . Para ser
persistente esta clase tiene que
seguir algunos reglas JPA sim-
ples :
• La clase tiene que ser identificada
como una entidad usando la
anotación
@javax.persistence.Entity
Esta parte de código
que vimos ( construc- • Una propiedad de la clase tiene
tores , getter y setter que tener un identificador anota-
do con @javax.persistence.Id
no son mostrados
para hacer esto mas • Tiene que haber un constructor
fácil de leer ) muestra sin argumentos
una clase “Customer”
EntityManager ...
ger.persist() para insertar este
EntityManager usan- objeto en la base de datos. Yo
do un factory ( Entity- puedo luego buscar este objeto
ManagerFactory ) , por su identificador usando el
instanciare mi objeto método EntityManger.find() y
“Customer” ( usando actualizar el mail usando los
el operador new como métodos "set" .
cualquier otro objeto
JAVA ) y le pasare La interface EntityManger no
algo de data como el tiene un método update . Los
"id" , "last name" , updates se hacen a través de las
"email" , etc. Usare el propiedades "setters" . Luego
método EntityMana- borrare el objeto usando Enti-
Persistence.xml
especifica unidad de <persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence">
El código que sigue muestra lo
mínimo requerido para definir
un "persistence object" . Ahora
vamos a manipular este objeto,
deseo persistir mi objeto
“customer” , actualizar alguna
de sus propiedades y borrarlo
de la base de datos. Estas ope-
raciones serán echas a través de
la interface
javax.persistence.EntityManager de JPA.
Para esto, quienes estén fami-
liarizados con el patrón DAO ,
el EntityManager puede ser
visto como una clase DAO que
nos provee un set de métodos
clásicos ( persist , remove ) y
buscadores ( find ).
tyManager.remove() , notar que
este código usa transacciones
explicitas . Es por eso que los
métodos persist , update , y
remove son llamados entre
transacion.begin() y transac-
tion.commit(). Vea los méto-
dos CRUD
Que base de datos usamos ? ,
La respuesta esta en EntityMa-
nagerFactory, Esta toma un
parámetro que se refiere a una

// Updates the customer email address persistencia ( water- <persistence-unit name="watermelonPU" transaction-type="RESOURCE_LOCAL">
trans.begin(); melonPU en este ca- <provider>
customer.setEmail("john@beatles.co.uk"); oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider
trans.commit(); so ) . Una unidad de </provider>
// Deletes the customer persistencia es decla- <class>entity.Customer</class>
<properties>
trans.begin();
em.remove(customer);
rada en el archivo <property name="toplink.jdbc.url"
trans.commit(); “persistence.xml” y value="jdbc:mysql://localhost:3306/watermelonDB"/>
<property name="toplink.jdbc.user" value="root"/>
// Closes the entity manager and the factory contiene información <property name="toplink.jdbc.driver" value="com.mysql.jdbc.Driver"/>
em.close(); como la base de datos <property name="toplink.jdbc.password" value=""/>
emf.close(); <property name="toplink.target-database" value="MySQL4"/>
} a usar y el driver <property name="toplink.ddl-generation" value="create-tables"/>
JDBC . </properties>
</persistence-unit>
</persistence>
Page 3
Unidad de Persistencia
En el código arriba , hay solo
una unidad de persistencia ,
llamada watermelonPU ( el
archivo persistence.xml puede
contener muchas unidades de
persistencia ) . Usted puede
pensar en una unidad de persis-
tencia como un conjunto de
entidades ( el elemento class )
que comparten propiedades
comunes . En este caso , estas
propiedades son : url de la base
de datos , driver JDBC , cre-
denciales. Bajo el elemento
"properties" usted encontrara
propiedades especificas para
Top-link por ejemplo to-
plink.ddl-generation . Esta
propiedad es usada por To-
Customizando
Usted solo necesita añadir
código customizado cuando el
código por defecto es inade-
cuado . En mi caso, porque yo
nunca especifico el nombre de
la tabla o columnas en la clase
“Customer” JPA asume que el
nombre de la tablas es igual al
nombre de la clase y que el
nombre de la columna tiene el
mismo nombre de las propie-
Añadiendo funcionalidades y customizando el mapeo
En este punto yo quisiera me-
jorar algunas cosas. Primero
que todo, yo no quiero setear
un identificador (primary key)
del objeto pero en lugar de
esto quiero que JPA lo incre-
mente automáticamente. Gra-
cias a las anotaciones , esto es
fácil de hacer.
Solo necesito anotar mi atribu-
to identificador
@javax.persitence.GeneratedValue .
Esta anotación genera un pri-
mary Key en cuatro posibles
modos:
JAVA PERSISTENCE API
pLink para generar las tablas fecto hace mas fácil la progra-
automáticamente si estas no mación para el desarrollador .
existen aun . Esto significa que
una vez ejecutado el código
TopLink a creado una tabla
para guardar la información de
“customers”. la tabla 1 muestra
la información DDL ( data
definition languaje ) de la tabla
“customer”.
Este es el DDL que JPA gene-
ra automáticamente de la clase
anotada “Customer” . Gracias
a la “codificación por defecto”
que guía JPA ( y en general
Java EE 5 ) No tengo que
hacer mucho para generar este
DDL , la codificación por de-
dades . Los
tipos de da-
tos son tam-
bién mapea-
dos por de-
fecto ( ejem-
plo String es
mapeado a
varchar
(255) ).
• AUTO (default) permite al Ahora quiero mejorar mi ma-
proveedor de persistencia
peo . Primero cambiar el nom-
(TopLink en mi caso) decidir
cual de las tres posibilidades bre de la tabla a "t_customer"
usar. en lugar de "customer". Luego
• SEQUENCE usar un SQL hare el nombre ( first name ) y
sequence para obtener el el apellido ( last name ) obliga-
próximo primary key
torios. El máximo largo de un
• TABLE requiere una tabla numero de teléfono
con dos columnas : el nombre
de la secuencia y su valor (telephone) tiene que ser 15
caracteres y la columna email
( esta es la estrategia por
defecto de TopLink ) tiene que ser renombrada a
• IDENTITY usa un “e_mail” con un "underscore" .
"identity generator" , ej :una
columna definida como
auto_increment en MySQL.
 JAVA PERSISTENCE API Page 4

Todos estos pequeños cambios pueden ser hechos con las anotaciones. Para cambiar el nombre
( name ) de la tabla anote la clase con @javax.persistence.Table . La anotación
@javax.persistence.Column es usada para definir las columnas y tienen una serie de atributos lista-
dos en la Tabla 3

Una aplicación

puede ser

notificada antes

o después de

ocurridos estos

eventos JPA
Anotaciones Callback
usando

"callback Ahora con el mapeo entre la actualizada o removida . Una Quiero verificar que el primer
clase Customer y la tabla aplicación puede ser notificada carácter del teléfono es "+" ,
annotations" t_customer quedo mejor gra- antes o después de ocurridos Yo puedo hacer esto antes que
cias a que las anotaciones estos eventos usando anotacio- la entidad sea persistida o actua-
@Column y @Table tienen nes . JPA tiene un conjunto de lizada . solo tengo que crear un
método ( validatePhoneNum-
muchos atributos. "callback annotatios" que pue-
ber en mi ejemplo , pero el
den ser usadas en métodos y nombre es irrelevante ) con
Hay otras dos cosas que quisie-
permiten al desarrollador añadir algo de lógica de negocios y con
ra hacer . Primero asegurarme
que todo
teléfono es
ingresado
usando códi-
gos interna-
cionales .
comenzando
con el
símbolo
'+' . Segun-
cualquier regla de negocios que las anotaciones @PrePersist y
do , calcular la edad del
desee . JPA llamara al método @PreUpdate, JPA hace el re-
“customer” a partir de la fecha
anotado antes o después de sto.
de nacimiento . Tengo muchas
estos eventos . La tabla 4 mues-
alternativas de como hacer estas El código de ejemplo en la si-
tra las "callback anotations"
tareas , pero voy a usar guiente pagina.
"callback annotations" Como uso las “callback annota-
Durante su ciclo de vida , una tios” para mis necesidades ? ,
entidad es cargada , persistida , Primero me encargare del for-
mato del numero de teléfono .

Page 5
Para la edad del cliente , hare
algo similar, calculare la edad del
cliente antes que la fecha de na-
cimiento sea insertada
( @PostPersist ) o actualizada
( @PostUpdate ) , y claro cada
vez que el cliente es cargado de
la base de datos ( @PostLoad ).
Anotaciones Callback .. añadir anotaciones
Para hacer que esto funcione .
necesito añadir un nuevo atri-
buto a la clase Customer : “date
of birth” . Para notificar a JPA
que mapee este atributo a una
fecha , uso la anotación
@Temporal con el atributo
TemporalType.DATE ( las
opciones son DATE , TIME ,
TIMESTAMP ) . Entonces
@PrePersist
@PreUpdate
private void validatePhoneNumber() {
if (telephone.charAt(0) != '+')
throw new IllegalArgumentException
("Invalid phone number");
}
}
@PostLoad
@PostPersist
@PostUpdate
public void calculateAge() {
Calendar birth = new GregorianCalendar();
birth.setTime(dateOfBirth);
Calendar now = new GregorianCalendar();
now.setTime(new Date());
int adjust = 0;
if (now.get(Calendar.DAY_OF_YEAR) - birth.get(Calendar.DAY_OF_YEAR) < 0)
{
adjust = -1;
}
age = now.get(Calendar.YEAR) - birth.get(Calendar.YEAR) + adjust;
}
estoy en la capacidad de calcu-
lar la edad del cliente pero yo
necesito persistir esa informa-
ción ? , NO , conociendo que el
valor cambia todos los años .
Para hacer que esta propiedad
(age) edad no sea persistente ,
usare la anotación @Transient
( La tabla no tendrá una colum-
na edad mas ) ver tabla 5.
 JAVA PERSISTENCE API Page 6

One to One Relationship

Ahora que tengo mapeada mi
clase Customer y tengo anota-
ciones callback para validar y
calcular data , necesito añadir
una dirección. Un Customer
tiene una y solo una
“address“ (dirección) entonces
Watermelon pueden enviar al
cliente un regalo por su cum-
pleaños . Lo representare como
una clase separada, clase Ad-
dress con un id , una calle
(street) , una ciudad (city) , un
código postal ( zip code ), y un
país (country).

al persistir o

remover

“customer”
One to One Relationship
también se hace
Como tu pueden ver en la tabla
con su “address”
6 , la clase Address usa la ano-
tación @Entity para notificar a
JPA que es una clase persisten-
te y @Column para customizar
el mapeo. Creando la relación
entre Customer y Address es
simple . Yo simplemente añado
una propiedad Address en la
clase Customer . Para persistir
la dirección de los "customer's"
uso el código que sigue :
public void createCustomerWithAddress() {
// Instantiates a Customer and an Address objecy
Customer customer = new Customer("John", "Lennon",
"+441909", "john@lenon.com", dateOfBirth);
Address homeAddress = new Address("Abbey Road",
"London", "SW14", "UK");
customer.setHomeAddress(homeAddress);
// Persists the customer with its address
trans.begin();
em.persist(homeAddress);
em.persist(customer);
trans.commit();
// Deletes the customer and the address
trans.begin();
em.remove(customer);
em.remove(homeAddress);
trans.commit();
}

One to One Relationship

Como este código muestra ,
usted tiene primero que instan-
ciar un objeto Customer y un
Adress , Para linkear los
dos ,uso un método setter ( set
HomeAddress ) y luego persis-
tido cada objeto , cada uno en
la misma transacción. Porque
no tiene sentido tener un
adress en el sistema que no este
linkeado a un customer , cuan-
do yo remuevo el customer
también remuevo el address. opcionales y basadas en mis
requerimientos, es decir al per-
Pero persistiendo y removien-
sistir o remover customer tam-
do ambos objetos parece que
bién se hace con su address.
se hiciera mas trabajo que el
que necesito. Seria mejor si yo
Quiero que un Customer tenga
pudiera persistir o remover
exactamente un Address , sig-
justo el objeto raíz ( el Custo-
nifica que un valor null no es
mer ) y permitir las dependen-
permitido . Puedo lograr todo
cias que se persistan o remue-
eso usando la anotación
van automáticamente ? , To-
@OneToOne junto con
pLink y la codificación por
defecto hará las asociaciones @JoinColumn.
Page 7 JAVA PERSISTENCE API

One to One Relationship

@OneToOne es usada para
anotar una relación . Este tiene
muchas propiedades incluyen-
do un cascade usado para
"cascading" de cualquier tipo
de acción. En este ejemplo ,
quiero "cascade" la acción de
persistir y remover. De esta
forma , cuando hago remove
o persist de un objeto custo-
mer este automáticamente lleva
acabo esta acción para el
"address" . El atributo fetch
dice a JPA que política usar
cuando cargamos una relación.
Esta puede ser una asociación
de carga tardía ( lazy loading
LAZY) , o "eagerly" (EAGER)
porque quiero cargar la direc-
ción de la casa "homeAddress"
tan pronto como el objeto
Customer es cargado.
La anotación @JoinColumn
tiene los mismos atributos co-
mo @Column , excepto que es
usado para asociar atributos ,
En este ejemplo , Yo renom-
bro la llave foránea en un ad-
dress_fk y no permito ningún
valor null ( nullable=false)
JPA entonces creara los si-
guientes DDLs con una cons-
traint de integridad ,para la
relación entre tablas
t_customer y t_adress ( ver El atributo
tabla 7 )
fetch dice a JPA

@Entity
que política usar
@Table(name = "t_customer")
public class Customer { cuando
@Id cargamos una
@GeneratedValue
private Long id;
(...) relación
@Transient
private Integer age;

@OneToOne(fetch = FetchType.EAGER, cascade =

{CascadeType.PERSIST, CascadeType.REMOVE})
@JoinColumn(name = "address_fk", nullable = false)
private Address homeAddress;

// constuctors, getters, setters

}
 JAVA PERSISTENCE API Page 8

Querying Objects
complejos sobre objetos ( aso- radores para filtrar la data ( IN ,
Hasta ahora yo estoy usando ciaciones , herencia , clases NOT IN , EXIST , LIKE , IS NULL , IS
JPA para mapear mis objetos a abstractas ) NOT NULL ) o para controlar las
una base de datos relacional y colecciones ( IS EMPTY , IS NOT
usar el entity manager para Los querys usan las palabras EMPTY , MEMBER OF ) , También
hacer algunas operaciones SELECT , FROM y WHE- hay funciones para manejar
CRUD (Create, read, update RE , mas un conjunto de ope- Strings ( LOWER , UPPER , TRIM ,
and delete ) , Pero CONCAT , LENGTH , SUBSTRING ) ,
JPA también permite // Finds the customers who are called John números ( ABS ,
que hagas querys SQRT , MOD ) , o
sobre los objetos. colecciones
Query query = em.createQuery("SELECT c ( COUNT , MIN ,
Esto usa "Java Persis- FROM Customer c WHERE
MAX , SUM ). Co-
tence Query Langua- c.firstname='John'");
ge" ( JPQL) , el cual List<Customer> customers = que- mo SQL , tu
es similar a SQL y es ry.getResultList(); también puedes
también independien- ordenar los
Usted tiene que te de la base de da- resultados
// Same query but using a parameter ( ORDER BY) o
tos , Este es un len- //Query query = em.createQuery("SELECT c FROM
hacer querys no guaje rico que nos agruparlos
//Customer c WHERE c.firstname=:param"); (GROUP BY)
permite hacer querys //query.setParameter(":param", "John");
sobre una tabla,

mas bien sobre

Querying Objects, sobre objetos ...
un objeto. Para hacer querys sobre los formas el string "John" es bus-
objetos se necesita EntityMa- cado : puede ser parte del que-
nager para crear un objeto ry JPQL o puede ser pasado
Query . Luego tengo el resulta- como parámetro , en este ulti-
do del query llamando el ge- mo caso necesito usar el méto-
tResultList o genSingleResult do setParameter.
cuando hay solo un objeto
retornado . En el ejemplo que
sigue , quiero buscar todos los
“Customers” quienes tienen el
primer nombre "John" , Yo
puedo hacer esto de dos for-
mas . De cualquiera de las dos

JPQL Queries, ejemplos ...

Como usted puede ver en este
query JPQL usa la notación
objeto . Usted tiene que hacer
query no sobre una tabla, mas
bien sobre un objeto. El carác-
ter “c” ( el nombre es irrele-
vante ) es el alias de un objeto
“customer” y el “c.firstname”
es la primera propiedad del Acá hay un conjunto de querys
objeto “customer” . Si ustedes que nosotros podemos hacer
quieren buscar todos los con JPQL . Ver tabla 8
“customers” que viven en U.S.
, ustedes pueden usar esta no-
tación , para obtener al atributo
country del objeto address.
SELECT c FROM Customer c WHERE
c.homeAddress.country='US';