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) Annotation  denota que es Entidad @Entity public class Customer { private Long id; private String name; private Address address; private Collection<Order> orders = new HashSet(); public Customer() {} @Id public Long getID() { return id; } protected void setID (Long id) { this.id = id; ... @Id denota la llave primaria 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 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 Queries Dinámicos 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.