Java Persistence API

Aplicaciones Empresariales Java

ESCUELA SUPERIOR POLITCNICA DE CHIMBORAZO

SEMESTRE SEPTIEMBRE 2011 FEBRERO 2012 JPA PERSISTENCE IDENTIFICACIONFacultad: Carrera: Materia: Semestre: Docente: Integrantes: Fecha: Facultad de Informtica y Electrnica Escuela de Ingeniera en Sistemas Aplicaciones Empresariales Java Noveno Ing. Jorge Huilca Palacios Luis Patio 10/02/12

Calificacin

Sello del Docente

Espacio reservado para el docente

JPA

1


ContenidoJAVA PERSISTENCE API (JPA) ........................................................................................................ 4 INTRODUCCIN................................................................................................................................. 4 OBJETIVOS .................................................................................................................................... 4 GENERAL ................................................................................................................................... 4 ESPECFICOS ............................................................................................................................ 4 MARCO TERICO .............................................................................................................................. 5 Definicin ......................................................................................................................................... 5 Arquitectura ..................................................................................................................................... 5 Caractersticas................................................................................................................................. 7 Tipos Asociados: ......................................................................................................................... 7 Campos persistentes ................................................................................................................... 8 Propiedades persistentes ............................................................................................................ 8 Clases con claves primarias ........................................................................................................ 9 Relaciones mltiples de la entidad .............................................................................................. 9 Relaciones y borrado en cascada ............................................................................................. 10 Entity Manager .......................................................................................................................... 10 El contexto de persistencia ....................................................................................................... 10 Contenedor de Manager entity .................................................................................................. 11 Instancias de entidades persistentes ........................................................................................ 12 Eliminar instancias entity ........................................................................................................... 13 Sincroizacin entre entidades y base de datos ............................................................................. 14 Creacin de consultas ............................................................................................................... 14 Paso de parmetros en las queries........................................................................................... 15 Unidades de persistencia .............................................................................................................. 16 El fichero persistence.xml ......................................................................................................... 16 Ventajas e inconvenientes ............................................................................................................ 17 Interaccin con otros subsistemas o componentes ...................................................................... 17 Hibernate ................................................................................................................................... 17 TopLink ...................................................................................................................................... 18 EJB ............................................................................................................................................ 18 EclipseLink ................................................................................................................................ 18 Modo de empleo (Aplicacin Web) ............................................................................................... 18

JPA

2


EclipseLink .................................................................................................................................... 19 Desarrollo Aplicativo .......................................................................................................................... 20 CONCLUSIONES .............................................................................................................................. 34 RECOMENDACIONES ..................................................................................................................... 34 Bibliografa......................................................................................................................................... 34 ANEXOS ............................................................................................................................................ 35 Anexo1. ......................................................................................................................................... 35 Anexo 2. ........................................................................................................................................ 37 Anexo3. ......................................................................................................................................... 40

JPA

3


JAVA PERSISTENCE API (JPA) INTRODUCCINEn Java solucionamos problemas de negocio a travs de objetos, los cuales tienen estado y comportamiento. Sin embargo, las bases de datos relacionales almacenan la informacin mediante tablas, filas y columnas, de manera que para almacenar un objeto hay que realizar una correlacin entre el sistema orientado a objetos de Java y el sistema relacional de nuestra base de datos. JPA (Java Persistence API) es una abstraccin sobre JDBC que nos permite realizar dicha correlacin de forma sencilla, realizando por nosotros toda la conversion entre objeto y base de datos. Esta conversin se llama ORM(Object Relational Mapping - Mapeo Relacional de Objetos) y puede configurarse a travs de metadatos (mediante xml o anotaciones). Por supuesto que JPA tambin nos permite seguir el sentido inverso, creando objetos desde una base de datos de forma totalmente transparente. A estos objetos los llamaremos desde ahora entidades (entities). JPA establece una interface comun que es implementada por un proveedor de persistencia de nuestra eleccion (como Hibernate, Eclipse Link, etc) de manera que podemos elegir en cualquier momento el proveedor que mas se adecue a nuestrasnecesidades. Asi, es el proveedor quien realiza el trabajo, pero siempre funcionando bajo la API de JPA. En el presente documento se presenta un estudio del JPA Perisistence de Java, adems se presenta un ejemplo aplicativo web.

OBJETIVOSGENERAL Investigar el Api de Persistencia de Java y su implementacin mediante EclipseLink ESPECFICOS Estudiar los conceptos, definiciones de la Api de Persistencia Java. Conocer la implantacin de JPA mediante EclipseLink. Implementar el JPA mediante una aplicacin web.

JPA

4


MARCO TERICODefinicinJava Persistence API (JPA) proporciona un modelo de persistencia basado en POJO's para mapear bases de datos relacionales en Java. El Java Persistence API fue desarrollado por el grupo de expertos de EJB 3.0 como parte de JSR 220, aunque su uso no se limita a los componentes software EJB. Tambin puede utilizarse directamente en aplicaciones web y aplicaciones clientes; incluso fuera de la plataforma Java EE, por ejemplo, en aplicaciones Java SE.

En su definicin, se han combinado ideas y conceptos de los principales frameworks de persistencia como Hibernate, Toplink y JDO, y de las versiones anteriores de EJB. Todos estos cuentan actualmente con una implementacin JPA. (R1) JPA: Java Persistence APIJava Persistence API (JPA) proporciona un estndar para gestionar datos relacionales en aplicaciones Java SE o Java EE, de forma que adems se simplifique el desarrollo de la persistencia de datos.Es una API de persistencia de POJOs(PlainOld Java Object). Es decir, objetos simples que no heredan ni implementan otras clases (como los

EJBs).Requerimientos:Programacin Orientada a objetosAnotaciones en Java 5Generic en java 5Base de datos relacionalesLenguaje estructurado de consultas (SQL)

