Download Java Persistance Persistance API

Survey
yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts
no text concepts found
Transcript
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.