Download Java Persistance Persistance API

Java Persistance
API
JPA
¿Qué es una
Entidad?
¿Qué es una entidad?
¬ Plain Old Java Object(POJO)
Se crean por medio de la palabra reservada new
¬ No se requieren interfaces
¬ Tiene una identidad de persistencia
¬ Puede tener estados tanto persistentes como no
persistentes
Tipos Simples (ej.
(ej primitivos,
primitivos enums ..))
Estados no persistentes (transient o @Transient)
¬ Permite herencia entre entidades
¬ Serializable; usable como objetos separados
en otras capas
No necesitan objetos de transferencia de datos
Ejemplo de Entidad
@Entity
public
bli class
l
Customer
C t
implements
i
l
t Serializable
S i li bl {
@Id protected Long id;
protected String name;
@Embedded p
protected Address address;;
protected PreferredStatus status;
@Transient protected int orderCount;
}
public Customer() {}
public Long getId() {return id;}
protected void setId(Long id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this
{this.name
name = name;}
…
Llave primaria (Pk
(Pk - Id) de la Entidad
¬ Cada Entidad tiene una llave p
primaria ((identity)
y)
de persistencia.
¬ Puede corresponder a un tipo simple
@EmbeddedId – campo simple/propiedad en la
clase entidad
@
@IdClass – corresponde
p
a muchos campos
p Id en la
clase entidad
¬ Debe ser definido en la raíz de la jerarquía d eal
entidad o clase padre mapeada
Modelo de
Programación
ó
Modelo de Programación de Persistencia de Java
¬ La entidad es un POJO ((no necesita implementar
p
un EntityBean)
¬ Uso de Annotations para denotar un POJO como
una entidad
tid d ((en lugar
l
de
d un descriptor)
d
i t )
// @Entity is an annotation
// It annotates Employee POJO class to be Entity
@Entity
public class Employee {
// Persistent/transient fields
// Property accessor methods
// Persistence logic methods
}
Ejemplo de Entidad de Persistencia (1)
@Entity
public
bli class
l
C t
Customer
{
Annotation Æ denota que es Entidad
private Long id;
private String name;
private Address address;
p
private Collection<Order> orders = new HashSet();
public Customer() {}
@Id denota la llave primaria
@Id public Long getID() {
return id;
}
protected void setID (Long id) {
this.id = id;
}
...
Métodos accesores para acceder el estado
Ejemplo de Entidad de Persistencia (2)
...
// Relationship between Customer and Orders
@OneToMany
public Collection<Order> g
p
getOrders()
() {
return orders;
}
public void setOrders(Collection<Order> orders) {
this.orders = orders;
}
// Other business methods
...
}
Código de Cliente: De Java SE Client
public static void main(String[]
p
(
g[] args)
g ){
EntityManagerFactory emf =
Persistence.createEntityManagerFactory("EmployeeService);
EntityManager em = emf.createEntityManager();
Collection emps = em.createQuery("SELECT e FROM
Employee
p y e"))
.getResultList();
// More codes
Contexto de
Persistencia y
Manejador de Entidad
Persistance Context &
Entity Manager (EM)
Contexto de Persistencia y Manejador de Entidad
¬ Contexto de Persistencia
R
Representa un conjunto
j
d
de instancias
i
i d
de entidad
id d
administradas por la capa de persistencia en tiempo de
ejecución
“Una instancia de Entidad es un estado administrado”
significa
i ifi que lla iinstancia
i está
á contenida
id en un contexto d
de
persistencia
Inclusión o exclusión de una entidad en/de el contexto de
persistencia determina la salida de cualquier operación de
persistencia en él
No es directamente accesible para la aplicación
es accedido indirectamente a través del
EM – el tipo de EM determina cómo un contexto de
persistencia es creado y borrado
¬ Manejador de Entidad (EM)
Realiza operaciones del ciclo de vida en entidades –
administra
d i i t ell contexto
t t d
de persistencia
i t
i
Operaciones de ciclo
de vida de una Entidad
Administrador de Entidad (EM)
¬ En funcionalidad es similar a el Hibernate
Session, JDO PErsistanceManajer, etc
¬ Controla el ciclo de vida de las entidades
persist() – inserta una entidad a la BD
remove() – remueve una entidad de la BD
merge() – sincroniza el estado de entidades
separadas
refresh() – refresca el estado desde la BD
Operación de Persistencia
public Order createNewOrder(Customer
p
(
customer)) {
Order order = new Order(customer);
// Transitions new instances to managed. On the
// next flush or commit, the newly persisted
// instances will be inserted into the datastore.
entityManager persist(order);
entityManager.persist(order);
return order;
}
Operaciones de Búsqueda y Eliminación
public void removeOrder(Long
p
(
g orderId)) {
Order order = entityManager.find(Order.class, orderId);
// The instances will be deleted from the datastore
// on the next flush or commit. Accessing a
// removed entity has undefined results.
entityManager remove(order);
entityManager.remove(order);
}
Operación de Merge
public OrderLine updateOrderLine(OrderLine
p
p
(
orderLine) {
// The merge method returns a managed copy of
// the
th given
i
detached
d t h d entity.
tit Changes
Ch
made
d to
t the
th
// persistent state of the detached entity are
// applied to this managed instance.
return entityManager.merge(orderLine);
}
Transacciones
Tipos de Transacciones
¬ Dos tipos de transacciones
Transacciones de recurso local (Resource - local)
JTA (Java Transaction API)
˜ Participan múltiples recursos
˜ Transacciones XA distribuidas
¬ El tipo de transacción es definido en la unidad de
persistencia ((archivo p
p
persistance.xml))
El valor default es JTA para JavaEE y RESOURCE_LOCAL
para Java SE
¬ EM administrado p
por un contendor utiliza
transacciones de JTA
Propagación del contexto de persistencia con
transacciones de JTA es gestionado por el contenedor –
compartiendo
ti d ell mismo
i
contexto
t t de
d persistencia
i t
i entre
t
múltiples EMs
Transacciones Y Contexto de Persistencia
¬ Las transacciones definen cuando las entidades
nuevas, modificadas, o borradas so sincronizadas
con la base de datos
¬ La
L creación
ió y uso del
d l contexto
t t de
d persistencia
i t
i es
determinado por el tipo de Transacción
(Resource-local o JTA) y el atributo de
Transacción (REQUIRED o ..)
Mapeo a O/R
Mapeo a O/R
¬ Conjunto
j
de annotations extenso definido p
por el
mapeo
Relaciones
Joins
J i
Tablas y columnas de BD
Generadores de secuencias de BD
¬ Especificadas utilizando
Annotations en el código
Archivo de mapeo por separado
Mapeos Simples
@Entity(access=FIELD)
public class Customer {
@Id
int id;
String name;
@Column(name=“CREDIT”)
int c_rating;
@Lob
Image photo;
}
CUSTOMER
ID
NAME
CREDIT
PHOTO
Ejemplo de Mapeo O/R
@Entity
@
y
@Table(name="EMPLOYEE",
schema="EMPLOYEE_SCHEMA")
uniqueConstraints=
{@UniqueConstraint(columnNames={"EMP_ID",
"EMP_NAME"})}
public class EMPLOYEE {
... @Column(name=
@Column(name="NAME"
NAME , nullable=false,
nullable=false length=30)
public String getName() { return name; }
}
Relaciones de
Entidades
Relaciones de Entidades
¬ Modela asociación entre entidades
¬ Soporta relaciones tanto unidireccionales como
bidireccionales
Relación
ó unidireccional: Entidad A hace referencia a
B, pero B no hace referencia a A
¬ Cardinalidades
Uno a uno
Uno a muchos
Muchos a uno
Muchos a muchos
Relaciones de Entidades:
Ejemplo Muchos a Muchos
@Entity
public
bli class
l
P j
Project
{
private Collection<Employee> employees;
@ManyToMany
public Collection<Employee> getEmployees() {
return employees;
p y
;
}
public void setEmployees(Collection<Employee> employees) {
thi
this.employees
l
= employees;
l
}
...
}
Comportamiento en Cascada
¬ “Cascading”
g es utilizado p
para propagar
p p g el efecto
de una operación en todas las entidades
relacionadas
Cascade = PERSIST
Cascade = REMOVE
Cascade = MERGE
Cascade = REFRESH
Cascade = ALL
QUERY
Mejora a EJB
EJB--QL
¬ Soporta
p
queries dinámicos,, además de q
q
queries
prefabricados o queries estáticos
¬ Queries polimórficos
¬ Operaciones de actualización y eliminación en
grandes bloques
¬ Joins
¬ Agrupaciones
¬ Subqueries
q
¬ Funciones de SQL Adicionales
UPPER, LOWER, TRIM, CURRENT_DATE
Queries
¬Q
Queries Estáticos
Definidos con metadatos de lenguaje de java o XML
˜ Annotations: @NamedQuery, @NamedNativeQuery
¬ Queries Dinámicos
El query se especifica en tiempo de ejecución
¬ Utiliza Lenguaje de Query de Persistencia de Java
o SQL
¬ Parámetros nombrados o posicionados
¬ El EM es fábrica de objetos de query
createNamedQuery, createQuery,
createNativeQuery
¬ Métodos de query para contolar resultados
máximos, paginación, modo flush
Queries Dinámicos
// Build and execute q
queries dynamically
y
y at runtime.
public List findWithName (String name) {
return em.CreateQuery (
“SELECT c FROM Customer c ” +
“WHERE c.name LIKE :custName”)
.setParameter(
setParameter(“custName”
custName , name)
.setMaxResults(10)
.getResultList();
}
Named Query
// Named q
queries are a useful way
y to create reusable queries
q
@NamedQuery(
name=“findCustomersByName”,
queryString=“SELECT c FROM Customer c ” +
“WHERE c.name LIKE :custName”
)
@PersistenceContext public EntityManager em;
List customers =
em.createNamedQuery(“findCustomersByName”).
setParameter(“custName”,
(
, “smith”).getResultList();
)g
();
Referencias
Java Persistence API: Simplifying
p y g Persistence
Sang Shin
Java Technology Evangelist
Sun Microsystems, Inc.