ArquitecturaEl siguiente diagrama muestra la relacin entre los componentes principales de la arquitectura de JPA:

JPA

5


Varias de las interfaces del diagrama anterior son solo necesarias para su utilizacin fuera de un servidor de aplicaciones que soporte EJB 3, como es el caso del EntityManagerFactory que es ampliamente usado en desarrollo de aplicaciones de escritorio. En un servidor de aplicaciones, una instancia de EntityManager tpicamente suele ser inyectada, haciendo as innecesario el uso de un EntityManagerFactory. Por otra parte, las transacciones dentro de un servidor de aplicaciones se controlan mediante un mecanismo estndar de controles de, por lo tanto la interfaz EntityTransaction tambin no es utilizada en este ambiente. Persistence: La clase javax.persistence.Persistence contiene mtodos estticos de ayuda para obtener una instancia de EntityManagerFactory de una forma independiente al vendedor de la implementacin de JPA. EntityManagerFactory: La clase javax.persistence.EntityManagerFactory nos ayuda a crear objetos de EntityManager utilizando el patrn de diseo del Factory (fbrica). EntityManager: La clase javax.persistence.EntityManager es la interfaz principal de JPA utilizada para la persistencia de las aplicaciones. Cada EntityManager puede realizar operaciones CRUD (Create, Read, Update, Delete) sobre un conjunto de objetos persistentes. Entity: La clase javax.persistence.Entity es una anotacin Java que se coloca a nivel de clases Java serializables y que cada objeto de una de estas clases anotadas representa un registro de una base de datos. EntityTransaction: Cada instancia de EntityManager tiene una relacin de uno a uno con una instancia de javax.persistence.EntityTransaction, permite operaciones sobre datos persistentes de manera que agrupados formen una unidad de trabajo transaccional, en el que todo el grupo sincroniza su estado de persistencia en la base de datos o todos fallan en el intento, en caso de fallo, la base de datos quedar con su estado original. Maneja el concepto de todos o ninguno para mantener la integridad de los datos. Query: La interface javax.persistence.Query est implementada por cada vendedor de JPA para encontrar objetos persistentes manejando cierto criterio de bsqueda. JPA estandariza el soporte para consultas utilizando Java Persistence Query Language (JPQL) y Structured Query Language (SQL). Podemos obtener una instancia de Query desde una instancia de un EntityManager.

JPA

6


CaractersticasUna entidad es un objeto de dominio de persistencia. Normalmente, una entidad representa una tabla en el modelo de datos relacional y cada instancia de esta entidad corresponde a un registro en esa tabla.

El estado de persistencia de una entidad se representa a travs de campos persistentes o propiedades persistentes. Estos campos o propiedades usan anotaciones para el mapeo de estos objetos en el modelo de base de datos.

El estado persistente de una entidad puede ser accesible a travs de variables de instancia a la entidad o bien a travs de las propiedades de estilo de JavaBean. Lo campos o propiedades pueden tener asociados los siguientes tipos Java:

Tipos Asociados:Tipos primitivos de Java java.lang.String Otro tipo de objeto serializable, incluyendo: Wrappers de tipos primitivos en Java java.math.BigInteger java.math.BigDecimal java.util.Date java.util.Calendar java.sql.Date java.sql.Time java.sql.TimeStamp User-defined serializable types byte Byte char Character Tipos enumerados

Otras entidades y/o colecciones de entidades Las entidades podrn utilizar campos persistentes o propiedades. Si las anotaciones de mapeo se aplican a las instancias de las entidades, la entidad utiliza campos persistentes, En cambio, si se aplican a los mtodos getters de la entidad, se utilizarn propiedades persistentes. Hay que tener en cuenta que no es posible aplicar anotaciones tanto a campos como a propiedades en una misma entidad.

JPA

7


Campos persistentesSi la entidad utiliza campos persistentes, los accesos se realizan en tiempo de ejecucin. Aquellos campos que no tienen anotaciones del tipo javax.persistence.Transient o no han sido marcados como Java transitorio sern persistentes para el almacenamiento de datos. Las anotaciones de mapeo objeto/relacin deben aplicarse a los atributos de la instancia.

Propiedades persistentesSi la entidad utiliza propiedades persistentes, la entidad debe seguir el mtodo de los convenios de componentes JavaBeans. Las propiedades de JavaBean usan mtodos getters y setters en cuyo nombre va incluido el atributo de la clase al cual hacen referencia. Si el atributo es booleano podr utilizarse isProperty en lugar de getProperty. Por ejemplo, si una entidad Customer, utiliza las propiedades de persistencia, supongamos que tiene un atributo privado denominado firsName, la clase definir los mtodos getFirstName y setFirstName para recuperar y establecer el valor de la variable firstName.

Los mtodos para la firma de un valor nico de propiedades son los siguientes. Tipo getProperty () void setProperty (Tipo tipo)

