USMP JPA Introduccion GuiaLabv1 0

Framework JPA – © Ing. Luis H. García P. – Ing. William Marquina Página 1

JPA: Introducción1

Guía de Laboratorio

1 Esta guía se complementa con la orientación en clase por parte del docente y las actividades propias del alumno.


Referencias

STRUTS

Página Oficial

http://struts.apache.org/

Descargas

http://struts.apache.org/download.cgi

Descargar archivo que contiene las librerias necesarias para utilizar struts 2.1.8.1.

JPA

Página Oficial del Java EE

http://www.oracle.com/technetwork/java/javaee/overview/index.html

Tutorial JPA

http://java.sun.com/javaee/5/docs/tutorial/doc/bnbpz.html

Implementación de JPA

http://www.eclipse.org/eclipselink/jpa.php

Ir a la sección Downloads, Previous Releases y descargar archivo del link “EclipseLink 2.0.1 Installer Zip

(27 MB) ” que contiene las librerías necesarias para utilizar JPA

IDE de desarrollo

Eclipse Helios:

http://www.eclipse.org/downloads/packages/release/helios/r

Contenedor Web

Apache Tomcat 7.0:

http://tomcat.apache.org/

Base de Datos

MySql Community Server

http://www.mysql.com/downloads/mysql/

Lenguaje de Programación

Java JSE 6

http://java.sun.com/javase/downloads/widget/jdk6.jsp

http://struts.apache.org/

http://struts.apache.org/download.cgi

http://www.oracle.com/technetwork/java/javaee/overview/index.html

http://java.sun.com/javaee/5/docs/tutorial/doc/bnbpz.html

http://www.eclipse.org/eclipselink/jpa.php

http://www.eclipse.org/downloads/packages/release/helios/r

http://tomcat.apache.org/

http://www.mysql.com/downloads/mysql/

http://java.sun.com/javase/downloads/widget/jdk6.jsp


JPA

Java Persistence API, siglas de JPA, es un API de persistencia para la plataforma JAVA que

aplica el Mapeo Relacional Objeto (ORM: Object-Relational Mapping) permitiendo

interactuar con bases de datos relacionales sin perder las ventajas de la orientación a

objetos.

Objetivo: Implementar una aplicación web básica utilizando las principales características del

framework JPA.

Configuración → Archivo persistence.xml y anotaciones

Componentes → Clases de entidad y uso de EntityManager.

Implementación → EclipseLink

Aplicación web básica con JPA 1.0

Se probará una aplicación web con los componentes mínimos para el correcto funcionamiento

del framework JPA versión 1.0


PASO 1: Importar el proyecto web clase_jpa_inicio.war

Vamos a aprender a utilizar JPA haciendo uso de un proyecto base de la plantilla del curso

propuesta.

Este proyecto ya tiene implementado el mantenimiento de la tabla Usuario en las capas de

presentación y negocio. La capa de datos(persistencia) la vamos a implementar con JPA.

Los componentes de JPA estarán ubicados dentro del paquete edu.plantilla,persistencia.

Las librerías jar necesarias son: eclipselink.jar y javax.persistence_1.0.0.jar.

NOTAS:

1) Obsérvese que el paquete persistencia tiene dos subpaquetes:

◦ entidad: Contiene clases de entidad que típicamente representan una tabla

relacional de una base de datos.

Una instancia de clase representará una fila de una tabla relacional.

◦ jpa: Contiene clases donde se implementará las funcionalidades de acceso a

base de datos y operaciones CRUD con las tablas relacionales.

2) persistence.xml es el archivo de configuración de los componentes que utilizará JPA.

1

2

PASO 2: Creación de una clase de entidad

Primero debemos configurar el aplicativo para que utilize JPA.

En el archivo persistence.xml añadir:

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/persistence

http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">

<persistence-unit name="AppJPA" >

<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>



<properties>

<property name="eclipselink.jdbc.batch-writing" value="JDBC"/>

<property name="eclipselink.jdbc.driver" value="com.mysql.jdbc.Driver"/>

