You are on page 1of 74

API Java de persistencia

Aplicaciones web y Bases de datos
• Normalmente las aplicaciones web guardan datos de distintos tipos, tanto datos producidos durante la interacción de los usuarios con la aplicación como datos que son mostrados a los usuarios. • Java incluye mecanismos para permitir que los programas accedan a bases de datos. • Java EE también incluye mecanismos específicos para hacer más eficiente el acceso a bases de datos.

Servidor de bases de datos
• MySQL Server 5.5 Usuario: root, Clave: mysql • Arranque: automático (servicio MySQL) • Parada:
C:\Archivos de programa\MySQL\MySQL Server 5.5\bin\

mysqladmin -uroot -pmysql shutdown • Administración:
C:\Archivos de programa\MySQL\MySQL Server 5.5\bin\

mysqladmin -uroot -pmysql

• Bases de datos: – CREATE DATABASE CLS.Servidor de bases de datos. – USE CLS. • Tablas: – SHOW TABLES.5\bin\ mysql -uroot -pmysql – Finalización: quit. II • Acceso desde cliente: C:\Archivos de programa\MySQL\MySQL Server 5. . – SHOW DATABASES.

…) . …) – COLUMNS(TABLE_SCHEMA. III • Catálogo: information_schema (base de datos) – TABLES(TABLE_SCHEMA.Servidor de bases de datos. COLUMN_NAME. TABLE_NAME. TABLE_NAME.

• JDBC se utiliza mediante un driver que al cargarse permite que un programa Java se conecte a un servidor de bases de datos como un usuario determinado • JDBC proporciona clases para representar las conexiones. consultas SQL y resultados de las mismas. .JDBC • JDBC es una biblioteca de Java que permite la conexión a bases de datos relacionales.

– Cierra la conexión. II • Un programa Java que utiliza JDBC hace lo siguiente: – Carga el driver JDBC (la clase que gestiona el acceso a bases de datos). obteniendo un conjunto de resultados (o void). – Crea una consulta en base a código SQL. . – Itera si es necesario sobre los resultados.JDBC. – Ejecuta la consulta. – Crea una conexión a la base de datos.

Utilización de JDBC mediante la API de persistencia • La API de persistencia. • Cuando una aplicación Java utiliza la API de persistencia (JPA). permite la especificación de manera sencilla de aplicaciones con un número elevado de usuarios simultáneos que acceden de manera eficiente a bases de datos. se crea un pool de conexiones JDBC que se reutilizan por los distintos hilos de la aplicación. . que es parte de JEE pero se puede utilizar en otras aplicaciones Java.

JPA: Consultas • El Lenguaje de Consultas de Persistencia de Java (JPQL) permite especificar consultas a bases de datos relacionales en forma parecida a SQL desde un programa Java. .

II • Los objetos que implementan la interfaz TypedQuery<?> de JPA representan consultas del tipo anterior. . • Los objetos de la clase anterior que representan consultas que devuelven valores (tipo SELECT) al ejecutar la consultas devuelven listas de objetos.JPA: Consultas.

‘Pérez’. ‘inglesa’) • SELECT * FROM PERSONA • UPDATE PERSONA SET NACIONALIDAD=‘española’ • DELETE FROM PERSONA .Recordatorio: Consultas en SQL • INSERT INTO PERSONA VALUES (‘Pepe’.

Consultas en JPQL • SELECT p FROM Persona p – Persona es una entidad (clase) – p representa una variable Java de la clase – El resultado de la ejecución de la consulta es una lista de objetos de la clase • Se pueden añadir otras cláusulas: – SELECT p FROM Persona p WHERE p.nombre = ‘Pepe’ .

II • Cuestiones pendientes de estudiar: – Programación de consultas – Acceso a resultados devueltos por las consultas – Definición de entidades – Sincronización .Consultas en JPQL.

• Tras esto veremos cómo se definen las clases de objetos que representan registros de una base de datos.JPA: EntityManager • Para crear y ejecutar consultas mediante JPA es necesario crear antes un objeto que implementa la interfaz EntityManager. . • A continuación veremos cómo se utilizan y cómo se crean los EntityManagers. que se ocupa de la gestión de los datos y de objetos que los representan.

Persona. .JPA: Programación de consultas • Para crear una consulta se utiliza el método createQuery de la clase EntityManager. cuyo argumento es la cadena de caracteres que define la consulta JPQL: TypedQuery<Persona> query = em.class).createQuery( “SELECT p FROM Persona p”.

util. que devuelve una lista de objetos: java.List<Persona> pers = query.getResultList(). .JPA: Acceso a resultados • Para ejecutar una consulta de tipo SELECT se utiliza el método getResultList.

puede inyectar una EntityManagerFactory que sea un atributo suyo o directamente un EntityManager. ServletContextListener. …).Gestión de persistencia en Java EE • En Java EE. beans gestionados de JSF. . • La inyección de EntityManagerFactory se puede hacer en cualquier contexto (servlet. cuando un contenedor activa un objeto. bean gestionado de JSF o EJB). página JSP. • La inyección directa de EntityManager solamente se puede hacer en un contexto monohilo (EJB sin estado.

createEntityManager().M. • Ejemplo de inyección de EntityManager: @PersistenceContext EntityManager em. .Factory: @PersistenceUnit private EntityManagerFactory emf.Gestión de persistencia en Java EE: Ejemplos • Ejemplo de inyección de E. EntityManager em = emf.

asociándoles un nombre accesible a través del protocolo Java JNDI.Recursos en Java EE • Los servidores de aplicaciones web permiten el acceso a recursos externos como sistemas de gestión de bases de datos o de colas de mensajes. . • El servidor registra los recursos. El uso de JNDI es transparente. • La gestión de recursos se puede hacer desde NetBeans o desde la aplicación de administración del servidor de aplicaciones.

Consideraciones para la utilización de la API de persistencia en el lab • Para acceder a una base de datos mediante JPA hay que utilizar dos recursos: un recurso JDBC y un pool de conexiones JDBC. .

.Consideraciones para la utilización de la API de persistencia en el lab. II • Un pool de conexiones JDBC es un conjunto de conexiones JDBC a una base de datos disponibles para ser reutilizadas concurrentemente por distintos hilos de la aplicación. propiedades. etc. contraseña. usuario. • Para especificar un pool de conexiones se indica la base de datos.

Consideraciones para la utilización de la API de persistencia en el lab. • Para especificar un recurso JDBC hay que indicar el nombre con que está registrado el pool correspondientes y las propiedades. III • Un recurso JDBC es un proxy a un pool de conexiones. .

Consideraciones para la utilización de la API de persistencia en el lab. III • Para crear un recurso JDBC y un connection pool en el servidor de aplicaciones hay dos posibilidades: – Localhost:4848 -> Resources -> JDBC – NetBeans -> Proyecto -> New persistence unit -> new Data Source -> new Data Base connection .

xml permite especificar las bases de datos accesibles a una aplicación y las entidades que utiliza. • El fichero de configuración debe incluirse en el directorio /META-INF del módulo correspondiente. . • La cláusula persistence-unit permite especificar un data-source.Acceso a recursos JDBC desde aplicaciones web • El fichero de configuración persistence.

org/.widgets.com/xml/ns/persistence" xmlns:xsi="http://www.0" xmlns="http://java.."> <persistence-unit name="book" transaction-type="JTA"> <jta-data-source>jdbc/__default</jta-data-source> <class>com.w3.Cust</class> </persistence-unit> </persistence> ..0" encoding="UTF-8" ?> <persistence version="1.Order</class> <class>com.“ xsi:schemaLocation="http://..Ejemplo de fichero persistence..sun.widgets.xml <?xml version="1.

… } . • @Entity public class Person { @Id int id. • Sus objetos se asocian a registros. • La clave primaria se indica mediante la anotación @Id (obligatorio).Clases entidad • Son clases asociadas a tablas (una o varias) en una base de datos. • Se declaran mediante la anotación @Entity.

II • Si la tabla primaria tiene un nombre diferente de la clase. éste se especifica mediante la anotación @Table(name). • NetBeans permite la opción de crear la tabla (si no existe) al compilar el código de la clase .Clases entidad.

de otra entidad. incluidos en la tabla de la primera – Generados automáticamente (@GeneratedValue) – Relaciones (próxima transparencia) . III • Tipos de atributos: – Persistentes (ver próxima transparencia) – No persistentes (@Transient) – Embebidos (@Embedded).Clases entidad.

arrays de bytes y chars. Set. clases embedibles • Colecciones: Collection. enumeraciones. temporales (Date. …). List. String. wrappers. Map .Clases entidad: Atributos persistentes • Son todos salvo los no persistentes • Tienen que ser protegidos o privados • Tipos: Primitivos.

widgets.Definición de entidades en persistence.Cust</class> </persistence-unit> </persistence> .Order</class> <class>com.xml (alternativa) <persistence> <persistence-unit name=“…“> <jta-data-source>…</jta-data-source> … <class>com.widgets.

Se definen en el servidor. • Los recursos JDBC y los pools de conexiones se utilizan por el servidor web para implementar la conexión a la base de datos. .JPA básico: Resumen • Las clases de entidades representan registros de tablas. Se definen mediante la anotación @Entity.

JPA básico: Resumen. Se inyectan en un objeto gestionado por un contenedor o se crean a partir de una fábrica inyectada. Están asociados a un recurso JDBC. • Los EntityManagers gestionan el acceso a las bases de datos. II • Los recursos utilizados por una aplicación se especifican en el fichero persistence.xml. .

Se crean a partir de ellas y en su caso devuelven listas de entidades.JPA básico: Resumen. . III • Los TypedQuerys pueden ejecutar consultas JPA.

Ejercicio
• [DBPERS0] Desarrollar una aplicación web que permita ver la lista de personas incluidas en una base de datos de personas sencilla, como la mencionada en los ejemplos anteriores.

JPA: Programación de consultas, II
• Se pueden definir TypedQuerys con tipo atómico (Integer, String, etc.) para consultas que seleccionan una sola columna: TypedQuery<String> query = em.createQuery( “SELECT p.nombre FROM Persona p”, String.class);

JPA: Programación de consultas, III
• Las consultas de actualización o borrado se definen de forma similar: UPDATE Persona p SET p.nacionalidad=‘española’ DELETE FROM Persona p WHERE p.estado=‘fallecido’

JPA: Programación de consultas. .executeUpdate(). IV • Para ejecutar una consulta de tipo UPDATE o DELETE se utiliza el método executeUpdate(): query.

getResultList().createQuery( “SELECT p FROM Persona p WHERE p. .edad=?1). V • Se pueden definir consultas parametrizadas utilizando patrones de parámetros: TypedQuery<Persona> query= em. 3).JPA: Programación de consultas. pers = query.setParameter(1.

Ejercicio • [DBPERS1] Desarrollar una aplicación web que permita gestionar a través de Internet una base de datos de personas sencilla. como la mencionada en los ejemplos anteriores. . permitiendo dar de alta y de baja a personas y modificar sus datos.

SWJSF. AJAXPERS) para guardar sus datos sustituyendo los ficheros por una base de datos. FAV. SWCC.Ejercicios voluntarios • [DBFILE…] Completar los ejercicios de los temas anteriores que utilizan ficheros (PyCE1. PyCE2. .

.createNativeQuery implementa la interfaz Query. VI • Se pueden utilizar consultas SQL (consultas nativas) mediante el método createNativeQuery de la clase EntityManager. • El objeto creado por EntityManager.JPA: Programación de consultas. superinterfaz de TypedQuery<?>.

getResultList a partir de una consulta SQL son arrays de objetos. out.get(0). VII • Los registros obtenidos mediante el método Query.getResultList().JPA: Programación de consultas.println(persona[0] + " " + persona[1]).createNativeQuery( "SELECT * FROM PERSONA”) . . • Ejemplo: Object[] persona = (Object[]) em.

createQuery( “SELECT p FROM Persona p”) . .setMaxResults(9).JPA: Programación de consultas. VIII • Se puede determinar el número del registro a partir del cual se extraen los resultados y el número máximo de resultados a extraer en una consulta: em.setFirstResult(5).

Búsqueda de objetos individuales • Se hace mediante el método find(Class<? >. Object) de la clase EntityManager.class. 2130). • Utiliza su segundo argumento como clave primaria.find(Person. • Ejemplo: Person p = e. .

. En este caso están en el estado Managed (gestionadas).Entidades persistentes: Ciclo de vida • Las entidades persistentes pueden estar desacopladas de la base de datos o acopladas a ella a través de un EntityManager. • Por ejemplo. una entidad persistente creada a través de una consulta a la base de datos normalmente está gestionada por el EntityManager que hace la consulta.

II SELECT Managed (em) Detached .Entidades persistentes: Ciclo de vida.

• Si una entidad está en el estado New. . en la base de datos puede haber un registro cuya clave primaria sea la misma de la entidad.Entidades persistentes: Ciclo de vida. III • Una entidad persistente creada mediante new está desacoplada de la base de datos y se encuentra inicialmente en el estado New.

Entidades persistentes: Ciclo de vida. IV New new SELECT Managed (em) Detached .

que las gestiona a partir de ese momento tras insertar los registros necesarios en la base de datos. . se lanza una excepción.Entidades persistentes: Ciclo de vida. • Si en la base de datos ya hay un registro con la misma clave primaria. V • Las entidades persistentes que están en el estado New pueden acoplarse a la base de datos mediante el método persist(Object) de la clase EntityManager.

VI [Añade registro] em.Entidades persistentes: Ciclo de vida.persist(o) SELECT Managed (em) New new Detached .

Entidades persistentes: Ciclo de vida. Tras su ejecución se actualizará la base de datos con su contenido. pasando a estar en el estado Detached. . VII • Las entidades persistentes gestionadas se pueden desacoplar de la base de datos mediante el método close(Object) del EntityManager que las gestiona. • El método merge(Object) de la clase EntityManager permite volver a gestionar una entidad persistente que está en el estado Detached.

VIII [Añade registro] em.merge(o) [objBD] Detached em.Entidades persistentes: Ciclo de vida.persist(o) SELECT em.close(o) Managed (em) New new .

IX • Tanto en el estado New como en Detached los cambios que origina el cambio de estado de una entidad persistente no se trasladan necesariamente a la base de datos de inmediato (se hace cuando termina la transacción que se está ejecutando). • Lo mismo ocurre con los cambios en los valores de los atributos persistentes de las entidades gestionadas.Entidades persistentes: Ciclo de vida. .

• Esto permite que cualquier otra consulta que se haga refleje los cambios realizados en las entidades gestionadas por el EM. X • Se puede forzar la realización inmediata en la base de datos de los cambios pendientes de realizar correspondientes a todas las entidades gestionadas por un EntityManager mediante el método flush() del mismo. .Entidades persistentes: Ciclo de vida.

merge(o) [objBD] Detached em.Entidades persistentes: Ciclo de vida. XI [Añade registro] em.close(o) [objsBD] em.persist(o) SELECT em.flush() Managed (em) New new .

• El modo de flush puede ser AUTO o COMMIT. . XII • Las consultas tienen asociado un modo de flush. que permite hacer que siempre que se ejecuten haya garantías de que la base de datos está actualizada con respecto a cambios en las entidades gestionadas.Entidades persistentes: Ciclo de vida. • Los EntityManagers también tienen un modo de flush.

cuando se termina una transacción). XIII • La actualización de los registros correspondientes a las entidades gestionadas por un EntityManager se puede hacer mediante una llamada explícita al método flush() en el programa o lo puede hacer el EntityManager al ejecutar acciones previstas en su funcionamiento (por ejemplo. .Entidades persistentes: Ciclo de vida.

Entidades persistentes: Ciclo de vida.refresh(Object). mediante el método remove de la clase EntityManager. . • Se puede borrar de una base de datos la información correspondiente a una entidad acoplada a ella. Esto se hace mediante el método EntityManager. XIV • También se puede actualizar una entidad acoplada a una base de datos con los valores que ésta contiene. La entidad pasa entonces al estado Removed.

close(o) [BD obj] em.persist(o) SELECT em.merge(o) [objBD] Detached em.refresh(o) [objsBD] em. XV [Añade registro] em.Entidades persistentes: Ciclo de vida.remove(o) [Elimina registro] Removed New new .flush() Managed (em) em.

lock(Object.close().Gestión de entidades: Otros aspectos • em. // Desconecta entidades. LockModeType) // READ. // Cierra conexiones . WRITE • em.clear().setFlushMode(FlushModeType) // AUTO (tras ejecución de update) // COMMIT (tras finalizar transacción) • em. sin sincronizarlas • em.

trabajo int ref Empresa. nombre varchar. @ManyToOne Empresa trabajo) Propietario – Empresa(@Id int id. nombre varchar) • Entidades: – Persona(@Id int id. String nombre.Relaciones muchos a uno Ejemplo • Tablas: – Persona(id int primary key.id) – Empresa(id int primary key. String nombre) // .

id. trabajo int ref Empresa. nombre varchar. idP int ref Persona.Relaciones muchos a muchos Ejemplo • Tablas: – Persona(id int primary key.id primary key (idE. idP)) .id) – Empresa(id int primary key. nombre varchar) – Clientes(idE int ref Empresa.

String nombre.Relaciones muchos a muchos Ejemplo. II • Entidades: – Persona(@Id int id. String nombre. La elección se debe basar en criterios de eficiencia. @ManyToMany Set<Persona> clientes) // Prop • Se podría haber hecho propietaria a la entidad Persona. . @ManyToOne Empresa trabajo) – Empresa(@Id int id.

@OneToMany(mappedBy=“trabajo”) Set<Persona> trabajadores) . @ManyToMany Set<Persona> clientes. String nombre.Relación uno a muchos • Relación inversa de otra muchos a uno • Se implementa por motivos de eficiencia (si se va a utilizar con frecuencia) • Ejemplo: Empresa(@Id int id.

@ManyToMany(mappedBy=“clientes”) Set<Empresa> contratistas) . @ManyToOne Empresa trabajo. String nombre.Relaciones muchos a muchos: Relación inversa • Se implementa por motivos de eficiencia (si se va a utilizar con frecuencia) • Ejemplo: Persona(@Id int id.

salvo quizás por una restricción de integridad • Las relaciones uno a uno se especifican mediante la anotación @OneToOne • La relación inversa de una relación uno a uno es también una relación uno a uno .Relaciones uno a uno • Ejemplo: Empresa(…. @OneToOne Persona director) • En la base de datos una relación uno a uno no se distingue de una muchos a uno.

la relación tiene que estar definida (en la clase de entidades persistentes) en la dirección en la que es atravesada. .name=‘Renfe’ (lista de Person) • Para poder hacer una consulta que atraviesa una relación.Consultas y relaciones • Ejemplos: Empleados de Renfe select p from Empresa e JOIN e.clientes p where e.

Entidades: Jerarquía de herencia • La API de persistencia incluye varios mecanismos para aprovechar la herencia que proporciona Java .

Relaciones y gestión de entidades • La API de persistencia permite especificar que las acciones de inserción y/o borrado de objetos deben propagarse a través de determinadas relaciones. • Por ejemplo. cuyos valores pueden ser PERSIST. REMOVE o ALL. si se quieren eliminar los objetos relacionados con uno cuando se elimine. se utiliza el atributo cascade=REMOVE de la relación . • Para ello se utiliza el atributo cascade de la anotación de la relación.

Relaciones y gestión de entidades. II • Ejemplo. @ManyToMany Set<Persona> clientes. @OneToMany(mappedBy=“trabajo” cascade=REMOVE) Set<Persona> trabajadores) . continuación: Empresa(@Id int id. String nombre.

• Por ejemplo.Transacciones en SQL • Una transacción es una secuencia de instrucciones SQL que se ejecutan provisionalmente. . pudiendo anularse en cualquier momento o consolidarse al final. un movimiento en una cuenta corriente puede realizarse mediante una transacción que comprueba que el usuario ha actuado correctamente en el cajero automático.

. • La instrucción COMMIT termina una transacción dando por buenos los cambios. II • En una sesión de ejecución de instrucciones en un Sistema de Gestión de Bases de Datos cualquier instrucción normal comienza una transacción si no hay una comenzada.Transacciones en SQL. • La instrucción ROLLBACK termina una transacción deshaciendo los cambios.

de manera que si se produce un error tanto en el servidor de bases de datos como en la máquina virtual se realizan acciones de recuperación a un estado seguro. .Transacciones en Java EE • Java EE permite definir transacciones que abarcan la ejecución de métodos. • Las transacciones son un tema optativo en CLS y se estudiarán junto con las Enterprise Java Beans (EJB).

Ciclo de vida completo de entidades .