Tutorial De Jpa

JPA es un framework de persistencia, que nos abstrae de las bases de datos y nos brinda un estandar para persistir los datos en java.

JPA viene a solucionar el vacio que hay entre utilizar objetos y persistirlos en una DB relacional.

Como todos sabemos java trabaja con el paradigma orientado a objetos, pero que pasa cuando quiero guardar mis datos?

Podria utilizar DB orientadas a objetos, pero con el tiempo estas no han podido imponerse a las relacionales, cuyo punto fuerte es SQL, un estandar para la consultas.

JPA mapea automaticamente nuestras clases en la base de datos de manera transparente, y utilizando un estandar, lo cual entre otras cosas nos permite poder migrar de motor cuando quieramos, y poder compartir codigo o trabajar en equipo sin ningun problema.

JPA trabaja fuertemente con anotaciones. Para mapear un bean (una clase java) con una tabla de la base de datos, tendriamos que escribir lo que se llama un Entity.

Esto es tan sencillo como escribir nuestro Bean, con sus atributos y metodos get y set. Y despues añadirle la anotacion “@Entity” a la par que seleccionamos uno de sus atributos como clave primaria con “@Id”. Por ejemplo, el siguiente trozo de codigo podria ser un Entity, que nos permitiria luego almacenar, recuperar, o actualizar campos sobre una tabla “usuario”:

@Entity

public class Usuario

{

@Id

private String id;

private String name;

private String email;

}

Con solo esto ya tenemos creada una “entidad” llamada “Usuario” y podriamos insertar, actualizar o eliminar entradas en una tabla llamada “Usuario” aunque esta aun no existe, siquiera.

Un fichero muy importante que tenemos que crear a parte de las clases “Entity” es el fichero “persistence.xml”, en este fichero vamos a indicar precisamente que clases son Entity, sobre que base de datos vamos a atacar, y cual es la política de creacion de esta base de datos.

Este fichero tiene los datos de la conexión a la base de datos, la cual ya debe estar creada anteriormente.

En el caso de las tablas no es necesario, JPA automáticamente crea las tabas necesarias a partir de las entidades que poseamos (en caso que tengamos habilitada dicha caracteristica).

El fichero xml se estructura de la siguiente forma:

- Tiene un nombre “EjemploPU” en el tag , este es importante, pues luego es por ese nombre por el que podremos acceder a este recurso o unidad de persistencia. Aqui se llama “EjemploPU” pero puedes darle el nombre o alias que quieras.

- Entre y vamos añadiendo todas las clases Entity que queremos manipular. Esto tambien es muy importante, porque si creas un Entity pero no lo añades a esta seccion del XML, para JPA no existe.

- Y por ultimo estan los properties. En estos properties estamos definiendo el mecanismo de conexion a la base de datos. Cambiando estos valores por los adecuados podemos conectar a cualquiera otra base de datos que tengamos.

- Existe una ultima propiedad que conviene tener activa en los primeros momentos, cuando estamos desarrollando:

Esta propiedad hace que si el modelo de datos no existe se cree de manera automatica, pero cada vez que invocamos al mecanismo de persistencia, borra el contenido de las tablas y las vuelve a crear si no existen previamente. Esto al comienzo cuando estamos de “pruebas” viene de fabula, despues ya podemos comentar esta opcion para trabajar con datos reales que tengamos insertados.

Tenemos los Entity ya creados. Como puedo por ejemplo, insertar uno de ellos en la base de datos.

Pues con un trozo de codigo similar al siguiente:

- Primero creamos un EntityManager que nos permita manipular y trabajar con los objeto Entity:

Código: [Seleccionar]

EntityManagerFactory factory = Persistence.createEntityManagerFactory("EjemploPU", System.getProperties());

em = factory.createEntityManager();

Como ves, el nombre que uso es “EjemploPU”, esto es porque asi lo tenemos definido en el fichero “persistence.xml”, asi sabe como recuperar las clases y propiedades que corresponden a esta unidad de persistencia. Si tu cambiaste el nombre en el XML, aqui deberias poner el que hayas usado.

Una vez creada la EntityManager, ya es muy simple, abrir una transaccion e incluso almacenar elementos (Entity) en la base de datos. Un ejemplo para insertar un “Usuario” podria ser:

Código: [Seleccionar]

em.getTransaction().begin();

Usuario u = new Usuario();

u.setId(100);

u.setName("jose");

u.setEmail("notengo@gmail.com");

em.persist(u);

em.flush();

em.getTransaction().commit();

Como se puede ver, hemos recuperado una transaccion (getTransaction), instanciado un objeto usuario, asignado valores a sus atributos, lo hemos “persistido” (almacenado) en la base de datos con “persist” y por ultimo un commit de la transaccion.

Es decir, solo escribiendo una clase, y un XML, ya hemos insertado un usuario con campos nombre y email en una tabla “Usuarios” que se ha generado de manera dinamica.

...