Introduciendo al uso de persistencia de datos JPA

Como parte de mi promesa de volver a bloguear activamente, ahora voy a escribir sobre el uso de la API de persistencia de datos de Java comunmente llamado JPA.


Pero antes de empezar este post aun recuerdo cuando Rodrigo queria implementar esta historia en nuestro proyecto de Sistemas de informacion gerencial, definitivamente si a mi no me hubiera agarrado el berrinche hubiesemos avanzado bastante en poco tiempo, ya que perdi bastante tiempo queriendo escribir mis diske reglas del negocio, por eso en ese caso se aplico bien lo que dicen la gente adulta "uno de cipote es tonto".

Este post se centrara en utilizar JPA utilizando el IDE Netbeans 6.1, ya que es el que tengo mas tiempo utilizandolo, y en mi caso la base de datos de mi preferencia es PostgreSQL.

La base de datos que cree la llame simplemente "tienda" y su estructura esta compuesta por dos tablas:

CREATE TABLE tienda
(
id serial NOT NULL,
descripcion character varying(20),
CONSTRAINT pk_tienda PRIMARY KEY (id)
)

CREATE TABLE empleado
(
nick character varying(15) NOT NULL,
nombre character varying(30),
fk_tienda integer,
CONSTRAINT pk_empleado PRIMARY KEY (nick),
CONSTRAINT tienda_empleado FOREIGN KEY (fk_tienda)
REFERENCES tienda (id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
)

Luego de esto nos dirigimos a nuestro Netbeans y creamos un proyecto "Java Application", creamos el nombre que nos plazca en mi caso le coloque JPAejemplo, incluso deje que el Netbeans me creara una clase con el metodo main que es alli donde mostrare su uso.


Luego de esto nos vamos a la pestana de "servicios" y creamos una nueva conexion a una base de datos, lo bueno de usar Netbeans es que ya trae el driver para PostgreSQL o si se desea tambien MySQL, si se esta usando algun otro como SQL Server, Oracle, SyBase, etc., es necesario agregarlo.


Para crear la nueva conexion hacemos clic derecho sobre el nodo que dice "Databases" en la pestana de servicios, y elegir la opcion "New Connection" del menu emergente. Ingresamos los datos necesarios para pegarnos a nuestra base de datos y damos aceptar.


Ya teniendo nuestra conexion abierta procedemos a crear nuestros objetos de reglas del negocio persistentes.

Para ello damos clic derecho sobre el proyecto, elegir nuevo y dar clic en la opcion "Entity Classes from Database", aparecera un asistence para la creacion de nuestros objetos persistentes.

El primer paso es elegir la conexion que creamos, para luego escoger las tablas que estaran involucradas.

Luego dar siguiente el asistente nos preguntara el nombre que le daremos a nuestras clases asi como tambien el paquete donde las encapsularemos.


Notese hay una alerta la cual indica que no hemos creado una unidad de persistencia debemos crearla para poder proseguir, asi que hacemos clic en el boton "Create Persistence Unit".


En la ventana de dialogo por lo general no se toca simplemente lo dejamos como esta siempre recordando el nombre de la unidad de persistencia que en este caso se llamara "JPAejemploPU", que luego la utilizaremos pero eso sera solamente una vez.

Ya generada la unidad de persistencia precionaremos el boton finalizar. Si seguimos los pasos tal cual como lo he indicado debemos tener dos clases creadas una llamada "Empleado" y la otra "Tienda".

Ahora para poder continuar debemos tener claro el tipo de dato que son las llaves primarias de las dos tablas que creamos en el caso de la tabla Tienda su llave primaria es de tipo "Serial" es equivalente a la opcion autoincrement de MySQL o IDENTITY de SQL Server.

Teniendo claro eso definimos la forma en la clase Tienda de como se generara el codigo primario cuando se indique que queremos realizar por decirlo asi un insert.

En la seccion del campo Id de la clase Tienda debemos agregar lo siguiente:

GeneratedValue(strategy=GenerationType.IDENTITY)

Esto se coloca despues de la anotacion "Column" del campo Id, que debe quedar asi:

@Id
@Column(name = "id", nullable = false)
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;


No hay que olvidar agregar los respectivos import.

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;


Con esto que se le agrego a la clase indicamos la forma de generar el valor para el campo Id en cada insert.

Ese tipo de generacion aplica para base de datos MySQL, SQL Server, Sybase, PostgreSQL (cuando trata de campos de tipo serial).

Pero cuando usamos secuencias se debe utilizar otro tipo de generacion de valores, como es el caso para Oracle, que en otro post lo explicare con mas detalle.

Pero bien no basta con solo agregar eso a la clase, tambien es necesario crear nuestras "Consultas nombradas", por esta caracteristica es que me gusto bastante esto del JPA, ya que es bastante, bastante flexible.

Creamos una simple para mostrar todos los empleados, ahora procedemos a editar la clase Empleado y en la anotacion "NamedQueries" agregamos la nuestra tan simple como esto:

@NamedQuery(name="Empleado.verTodos", query="SELECT e FROM Empleado e")

Que al final debe quedar asi:

@NamedQueries({
@NamedQuery(name="Empleado.verTodos", query="SELECT e FROM Empleado e"),
@NamedQuery(name = "Tienda.findById", query = "SELECT t FROM Tienda t WHERE t.id = :id"), @NamedQuery(name = "Tienda.findByDescripcion", query = "SELECT t FROM Tienda t WHERE t.descripcion = :descripcion")})

Ya hecho todo esto, pasamos a la parte mas interesante, que es utilizar nuestras clases ya configuradas, para ello creamos dos clases mas para la manipulacion de las ya antes mencionadas.

Una la llamaremos ControlEmpleado.java y la otra ControlTienda.java

El objetivo de estas sera mostrar consultar, agregar, eliminar o modificar un objeto en especifico.

Pero para no hacer mas largo este post de lo que ya esta por que me estoy cagando del sueno solo mostrare como mostrar los resultados de una consulta, y realizar un insert.

Pues bien para realizar un insert nos vamos a la clase ControlTienda y agregamos el siguiente metodo:

public void insertPrueba() {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("JPAejemploPU");
EntityManager em=emf.createEntityManager();

Tienda nueva = new Tienda();
nueva.setDescripcion("Otra tienda");

em.getTransaction().begin();
em.persist(nueva);
em.getTransaction().commit();
}


Eso es todo, lo mas correcto hubiera sido que el metodo recibiera una instancia de tienda y luego por medio de JPA se realizara el insert, pero el punto era mostrar como se hace.

Ahora como mostramos los registros? pues es tambien muy sencillo, y eso haciendo uso de nuestra consulta nombrada.

Creamos otro metodo en la clase ControlEmpleado, que devuelva un arreglo de Empleados.

public Empleado[] getEmpleados() {
EntityManagerFactory emf=Persistence.createEntityManagerFactory("JPAejemploPU");
EntityManager em=emf.createEntityManager();

Query q = em.createNamedQuery("Empleado.verTodos");

return (Empleado[]) q.getResultList.toArray(new Empleado[0]);
}

Ya con esto desde el metodo main hacemos un recorrido por los registros que nos devuelva nuestro metodo.

Empleado[] empleados = new ControlEmpleado().getEmpleados();

for (int i= 0 ;i
System.out.println(empleados[i].getNombre()+ " trabajo en "+empleados[i].getTienda().getDescripcion());



Y eso es todo, espero poder aportar mas con lo que he quedado pendiente en este post, saludos marachitos.

Comentarios (4)

4 Response to "Introduciendo al uso de persistencia de datos JPA"

  1. Hugo Barrientos says:
    sábado, noviembre 22, 2008

    Me cambio a este metodo... PERO YAAAA!!!!!

    Gracias compa como siempre muy fino!

    SALU!

  2. Daniel Alberto says:
    domingo, noviembre 23, 2008

    @ Hugo Barrientos:

    Gracias por dejar el respectivo saludo en este tu blog también.

  3. xtecuan says:
    martes, enero 13, 2009

    JPA!!!

  4. Ramiro Fuentes Says:
    martes, abril 14, 2009

    Excelente post, la forma en la que lo explicas resulta muy entendible. Seria bueno que siguieras posteando sobre JPA.

    Gracias por el aporte Daniel :)