====== Novedades de JPA 2.0 ====== --- //[[juanmiguelbg@um.es|JUAN MIGUEL BERNAL GONZALEZ]] 2014/03/25 16:21// JavaEE 6 ha introducido una revisión de la capa de persistencia (Java Persistence API o JPA) que introduce algunas novedades. Quizás no suficientes para justificar el cambio de numeración mayor, pero quizás haya venido dado por el Criteria API, que ha sido un añadido bastante pretencioso que busca un código de mayor calidad quizás no para los desarrolladores sino para generadores automáticos de código. Ahora vamos a relatar las [[http://en.wikibooks.org/wiki/Java_Persistence/What_is_new_in_JPA_2.0%3F|novedades de JPA 2.0]] con respecto a JPA 1.0. ==== Cache API ==== JPA 2.0 proporciona una interfaz //Cache// que puede obtenerse mediante el método //getCache()// de la clase //EntityManagerFactory//. La cache puede utilizarse para eliminar/invalidar manualmente entidades, clases completas y la cache al completo. También se puede comprobar si una entidad esta en la cache. JPA 2.0 proporciona un conjunto de //hints// para las consultas para permitir refrescar o saltar la cache. [[http://en.wikibooks.org/wiki/Java_Persistence/Caching#JPA_2.0_Cache_APIs|Referencia y Ejemplos]] ==== Colecciones de Elementos ==== JPA 2.0 define el mapeo de //ElementCollection//, que se utiliza para manejar mapeos de relaciones no estándar. Un //ElementCollection// se puede utilizar para definir una relación //OneToMany// con un objeto //Embeddable// o un valor //Basic// (como una colección de //Strings//). Puede utilizarse junto a una columna //Map// para definir relaciones donde la clave es un tipo de objeto y el valor es un objeto //Embeddable// o valor //Basic//. Los valores //ElementCollection// siempre se almacenan en una tabla separada, que se define con la anotación //@CollectionTable//. Esta anotación permite definir el nombre de la tabla y especificar la clave primaria mendiate las anotaciones //@JoinColumn// o si es compuesta mediante //@JoinColumns//. [[https://wiki.eclipse.org/EclipseLink/Examples/JPA/2.0/ElementCollections|Referencia y Ejemplos]] ==== Columnas Mapeadas Mediante Clave ==== Permite que una relación que habitualmente se representaría como una lista pueda representarse como un mapa incluyendo como clave algunos valores de la tabla de destino (entre otros). [[http://en.wikibooks.org/wiki/Java_Persistence/Relationships#Map_Key_Columns_.28JPA_2.0.29|Referencia y Ejemplos]] ==== Criteria API ==== JPA 2.0 defina una criteria API para consultas en un intento de simplificar la creación de consultas dinámicas. Con JPQL, las consultas dinámicas necesitan realizar concatenación de //String//. Además el JPQL es analizado en tiempo de ejecución provocando que los errores tipográficos se detecten más tarde. La criteria API utiliza un conjunto de interfaces Java para permitir que las consultas se construyan dinamicamente y permitiendo el análisis en tiempo de compilación. [[http://en.wikibooks.org/wiki/Java_Persistence/Criteria|Referencia y Ejemplos]] ==== Eliminación de Huérfanos ==== Una entidad huérfana, es aquella que es referenciado por una relación y que sin el valor de la fuente de la relación, su existencia no tiene sentido. JPA 2.0 proporciona la opción //orphanRemoval// en las anotaciones //@OneToMany// y //@OneToOne//. La eliminación de huérfanos asegura que cualquier objeto que no sea referenciado por una relación es borrado de la base de datos. [[http://en.wikibooks.org/wiki/Java_Persistence/Relationships#Orphan_Removal_.28JPA_2.0.29|Referencia y Ejemplos]] ==== Mejoras de EntityManager y Query API ==== Tanto el EntityManager como la Query API has sido mejorados para soportar cosas como obtener el primer resultado (JPA 1.0 permitía obtener un único resultado), especificar el tamaño máximo del resultado, permitir acceder a los objetos //query// y //entity manger// específicos del motor de persistencia y el //pessimistic locking// (JPA 1.0 solo soporta //optimistic locking//). [[http://en.wikibooks.org/wiki/Java_Persistence/Persisting|Entity Manager Updates]] JPA 2.0 soporta //pessimistic locking//, que permite obtener un //lock// sobre un objeto que se quiere editar y evitar que otros usuarios puedan modificar el objeto. [[http://en.wikibooks.org/wiki/Java_Persistence/Locking#Pessimistic_Locking|Referencia y Ejemplos]] - [[http://en.wikibooks.org/wiki/Java_Persistence/Locking#JPA_2.0_Locking|Tipos de Lock en JPA 2.0]] ==== Mejoras de JPQL ==== JPQL ha sido mejorado con SQL-like CASE, NULLIF, COALESCE y funcionalidades //like//. [[http://en.wikibooks.org/wiki/Java_Persistence/JPQL_BNF#New_in_JPA_2.0|Referencia y Ejemplos]] ==== Order Column ==== JPA 2.0 añade soporte para la ordenación de listas de bean de entidad mediante la anotación //@OrderColumn//. [[http://en.wikibooks.org/wiki/Java_Persistence/Relationships#Order_Column_.28JPA_2.0.29|Referencia y Ejemplos]] ==== Relación OneToMany Unidireccional ==== JPA 1.0 no soporta relaciones //OneToMany// unidireccionales sin una //JoinTable//. JPA 2.0 añade soporte para relaciones //OneToMany// unidireccionales añadiendo la anotación //@JoinColumn// para especificar la clave foránea. [[http://en.wikibooks.org/wiki/Java_Persistence/OneToMany#Undirectional_OneToMany.2C_No_Inverse_ManyToOne.2C_No_Join_Table_.28JPA_2.0.29|Referencia y Ejemplos]] ==== Tipos de Acceso ==== JPA 2.0 permite definir dos tipos de acceso: * Acceso a variable (AccessType.Field) * Acceso a propiedad (AccessType.Property) El tipo de acceso que usará una entidad está definido por el lugar donde situemos sus anotaciones de mapeo: * Si las anotaciones están en las variables que conforman la clase (como hemos hecho hasta ahora), estaremos indicando a JPA que debe realizar acceso a variable. * Si las anotaciones de mapeo en los métodos //getter//, estaremos indicando un acceso a propiedad. A efectos prácticos, no existe diferencia alguna entre ambas opciones (más allá de gustos personales y de organización de código). Sin embargo, en determinadas ocasiones debemos ser consecuentes con el tipo de acceso que elijamos, evitando mezclar tipos de acceso (lo cual puede inducir a JPA a actuar de forma errónea). Un ejemplo típico es el uso de clases insertables: salvo que se especifique lo contrario, las clases insertables heredan el tipo de acceso de la entidad donde son insertadas, ignorando cualquier anotación que se haga hecho sobre ellas previamente. ---- ===== Referencias ===== [[http://www.davidmarco.es/articulo/introduccion-a-jpa-2-0-i|Introduccion a JPA 2.0 (I)]] - [[http://www.davidmarco.es/articulo/introduccion-a-jpa-2-0-ii|(II)]] - [[http://www.davidmarco.es/articulo/introduccion-a-jpa-2-0-iii|(III)]] - [[http://www.davidmarco.es/articulo/introduccion-a-jpa-2-0-iv|(IV)]] [[http://musingsofaprogrammingaddict.blogspot.com.es/2010/01/jpa-2-and-bean-validation-in-action.html|JPA 2 and Bean Validation in Action]] [[http://www.jboss.org/jdf/examples/ticket-monster/tutorial/DataPersistence/|TicketMonster Tutorial - Building the persistence layer with JPA2 and Bean Validation]] [[http://docs.jboss.org/hibernate/core/4.2/manual/en-US/html/|Hibernate 4.2 Reference Documentation]] - [[http://docs.jboss.org/hibernate/core/4.2/devguide/en-US/html/|Developer Guide]] - [[http://docs.jboss.org/hibernate/core/4.2/quickstart/en-US/html/|Getting Started Guide]] [[http://www.arquitecturajava.com/entitymanagerentidades-y-estados-jpa-ii/|EntityManager entidades y estados]]