<property name="eclipselink.jdbc.url" value="jdbc:mysql://localhost:3306/demodbjpa"/>

<property name="eclipselink.jdbc.user" value="root"/>

<property name="eclipselink.jdbc.password" value="root"/>

</properties>

</persistence-unit>

</persistence>

Donde:

persistence-unit: Indica la unidad de persistencia a utilizar para una base de datos.

provider: Indica el proveedor de la implementación del API JPA, en este caso eclipseLink.

class: Indica clase de entidad que será utilizada en la unidad de Persistencia.

properties: Se indican las propiedades de conexión a base de datos.

PASO 3: Creación de una clase de entidad

Una clase de entidad representa una tabla relacional, por lo cual debemos definirle todas las

características que la tabla presente: nombre de tabla, columnas, tipos de datos de cada

columna, llave primaria y relaciones con otras tablas principalmente.

Ejemplo:

Se tiene en el schema demodbjpa la Tabla Usuario, la cual NO tiene relación con otra tabla

según el script:

create database demodbjpa;

use demodbjpa;

CREATE TABLE t_usuario(

usuario varchar(10) NOT NULL,

password varchar(10) NULL,

nombre varchar(50) NULL

);

ALTER TABLE t_usuario ADD PRIMARY KEY (usuario);


Crear en el paquete edu.plantilla.persistencia.entidad una clase con nombre Usuario

Declarar los atributos respecto a las columnas de la tabla usuario:

private String usuario;

private String contrasena;

private String nombre;

Generar los métodos getter/setter para cada atributo.


Ahora vamos a utilizar @Anotaciones para completar el mapeo relacional objeto:

package edu.plantilla.persistencia.entidad;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name="t_usuario")

public class Usuario {

@Id

private String usuario;

@Column(name="password")

private String contrasena;

@Column

private String nombre;

public String getUsuario() {

return usuario;

}

public void setUsuario(String usuario) {

this.usuario = usuario;

}

public String getContrasena() {

return contrasena;

}

public void setContrasena(String contrasena) {

this.contrasena = contrasena;

}

public String getNombre() {

return nombre;

}

public void setNombre(String nombre) {

this.nombre = nombre;

}

}

NOTAS:

1) Toda clase de entidad debe utilizar la anotación @Entity, la cual indica que la clase

representa una tabla relacional.

En caso el nombre de la tabla y el nombre de la clase sean idénticos basta con utilizar esa

anotación.

Solo en en caso que el nombre de la clase sea distinto al nombre de la tabla, se debe

utilizar la anotación @Table con el atributo name (name="") , para indicar el nombre de

la tabla que la clase representa.

1

2


2) Se observa los 3 atributos que representa a las columnas de las tablas con el tipo de dato

que le corresponda a cada uno.

@Column: Sirve para indicar que el atributo es una columna.

Si la columna tiene el mismo nombre que el atributo, el mapeo es

automático.

Si la columna no tiene el mismo nombre, hay que utilizar la anotación

@Column e indicar el nombre de la columna en el atributo name

@Id: Sirve para indicar el atributo que representa la llave primaria de la tabla.

Ya hemos terminado el mapeo relacional objeto de la tabla Usuario.

PASO 4: Registro de una clase de entidad

Ahora vamos a registrar la clase en la unidad de persistencia.

Abrir archivo persistence.xml y añadir lo resaltado en amarillo:

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/persistence

http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">

<persistence-unit name="AppJPA" >

<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>

<class>edu.plantilla.persistencia.entidad.Usuario</class>

<properties>

<property name="eclipselink.jdbc.batch-writing" value="JDBC"/>

<property name="eclipselink.jdbc.driver" value="com.mysql.jdbc.Driver"/>

<property name="eclipselink.jdbc.url" value="jdbc:mysql://localhost:3306/demodbjpa"/>

<property name="eclipselink.jdbc.user" value="root"/>

<property name="eclipselink.jdbc.password" value="root"/>

</properties>

</persistence-unit>

</persistence>


PASO 4: Uso de clase de entidad

Vamos a implementar las operaciones CRUD con la tabla Usuario haciendo uso de JPA y la