Tanto los campos persistentes como las propiedades deben utilizar las interfaces de Java independientemente de que la entidad utilice campos o propiedades. Las colecciones posibles son: Colecciones: java.util.Collection java.util.Set java.util.List java.util.Map Si la entidad utiliza campos persistentes, el tipo en el mtodo anterior debe ser uno de estos tipos de collection. Las variables genricas de estos tipos tambin pueden ser utilizadas. Por ejemplo, si la entidad Customer tiene un atributo que contiene un conjunto de nmeros de tlfno, tendr que tener los siguientes mtodos: Set getPhoneNumbers() {} void setPhoneNumbers(Set) {}

JPA

8


Las anotaciones del mapeo objeto/relacional deben aplicarse a los mtodos getter. El mapeo de las anotaciones no puede aplicarse a los campos o propiedades anotadas como @Transient o marcadas como transient.

Clases con claves primariasUna clase con clave primaria debe cumplir los siguientes requerimientos: El modificador de control de acceso de la clase debe ser pblico Las propiedades de la clave primaria deben ser pblicas o protected si se utiliza el acceso a la base de la propiedad.

La clase debe tener un constructor pblico por defecto. La clase debe implementar los mtodos hashCode() y equals(Object other) La clase debe ser serializable.

Una clave primaria debe representarse y mapearse por campos mltiples o propiedades de la clase de la entidad, o debe representarse y mapearse como una clase embebida.

Si la clave primaria est compuesta por varios campos o propiedades, los nombres y tipos de campos de la clave primaria o propiedades en la clave primaria debe coincidir con las de la entidad.

Relaciones mltiples de la entidad Hay cuatro tipo de relaciones: uno a uno, uno a muchos, muchos a uno, y muchos a muchos.

Uno a uno: Cada entidad se relaciona con una sola instancia de otra entidad. Por ejemplo, al modelo fsico de almacn en el que cada almacn contiene un nico artilugio, StorageBin y Widget, deberan tener una relacin uno a uno. Las relaciones uno a uno utilizan anotaciones javax.persistence.OneToOne. Uno a muchos: Una entidad, puede estar relacionada con varias instancias de otras entidades. Una orden de venta (Order), por ejemplo, puede tener varias partidas (LineItem). En la aplicacin de la orden, La orden (Order) tendr una relacin uno a muchos con las partidas (LineItem). Las relaciones uno a muchos utilizan anotaciones javax.persistence.OneToMany en los campos o propiedades persistentes.

JPA

9


Muchos a uno: Mltiples instancias de una entidad pueden estar relacionadas con una sola instancia de otra entidad. Esta multiplicidad es lo contrario a la relacin uno a muchos. En el ejemplo anterior, desde la perspectiva de la orden de venta (LineItem) la relacin con la Orden (Order) es de muchos a uno. Las relaciones muchos a uno utilizan anotaciones

javax.persistence.ManyToOne en los campos o propiedades persistentes.

Muchos a muchos: En este caso varias instancias de una entidad pueden relacionarse con mltiples instancias de otras entidades. Por ejemplo, cada curso de una universidad tiene muchos estudiantes, y cada estudiante puede tener varios cursos. Por lo tanto, en una solicitud de inscripcin, los cursos y los estudiantes tendran una relacin muchos a muchos. Este tipo de relacin utiliza anotaciones javax.persistence.ManyToMany en los campos o propiedades persistentes.

Relaciones y borrado en cascada Existen entidades que utilizan relaciones con dependencias de relaciones de otra entidad. Por ejemplo, una lnea es parte de una orden, y si la orden es eliminada, entonces la lnea tambin debe eliminarse. Esto se llama borrado en cascada. Las relaciones de borrado en cascada se especifican utilizando cascade=REMOVE, elemento que viene en la especificacin de las relaciones @OneToOne y @OneToMany. Por ejemplo:

@OneToMany(cascade=REMOVE, mappedBy="customer") public Set getOrders() { return orders; } Entity Manager Las entidades son gestionadas por el Entity Manager. ste se representa por instancias javax.persistence.EntityManager. A cada instancia de EntityManager se le asocia con un contexto de persistencia. Un contexto de persistencia define el mbito particular, bajo el cual se crean o se eliminan las instancias de la entidad.

El contexto de persistencia Un contexto de persistencia es un conjunto de instancias que existen en un almacn de datos. El interfaz EntityManager define los mtodos que se utilizan para interactuar con el contexto de persistencia.

Interfaz EntityManager La API entityManager crea y elimina instancias de entidades persistentes, busca entidades a partir

JPA

10


de su clave primaria y permite ejecutar queries.

Contenedor de Manager entityCon un contenedor de entidades, una instancia de un EntityManager de un contexto persistente se propaga automticamente por el contenedor de aplicacin a todos los componentes que utilizan la instancia del EntityManager en una sola transaccin Java (JTA). Para obtener una instancia de un EntityManager, basta con incluir la entidad dentro del componente de la aplicacin:

@ PersistenceContext

EntityManager em;Con entity managers por el contrario, el contexto de persistencia no se propaga a los componentes de la aplicacin y el ciclo de vida de las instancias del EntityManager se gestionan por la aplicacin.

El administrador de EntityManagers de la aplicacin se usa cuando las aplicaciones necesitan acceso al contexto de persistencia cuando no se propaga con la transaccin JTA a travs de la instancia del EntityManager en una unidad de persistencia particular. En este caso, cada EntityManager crea un nuevo contexto de persistencia.El EntityManager, y sus contextos de persistencia asociados, se crean y se destruyen explcitamente por la aplicacin.

Las aplicaciones crean instancias de EntityManager en esos casos mediante el mtodo createEntityManager de javax.persistence.EntityManagerFactory.

Para

obtener

