Download Jpa

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. 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 class Customer implements Serializable {
@Id protected Long id;
protected String name;
@Embedded 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.name = name;}
…
Llave primaria (Pk - Id) de la Entidad
 Cada Entidad tiene una llave primaria (identity)
de persistencia.
 Puede corresponder a un tipo simple
 @EmbeddedId – campo simple/propiedad en la
clase entidad
 @IdClass – corresponde a muchos campos 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
un EntityBean)
 Uso de Annotations para denotar un POJO como
una entidad (en lugar de un descriptor)
// @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 class Customer {
Annotation  denota que es Entidad
private Long id;
private String name;
private Address address;
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> 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[] args) {
EntityManagerFactory emf =
Persistence.createEntityManagerFactory("EmployeeService);
EntityManager em = emf.createEntityManager();
Collection emps = em.createQuery("SELECT e FROM
Employee 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
 Representa un conjunto de instancias de entidad
administradas por la capa de persistencia en tiempo de
ejecución
 “Una instancia de Entidad es un estado administrado”
significa que la instancia está contenida en un contexto 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 el contexto de persistencia
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 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);
return order;
}
Operaciones de Búsqueda y Eliminación
public void removeOrder(Long 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);
}
Operación de Merge
public OrderLine updateOrderLine(OrderLine
orderLine) {
// The merge method returns a managed copy of
// the given detached entity. Changes made to the
// 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 persistance.xml)
 El valor default es JTA para JavaEE y RESOURCE_LOCAL
para Java SE
 EM administrado por un contendor utiliza
transacciones de JTA
 Propagación del contexto de persistencia con
transacciones de JTA es gestionado por el contenedor –
compartiendo el mismo contexto de persistencia entre
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 creación y uso del contexto de persistencia 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 de annotations extenso definido por el
mapeo
 Relaciones
 Joins
 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
@Table(name="EMPLOYEE",
schema="EMPLOYEE_SCHEMA")
uniqueConstraints=
{@UniqueConstraint(columnNames={"EMP_ID",
"EMP_NAME"})}
public class EMPLOYEE {
... @Column(name="NAME", 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 class Project {
private Collection<Employee> employees;
@ManyToMany
public Collection<Employee> getEmployees() {
return employees;
}
public void setEmployees(Collection<Employee> employees) {
this.employees = employees;
}
...
}
Comportamiento en Cascada
 “Cascading” es utilizado para propagar 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-QL
 Soporta queries dinámicos, además de queries
prefabricados o queries estáticos
 Queries polimórficos
 Operaciones de actualización y eliminación en
grandes bloques
 Joins
 Agrupaciones
 Subqueries
 Funciones de SQL Adicionales
 UPPER, LOWER, TRIM, CURRENT_DATE
Queries
 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 queries dynamically at runtime.
public List findWithName (String name) {
return em.CreateQuery (
“SELECT c FROM Customer c ” +
“WHERE c.name LIKE :custName”)
.setParameter(“custName”, name)
.setMaxResults(10)
.getResultList();
}
Named Query
// Named queries are a useful way to create reusable queries
@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();
Referencias
Java Persistence API: Simplifying Persistence
Sang Shin
Java Technology Evangelist
Sun Microsystems, Inc.