clase entidad Usuario.

Crear en el paquete edu.plantilla.persistencia.jpa una clase con nombre UsuarioJPA


Añadir el código base para este tipo de clase:

package edu.plantilla.persistencia.jpa;

import javax.persistence.EntityManager;

import javax.persistence.EntityManagerFactory;

import javax.persistence.Persistence;

import javax.persistence.Query;

import org.apache.commons.beanutils.BeanUtils;

import edu.plantilla.bean.UsuarioDTO;

import edu.plantilla.persistencia.entidad.Usuario;

public class UsuarioJPA {

private static UsuarioJPA usuarioJPA;

public static UsuarioJPA getInstance(){

if(usuarioJPA==null)

usuarioJPA=new UsuarioJPA();

return usuarioJPA;

}

public Usuario copiarPropiedadesAEntidad(UsuarioDTO usuarioDTO)

throws Exception{

Usuario entidad=new Usuario();

BeanUtils.copyProperties( entidad,usuarioDTO);

return entidad;

}

/*

* Referenciamos a nuestra unidad de persistencia

* AppJPA para gestionar nuestras entidades

*/

EntityManagerFactory fabrica=

Persistence.createEntityManagerFactory("AppJPA");

}

NOTAS:

1) Permite utilizar una única instancia de la clase para todo el aplicativo.

2) Método utilitario para copiar los valores de las propiedades del DTO recibido a las

propiedades del mismo nombre de la ENTIDAD a utilizar.

IMPORTANTE:

-Los objetos que se transportan entre capas son los DTO.

-Los objetos que se utilizan en la capa de datos(persistencia) son las clases ENTIDAD,

las cuales tiene configurado el mapeo relacional-objeto.

-Por ello cuando un DTO es enviado a la capa de datos, es necesario copiar los valores

del DTO a la ENTIDAD para poder utilizar JPA y acceder a bases de datos.

Por estándar en el curso, los atributos del DTO deben ser iguales a los de la Entidad

3) Obtiene fabrica de recursos configurada en una unidad de persistencia.

En este caso “AppJPA”

1

3

2


PASO 5: Implementamos las operaciones del CRUD

public void insertar(UsuarioDTO usuarioDTO) throws Exception {

Usuario entidad=copiarPropiedadesAEntidad(usuarioDTO);

//1.Creamos instancia del EntityManager

EntityManager em=fabrica.createEntityManager();

try{

//2.inicia la transacción

em.getTransaction().begin();

//3.ejecuta las operaciones

em.persist(entidad);

em.flush();

//4.ejecuta commit a la transacción

em.getTransaction().commit();

}finally {

//5.cierra el EntityManager

em.close();

}

}

public void actualizar(UsuarioDTO usuarioDTO) throws Exception {



try{


em.merge(entidad);

em.flush();


}finally {

em.close();

}

}

public void eliminar(UsuarioDTO usuarioDTO) throws Exception {


try{


Usuario entidad=(Usuario)em.find(Usuario.class,usuarioDTO.getUsuario());

em.remove(entidad);

em.flush();


}finally {

em.close();

}

}


Donde:

Método insertar:

-em.persist(entidad): Genera un insert a la tabla relacional mapeada con los datos del objeto.

Método actualizar:

-em.merge(entidad): Genera un update a la tabla relacional mapeada con los datos del objeto.

Método eliminar:

-Es necesario primero realizar una búsqueda por llave primaria para asociar el objeto entidad

a la transacción con JPA

-em.remove(entidad): Genera un delete a la tabla relacional mapeada con los datos del objeto.

IMPORTANTE:

-Asegúrense que los objetos “entidad” fueron cargados con todos los valores necesarios en sus

atributos antes de ejecutar las transacciones, de lo contrario puede dar error al momento de

ejecutarlas.


En el caso de consultas:

public UsuarioDTO buscarXId(UsuarioDTO usuarioDTO) throws Exception{



try{


Object o=(Object)em.find(Usuario.class, entidad.getUsuario());

if(o!=null){

entidad=(Usuario)o;

BeanUtils.copyProperties( usuarioDTO,entidad);

}


}finally {

em.close();

}

return usuarioDTO;

}