una

instancia

EntityManager,

primero

debe

obtener

una

instancia

EntityManagerFactory mediante la una anotacin de javax.persistence.PersistenceUnit:

@PersistenceUnit EntityManagerFactory emf;

A continuacin, se obtiene un EntityManager de la instancia EntityManagerFactory:

JPA

11


EntityManager em = emf.createEntityManager ();

Se buscan las entidades utilizando el EntityManager. El mtodo EntityManager.find se utiliza para buscar entidades en el almacn de datos a partir de la clave primaria de la entidad. @ PersistenceContext EntityManager em; public void enterOrder (int custID, Order newOrder) ( Customer cliente = em.find (Customer.class, custID); cliente.getOrders (). add(newOrder); newOrder.setCustomer (cliente);

Gestin del ciclo de vida de una instancia Entity Las instancias de un entity pueden encontrarse en uno de estos cuatro estados: nuevo, gestionado, trasladado o eliminado. Una nueva instancia no tiene identidad de persistencia e incluso no tiene asociado su contexto de persistencia. Una instancia gestionada tiene una identidad persistente y est asociada con un contexto de persistencia. Una instancia trasladada tiene una identidad persistente y no se encuentra actualmente asociada con un contexto de persistencia.

Una instancia eliminada tiene una identidad persistente y se encuentra asociada con un contexto persistente. Se preve el borrado del almacn de datos.

Instancias de entidades persistentes Una nueva instancia se gestiona y se actualiza invocando al mtodo persist, o por una operacin de actualizacin en cascada llamada desde una entidad relacionada a travs de las anotaciones cascade=PERSIST o cascade=ALL. Esto significa que el dato de la entidad se almacena en base de datos cuando la transaccin asociada con la operacin persist se completa. Si la entidad ya se encuentra actualizada, la operacin persist se ignora, aunque la operacin persist se ejecutar en cascada con las entidades relacionadas. Si se llama al mtodo persist o al mtodo removed, se convierte en una instancia gestionada. Si la entidad se separa, el mtodo persist elevar una excepcin IllegalArgumentException, o la realizacin del commit fallar. Insertando instancias entity @PersistenceContext EntityManager em;

JPA

12


... public LineItem createLineItem(Order order, Product product, int quantity) { LineItem li = new LineItem(order, product, quantity); order.getLineItems().add(li); em.persist(li); return li; }

La operacin persist se propaga a todas las entidades relacionadas con la entidad que tienen el elemento de cascada configurado con ALL o PERSIST

@OneToMany(cascade=ALL, mappedBy="order") public Collection getLineItems() { return lineItems; } Eliminar instancias entity La instancias del entity managed se eliminan invocando al mtodo remove, o por un borrado en cascada invocado desde una entidad relacionada. Si el mtodo remove se invoca desde una entidad nueva, la operacin de borrado se ignora, aunque se borrarn en cascada las entidades relacionadas que tienen configurado su borrado en cascada mediante las anotaciones REMOVE o ALL. Si el mtodo remove se invoca en una entidad en estado trasladada se elevar una excepcin IllegalArgumentException, la transaccin de commit fallar. Si el mtodo remove se invoca desde una entidad ya eliminada, se ignorar. El dato representado por la entidad se eliminar de la base de datos cuando la transaccin se complete, o cuando se realice la operacin de descarga.

public void removeOrder(Integer orderId) { try { Order order = em.find(Order.class, orderId); em.remove(order); }...

En este ejemplo, todos los LineItem, entidades asociadas con el objeto order, sern eliminados, ya que Order.getLineItems tiene configurado el cascade=ALL en la relacin de anotacin.

JPA

13


Sincroizacin entre entidades y base de datosEl estado de las entidades persistentes se sincroniza con la base de datos cuando la transaccin con la que la entidad est asociada realice el commit. Para forzar la sincronizacin de la entidad con la base da datos, se invoca el mtodo flush de la entidad. Si la entidad est relacionada con otra, y la relacin es en cascada, los datos de la entidad se sincronizan con la base da datos cuando se llama al mtodo flush. Si la entidad se borra, se llama al mtodo flush, el cual borrar la entidad de la base da datos.

Creacin de consultas Los mtodos EntityManager.createQuery y EntityManager.createNamedQuery se utilizan para realizar consultas usando lenguaje de consultas. El mtodo createQuery se utiliza para crear queries dinmicas; queries que se definen directamente en la aplicacin dentro de la lgica de negocio.

public List findWithName(String name) { return em.createQuery( "SELECT c FROM Customer c WHERE c.name LIKE :custName") .setParameter("custName", name) .setMaxResults(10) .getResultList(); } El mtodo createNamedQuery se utiliza para crear queries estticas, queries que se definen utilizando el javax.persistence.NamedQuery . La anotacin @NamedQuery especifica el nombre de la consulta que se utilizar con el mtodo createNamedQuery. El elemento de consulta @ NamedQuery es la query.

@NamedQuery( name="findAllCustomersWithName", query="SELECT c FROM Customer c WHERE c.name LIKE :custName" )

En este ejemplo se utiliza la anotacin @NamedQuery definida anteriormente. @PersistenceContext public EntityManager em;

JPA

14


... customers = em.createNamedQuery("findAllCustomersWithName") .setParameter("custName", "Smith") .getResultList(); Paso de parmetros en las queries Los parmetros de una consulta son predefinidos utilizando un signo de dos puntos (:). Los parmetros se especifican en una query mediante el mtodo javax.persistence.Query.setParameter (String nombre, Object valor). En el siguiente ejemplo, el parmetro del mtodo findWithName debe definirse como :custName especificado con el mtodo Query.setParameter.

public List findWithName(String name) { return em.createQuery( "SELECT c FROM Customer c WHERE c.name LIKE :custName") .setParameter("custName", name) .getResultList(); }El nombre de los parmetros es sensible a maysculas y minsculas, y puede ser utilizado por queries estticas y dinmicas.

Posicionamiento de parmetros en las queries Dentro de las queries, los parmetros son predefinidos con un signo de interrogacin (?) seguido del nmero que representa la posicin del parmetro en la query. El mtodo Query.setParameter (Integer posicin, Object, value) se usa para fijar el valor del parmetro.

En el siguiente ejemplo, el mtodo findWithName es reescribe para utilizando entrada de parmetros: public List findWithName(String name) { return em.createQuery( SELECT c FROM Customer c WHERE c.name LIKE ?1) .setParameter(1, name) .getResultList(); }

La entrada de parmetros comienza enumerndose en la posicin 1. Los parmetros son sensibles a maysculas y minsculas, y pueden utilizarse tanto en queries dinmicas como estticas.

JPA

15


Unidades de persistenciaLa unidad de persistencia define un conjunto de todas las entidades (clases) que son gestionadas por la instancia del EntityManager en una aplicacin. Este conjunto de clases de entidad representa los datos contenidos en un nico almacn de datos.

Las unidades de persistencia se definen en el fichero de configuracin persistence.xml. El fichero JAR cuyo directorio META-INF contiene persistence.xml se llama raz de la unidad de persistencia. El mbito de la unidad de persistencia se determina por la raz de la unidad de persistencia.

Cada unidad de persistencia debe ser identificada con un nombre nico en el mbito de la unidad de persistencia. Las unidades de persistencia pueden empaquetarse como parte de un WAR o un fichero EJB JAR, o pueden empaquetarse como un archivo JAR que pueda ser incluido en un fichero WAR o EAR.

El fichero persistence.xml El fichero persistence.xml define una o ms unidades de persistencia:

Esta unidad gestiona pedidos y clientes. No se basa en cualquiera de las funciones especficas de su proveedor y puede por lo tanto, se desplegarn a cualquier proveedor de persistencia.

jdbc/MyOrderDB MyOrderApp.jar com.widgets.Order com.widgets.Customer

Este archivo define una unidad de persistencia llamada OrderManagement, la cual utiliza jdbc / MyOrderDB. El fichero JAR y los elementos de la clase especifican las clases de persistencia: clases de entidad, clases embebidas y superclases mapeadas. El elemento jar-file especifica los ficheros JAR en los que se encuentran las clases persistentes, mientras que el elemento class indica el nombre de esas clases. El elemento jta-data-source especifica el nombre global JNDI de la fuente de datos que utiliza el contenedor.

JPA

16


Ventajas e inconvenientesAlgunas de las ventajas del JPA consisten en que objetos transitorios pueden ser almacenados en forma permanente en una base de datos relacional. Adems, JPA pretende hacer ms eficaz el proceso de desarrollo, permitiendo a los desarrolladores enfocarse a resolver los problemas de negocios a los que se enfrentan, en lugar de ocupar su tiempo con el cdigo de infraestructura.

El Java Persistence API se basa en las mejores ideas de tecnologas como la persistencia Hibernate, TopLink, y JDO. Los clientes ya no tienen que enfrentarse a las incompatibilidades de modelos no estndar. Adems, la Java Persistence API se puede usar tanto en entornos Java SE, como en Java EE.

No obstante, tiene la desventaja de que la implementacin del proveedor se encuentra oculta a la aplicacin lo cual la hace menos flexible.

Requisitos e incompatibilidadesJPA ha sido definida como parte de la especificacin EJB 3.0 de Java EE 5, que supone una simplificacin sobre versiones anteriores, por lo que ya no requiere de un contenedor EJB ni un servidor de aplicaciones Java EE. Esto implica que no podr utilizarse en versiones anteriores de Java.

Interaccin con otros subsistemas o componentesMuchos de los desarrolladores de Java que han utilizado objetos persistente que proporcionaban los marcos de cdigo abierto o DAO's en lugar de Entinty Beans e Enterprise Beans fue porque eran considerados demasiado pesados y complicados de utilizar. Adems, estos ltimos slo podan utilizarse en servidores de aplicaciones Java EE. Muchas de las caractersticas de la persistencia de otros frameworks se incorporaron a la Java Persistence API, y proyectos como Hibernate y TopLink son ahora implementaciones de Java Persistence API (JPA).

Hibernate La versin 3.2.0 Hibernate desarrolla la especificacin JPA, con lo que ahora es posible desarrollar una capa de acceso a datos compatible con los estndares de Java en hibernate, y desplegarla en cualquier servidor de aplicaciones que soporte las especificaciones JEE5.

JPA

17


TopLink TopLink es una implementacin del EJB 3.0 JPA (Java Persistence API). Es una versin limitada del propietario del producto, por ejemplo, TopLink no proporciona sincronizacin de la cach entre la agrupacin de las aplicaciones, la poltica de validaciones y la cach de consultas.

EJB JPA se defini como parte de la especificacin EJB 3.0 que es a su vez parte de la plataforma Java EE 5. No se utiliza un contenedor de EJB's, ni tampoco un servidor de aplicaciones Java EE con el fin de ejecutar aplicaciones que utilizan persistencia. EclipseLink El proyecto EclipseLink ofrece una solucin de persistencia en tiempo de ejecucin se centr en las normas principales y la funcionalidad ampliada necesaria para Java empresarial de hoy y el desarrollo de aplicaciones SOA.

Modo de empleo (Aplicacin Web)Los datos compartidos entre los componentes web y las invocaciones de persistencia de una aplicacin se mantienen normalmente en base de datos. Las aplicaciones web utilizan JPA para acceder a esas bases de datos relacionales.

Para gestionar la interaccin de las entidades con la JPA, una aplicacin utiliza la interfaz EntityManager. Esta interfaz proporciona mtodos que realizan las funciones comunes de una base de datos, como consulta y actualizacin de la base de datos.

El conjunto de entidades que pueden ser gestionadas por un Entity Manager se definen en una unidad de persistencia. sta supervisa todas las operaciones de persistencia en la aplicacin. La unidad de persistencia est configurada por un descriptor de archivo llamado persistence.xml. Este fichero tambin define el datasource, el tipo de transacciones utilizadas por la aplicacin, junto con otra informacin adicional. Estos ficheros se deben empaquetar en un .jar y aadirlos a la aplicacin.

JPA

18


EclipseLinkEl eclipse persistencia de Servicios para Proyectos (EclipseLink) objetivo del proyecto es proporcionar un framework de persistencia completa que es a la vez amplio y universal. Se ejecutar en cualquier ambiente Java y leer y escribir objetos a prcticamente cualquier tipo de fuente de datos, incluyendo bases de datos relacionales, XML, o sistemas EIS. EclipseLink se centrar en la prestacin de apoyo de vanguardia, incluyendo las extensiones de funciones avanzadas, para las normas de persistencia dominantes para cada fuente de datos de destino, Java Persistence API (JPA) para bases de datos relacionales, la arquitectura Java para vinculacin XML (JAXB) para XML, J2EE Connector Architecture (JCA) para la EIS y otros tipos de sistemas heredados, y Service Data Objects (SDO).

El proyecto EclipseLink ofrece una solucin de persistencia en tiempo de ejecucin se centr en las normas principales y la funcionalidad ampliada necesaria para Java empresarial de hoy y el desarrollo de aplicaciones SOA. EclipseLink ofrece soporte para:

EclipseLink es un subproyecto del proyecto de ejecucin

Oracle TopLink 11g, un avanzado sistema objeto-relacional de persistencia basado en el cdigo abierto EclipseLink proyecto, presenta una perfecta integracin con Oracle Coherence y flexible a objetos XML vinculante, y ofrece fuera de la caja de la compatibilidad con Oracle WebLogic Server y Java incluyendo los marcos Oracle Application Development Framework (ADF) 11g.

Oracle tambin ahora ofrecen soporte profesional comercial para EclipseLink.

EclipseLink se basa en una versin anterior de Oracle TopLink, que Oracle ha contribuido a la Eclipse Foundation en 2006.

EclipseLink soporta un extenso mapeo JPA orm.xml archivo de configuracin llamado EclipseLinkorm.xml. Este archivo de asignacin puede ser utilizado en lugar del archivo de asignacin estndar de APP, o puede ser utilizado para reemplazar un fichero de mapeo JPA. En adicional a permitir que todas las capacidades de mapeo JPA estndar tambin incluye tipos de mapas y opciones avanzadas.

JPA

19


Desarrollo AplicativoIntroduccin El desarrollo aplicativo consiste en la creacin de una aplicacin que administre usuarios web y tenga la capacidad de listarlos, esta aplicacin se ejecutara en un browser por lo cual ser web. Desarrollo Para la construccin de la aplicacin, previamente se tiene realizada una base de datos en Oracle. La base de datos consta de dos tablas, usuario y visita. La tabla usuario consta de cuatro campos, identificador de usuario, nombre de usuario, Contrasea correo Electrnico y Tipo de usuario.

JPA

20


Como se explico previamente el aplicativo consta de la creacin de una aplicacin web, y para ello se selecciona Java Web y en proyectos web aplication.

Se selecciona el nombre y la ubicacin del que tendr el proyecto web, para este caso WebVistas y la ubicacin predeterminada respectivamente.

JPA

21


Se selecciona el servidor web, para este caso Apache Tomcat en su versin 7.0.11.0 .

Una ves seleccionado las plantillas de se genera el proyecto web con un archivo jsp. Ada dems de esto, se crea dos paquetes DataAccess y Entities que servir para agrupar las clases tipo entidad y los controladores de acceso y manejo ORM.

JPA

22


Como siguiente paso se crea el archivo de unidad de persistencia que es fundamental a la hora de hacer el mapeo relacional. Para esto se Crear nuevo archivo dentro de la carpeta Persistence se selecciona Percistence Unit y siguiente.

En este paso se selecciona un nombre y la Biblioteca con la que va a persistir para nuestro caso se selecciona EclipseLink 2.0 , adems se seleccin la coneccion a la base de datos jdbc:oracle:thin:@localhost:1521:EX(ESPOCH:ESPOCH) previamente establecida que vincula nuestra aplicacin con la base de datos.

JPA

23


En la presente pantalla se puede observar el xml generado por el asistene en el archivo de persistencia creado, como se puede observar los valores de las propiedades corresponde a los especificcados en la conexin de base de datos Oracle.

Como paso siguiente se decide crear las entidades a partir de la base de datos, es decir construir las clases que correspondan con las tablas especificadas en la base de datos. Para esto se selecciona en Percistence el tem Entity from DataBase y clic en siguiente.

JPA

24


En el siguiente paso se selecciona las tablas que sern mapeadas a clases, para este caso se selecciona las dos tablas que previamente se tenan creadas en la base de datos Oracle y siguente.

Como siguiente paso se selecciona el tipo de asociacin y carga de datos adems el tipo de coleccin que para nuestro es lazy y List respectivamente y finalizar.

JPA

25


En la presente pantalla se puede observar las clases generadas a partir de la base de datos. Que par este caso es UserWeb y Visita.

JPA

26


En la presente pantalla se puede observar el cdigo generado en la clase UserWeb. El cdigo incluye entre lo mas importante las anotaciones y la generacin de mtodos set y get. Las anotaciones son aplicadas la clase como @Entity que corresponde al nombre de la tabla en la base de datos, @Column que relaciona los nombre de la porpiedes de la clase con las columnas en la base de datos.

En la presente pantalla se puede observar los mtodos get y set que han sido generados a partir de las propiedades de la clase.

JPA

27


Posterior a la generacin de entidades a partir de tablas de la base de datos se decide realizar la creacin de los controladores JPA a partir de las entidades ya creadas. Para esto se selecciona el tem JPA Controller Classes form Entity Classes y siguiente.

Como siguiente paso se selecciona las entidades a ser generadas y siguiente.

JPA

28


En la presente pantalla se puede observar los controladores JPA generados a partir de las entidades ya creadas.

En la presente pantalla se puede observar el cdigo generado por el JPA de persistencia en el cual resalta el atributo emf que es el el EntityMangerFactory atributo esencial en la administracin de la persistencia.

JPA

29


En la presente pantalla se puede observar dos de los mtodos mas importantes de persistencia como lo es el Mtodo crate(UserWeb) y edit(UserWeb) que son administrados en su totalidad con el objeto Entidad Manejadora.

En la presente pantalla se pude observar mtodos de persistencia muy importantes como los son destroy, find que complen su cometido con la entidad UserWeb mediante la clase manejadora de entidad.

JPA

30


Como paso siguiente se procede a la creacin de Servlets uno por entidad, y como se puede observar la plantilla nos genera el cdigo bsico para la administracin web.

En un siguiente paso se crea un archivo .jsp al cual se le nombra UsuaioWeb.

JPA

31


En archivo creado se agrega el cdigo respectivo para la insercin de un usuario web.

Se procede a introducir el cdigo de lgica en le servlet de UserWeb que realizara la creacin de la entidad ingresada mediante su respectivo controlador.

JPA

32


Como ultimo paso se procede a la ejecucin de la aplicacin. En primera instancia nos muestra la lista de usuarios web con la cual se pude insertar, editar o a su ves eliminar. Para nustro caso de prueba se decide crear un nuevo Usuario.

Se nos presenta el formulario con los campos correspondientes al usuario web y se procede a insertar, seguido a esto se nos presenta nuevamente la lista.

En la presente pantalla se pude observar que el nuevo registro a sido aadido con xito.

JPA

33


CONCLUSIONES JAP es la una abstraccin de la JDBC que realiza la correlacin entre el sistema orientado a objetos de Java y el sistema relacional de nuestra base de datos. JPA mediante su interface comn puede ser implementada por varios proveedores como Hibernet, Eclipse link, dando as la posibilidad de eleccin. Se ha implementado la aplicacin web, conociendo as las ventajas de JPA implementacin en EclipseLinK. con su

RECOMENDACIONES Se recomienda utilizar la Api de persistencia de Java en aplicaciones que necesiten correlacionar sistemas orientados a objetos con sistemas relacionales, para facilitar su desarrollo. Tener muy en cuenta los proveedores de la implementacin de JPA, recordando que cada uno tiene su ventajas y desventajas acorde a la aplicacin. Basarse en ejemplo aplicativo desarrollado para futuras implementaciones.

Bibliografa.http://www.oracle.com/technetwork/articles/javaee/jpa-137156.html http://terrazadearavaca.blogspot.com/2008/12/comparativa-de-implementaciones-de-jpa.html http://www.developer.com/java/ent/getting-started-with-eclipselink-and-jpa-2.htm http://weblogs.java.net/blog/ss141213/archive/2006/01/custom_tags_to.html http://www.slideshare.net/jamslug/introduccin-a-java-persistence-api http://www.java.net/external?url=http://java.sun.com/j2ee/1.4/docs/api/javax/servlet/jsp/tagext/Simpl eTag.html http://wiki.eclipse.org/EclipseLink http://wiki.eclipse.org/EclipseLink/FAQ/JPA#What_is_Object-Relational_Mapping http://wiki.eclipse.org/EclipseLink/Examples/JPA/EclipseLink-ORM.XML

JPA

34


ANEXOSAnexo1.Entidad UserWeb: @Entity @Table(name = "USER_WEB", catalog = "", schema = "ESPOCH") @XmlRootElement @NamedQueries({ @NamedQuery(name = "UserWeb.findAll", query = "SELECT u FROM UserWeb u"), @NamedQuery(name = "UserWeb.findByIdUser", query = "SELECT u FROM UserWeb u WHERE u.idUser = :idUser"), @NamedQuery(name = "UserWeb.findByUserName", query = "SELECT u FROM UserWeb u WHERE u.userName = :userName"), @NamedQuery(name = "UserWeb.findByPassword", query = "SELECT u FROM UserWeb u WHERE u.password = :password"), @NamedQuery(name = "UserWeb.findByCorreoEctronico", query = "SELECT u FROM UserWeb u WHERE u.correoEctronico = :correoEctronico"), @NamedQuery(name = "UserWeb.findByTipo", query = "SELECT u FROM UserWeb u WHERE u.tipo = :tipo")}) public class UserWeb implements Serializable { private static final long serialVersionUID = 1L; @Id @Basic(optional = false) @Column(name = "ID_USER", nullable = false) private Short idUser; @Basic(optional = false) @Column(name = "USER_NAME", nullable = false, length = 50) private String userName; @Column(name = "PASSWORD", length = 50) private String password; @Column(name = "CORREO_ECTRONICO", length = 100) private String correoEctronico; @Column(name = "TIPO", length = 30) private String tipo; public UserWeb() { } public UserWeb(Short idUser) { this.idUser = idUser; } public UserWeb(Short idUser, String userName) { this.idUser = idUser; this.userName = userName;

JPA

35


} public Short getIdUser() { return idUser; } public void setIdUser(Short idUser) { this.idUser = idUser; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getCorreoEctronico() { return correoEctronico; } public void setCorreoEctronico(String correoEctronico) { this.correoEctronico = correoEctronico; } public String getTipo() { return tipo; } public void setTipo(String tipo) { this.tipo = tipo; } @Override public int hashCode() { int hash = 0; hash += (idUser != null ? idUser.hashCode() : 0); return hash; }

JPA

36


Anexo 2.Controlador JPA UserWeb

public class UserWebJpaController implements Serializable { public UserWebJpaController(EntityManagerFactory emf) { this.emf = emf; } private EntityManagerFactory emf = null; public EntityManager getEntityManager() { return emf.createEntityManager(); } public void create(UserWeb userWeb) throws PreexistingEntityException, Exception { EntityManager em = null; try { em = getEntityManager(); em.getTransaction().begin(); em.persist(userWeb); em.getTransaction().commit(); } catch (Exception ex) { if (findUserWeb(userWeb.getIdUser()) != null) { throw new PreexistingEntityException("UserWeb " + userWeb + " already exists.", ex); } throw ex; } finally { if (em != null) { em.close(); } } } public void edit(UserWeb userWeb) throws NonexistentEntityException, Exception { EntityManager em = null; try { em = getEntityManager(); em.getTransaction().begin(); userWeb = em.merge(userWeb); em.getTransaction().commit(); } catch (Exception ex) { String msg = ex.getLocalizedMessage(); if (msg == null || msg.length() == 0) { Short id = userWeb.getIdUser(); if (findUserWeb(id) == null) {

JPA

37


throw new NonexistentEntityException("The userWeb with id " + id + " no longer exists."); } } throw ex; } finally { if (em != null) { em.close(); } } } public void destroy(Short id) throws NonexistentEntityException { EntityManager em = null; try { em = getEntityManager(); em.getTransaction().begin(); UserWeb userWeb; try { userWeb = em.getReference(UserWeb.class, id); userWeb.getIdUser(); } catch (EntityNotFoundException enfe) { throw new NonexistentEntityException("The userWeb with id " + id + " no longer exists.", enfe); } em.remove(userWeb); em.getTransaction().commit(); } finally { if (em != null) { em.close(); } } } public List findUserWebEntities() { return findUserWebEntities(true, -1, -1); } public List findUserWebEntities(int maxResults, int firstResult) { return findUserWebEntities(false, maxResults, firstResult); } private List findUserWebEntities(boolean all, int maxResults, int firstResult) { EntityManager em = getEntityManager(); try { CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); cq.select(cq.from(UserWeb.class)); Query q = em.createQuery(cq);

JPA

38


if (!all) { q.setMaxResults(maxResults); q.setFirstResult(firstResult); } return q.getResultList(); } finally { em.close(); } } public UserWeb findUserWeb(Short id) { EntityManager em = getEntityManager(); try { return em.find(UserWeb.class, id); } finally { em.close(); } } public int getUserWebCount() { EntityManager em = getEntityManager(); try { CriteriaQuery cq = em.getCriteriaBuilder().createQuery(); Root rt = cq.from(UserWeb.class); cq.select(em.getCriteriaBuilder().count(rt)); Query q = em.createQuery(cq); return ((Long) q.getSingleResult()).intValue(); } finally { em.close(); } } }

JPA

39


Anexo3.Servlet UserWeb, meotdo processRequest. protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); try { //CREACAION DE LA ENTIDAD USERWEB. UserWeb userWeb=new UserWeb(); userWeb.setIdUser( Short.valueOf(request.getParameter("id").toString())); userWeb.setUserName(request.getParameter("nombreUsuario")); userWeb.setPassword(request.getParameter("pasword")); userWeb.setCorreoEctronico(request.getParameter("correo")); userWeb.setTipo("WebUser"); //CREACION DEL CONTRALADOR PARA LA INSERCION EntityManagerFactory entityManagerFatory=Persistence.createEntityManagerFactory("WebVisitasPU",System.getProperti es()); UserWebJpaController userWebJpaController=new UserWebJpaController(entityManagerFatory); out.println(""); out.println(""); out.println("Servlet UsuarioServlet"); out.println(""); out.println(""); try { userWebJpaController.create(userWeb); out.println("Usuario Web insertado con exito!"); } catch (Exception e) { out.println("Usuario Web no pudo se insertado!"); } }

JPA

40

Documents

Java Persistence API