public List<UsuarioDTO> buscarXCriterio(UsuarioDTO usuarioDTO)

throws Exception{

List<UsuarioDTO> listaDTO=new Vector<UsuarioDTO>();


try{


String query="SELECT o FROM Usuario o ";

Query emquery=em.createQuery(query);

List<Usuario> listaEntidad=emquery.getResultList();

//Recorremos listado de entidades

Iterator it=listaEntidad.iterator();

while(it.hasNext()){

Usuario entidad=(Usuario)it.next();

//Copiamos valores de entidad al DTO

//Añadimos dto a listado de DTO

usuarioDTO=new UsuarioDTO();

BeanUtils.copyProperties(usuarioDTO,entidad);

listaDTO.add(usuarioDTO);

}


}finally {

em.close();

}

//Retornamos al servicio listado de DTO.

return listaDTO;

}


Método buscarXId

Búsquedas por llave primaria

-em.find(ClaseEntidad.class, valorLlavePrimaria):

Realiza una búsqueda por llave primaria en la tabla que representa la ClaseEntidad.

Ejemplo: Object o=(Object)em.find(Usuario.class, entidad.getUsuario());

-Este tipo de búsqueda devuelve un único objeto, el cual de no ser nulo hay que castearlo a la

clase ENTIDAD correspondiente. if(o!=null)

entidad=(Usuario)o;

IMPORTANTE:

-Los objetos que se transportan entre capas son los DTO, por ello este método devuelve un DTO

a la capa de Negocio, previa copia de propiedades de la ClaseEntidad al DTO:

BeanUtils.copyProperties( usuarioDTO,entidad);


Método buscarXCriterio:

Búsquedas por criterio

-Este tipo de búsqueda requiere el uso de Java Persistence Query Languaje.

Es un lenguaje de consulta, similar al SQL, con la diferencia que trabaja con objetos

directamente.

String query="SELECT o FROM ClaseEntidad o ";

-La consulta es de tipo String y para ejecutarla, debemos crearla y guardarla en un objeto de

tipo Query

String query="SELECT o FROM Usuario o ";

Query emquery=em.createQuery(query);

-A diferencia de la búsqueda por llave primaria, cuando usamos JPQL, podemos obtener más

de una instancia de objetos al realizar una operación de consulta.

Por ejemplo ejecutamos un query con el método getResultList.

List lista=(Vector<Usuario>)emquery.getResultList();

El resultado lo almacenamos en un listado con el tipo de ClaseEntidad correspondiente.

IMPORTANTE:

-Los objetos que se transportan entre capas son los DTO, por ello este método devuelve un

listado de DTO a la capa de Negocio, previa copia de propiedades de la ClaseEntidad al DTO.

Ejemplo:

//Recorremos listado de entidades

Iterator it=listaEntidad.iterator();

while(it.hasNext()){

Usuario entidad=(Usuario)it.next();

//Copiamos valores de entidad al DTO

//Añadimos dto a listado de DTO

usuarioDTO=new UsuarioDTO();

BeanUtils.copyProperties(usuarioDTO,entidad);

listaDTO.add(usuarioDTO);

}

-También se puede utilizar JPQL para realizar actualizaciones ó eliminaciones masivas.

PASO 6: Ejecutar la aplicación

PASO 7: ¡Excelente!, ha culminado de probar exitosamente la aplicación web


CASO PROPUESTO PARA DESARROLLO EN CLASE

Ahora que ya hemos visto como utilizar JPA, importemos la última versión del proyecto plantilla que

vimos en la anterior clase e implementemos la capa de persistencia(datos) ahora con JPA.

LA PRÓXIMA CLASE EXPLICAREMOS COMO UTILIZAR JPA CON TABLAS

RELACIONADAS Y LLAVES FORÁNEAS.

USMP JPA Introduccion GuiaLabv1 0

Documents

Transcript of USMP JPA Introduccion GuiaLabv1 0