Vamos a programar un poco

Vamos a programar un poco…

Antes cuando tenía que hacer una consulta en la base de datos, empleaba JDBC a “pelo” o Frameworks como iBatis e Hibernate. Eran APIs que permiten mapear una clase Java (Bean) con una tabla de la base de datos y facilitan mucho el trabajar con la persistencia de los objetos (usando métodos del estilo a “select”, “insert”, “update” y “delete”).Pero ahora he conocido JPA y me parece que a partir de ahora será lo único que utilizare. Con JPA puedes hacer cosas como estas:

- Escribir el código de tu clase, y aunque no exista la tabla correspondiente en la base de datos, no importa JPA se encargara de crear la tabla del modelo de datos. Esto esta Genial! es decir, tu solo escribes el código y JPA con su mecanismo de persistencia ya se encargara de crear la tabla, si no existen y si existen pues las usa. Además da igual la base de datos, podrías por ejemplo escribir la aplicación en MySQL y después con un ligero cambio llevártela a Oracle.

- Sincronización. Viene tu jefe de proyecto y te dice, quiero que añadas dos columnas nuevas a esta tabla y elimines el campo primario de esta otra tabla. Y ya empiezas a sudar. Llevas escritas más de 20 sentencias SQL y te toca cambiarlas. Eso se acabó. Es tan sencillo como irte al código de tu bean, y añadir 2 atributos nuevos que se mapearan como campos nuevos de la tabla. Chachi.

- Puedes también mantener la persistencia no necesariamente atacando a una base de datos, tal vez te interesaría persistir un objeto a un fichero de texto plano o XML.

Como ejemplo de uso de JPA vamos a implementar un pequeño sistema CMS personal. La idea es escribir una pequeña aplicación que nos permita almacenar nuestros documentos en la base de datos. Y al decir “almacenar” me refiero a almacenar el contenido del documento en la propia base de datos, no su pathname o ruta en el disco duro. De esta manera aprovecharemos para ver como con JPA se hace también muy simple la inserción en campos BLOB de la base de datos, algo que muchas veces trae de cabeza a los desarrolladores de Java.

Este ejemplo de CMS (cuyo código dejo al final del artículo) será muy simple. He preferido que el ejemplo no se complique con restricciones o constraints de la base de datos, así que no existen tampoco claves foráneas a otras tablas. De manera que será difícil que nos dé un error, cuando intentemos insertar algún contenido. También en esta primera versión solo os dejare una aplicación en modo consola (un intérprete de comandos) que nos permitirá ir insertando o consultando los documentos de nuestra base de datos. En otro artículo posterior, veremos cómo crear un interface gráfico vía web que nos permita manipular los documentos.

¿Qué necesitamos?

- Pues un editor de Java. Puedes usar el que más rabia te dé. Eclipse, Netbeans u otro. Yo esta vez he usado Netbeans, para ir variando.

- Una base de datos. El ejemplo está preparado para MySQL pero funcionara con ligeros cambios en Oracle u otra base de datos relacional. A su vez, no te olvides de incluir el driver JDBC de conexión a la base de datos en el Classpath.

- y por último y lo más importante, para trabajar con JPA necesitamos una implementación de JPA. Existen muchos fabricantes que han hecho la suya (ver implementaciones). En el ejemplo yo he empleado EclipseLink, así que básicamente, descárgate esta implementación, descomprímela y copia los siguientes .jar en el classpath de tu proyecto:

-eclipselink.jar

- javax.persistence_1.0.0.jar

En Netbeans podemos por ejemplo crear una Librería con esos jar, que luego incluiremos en el proyecto, en Eclipse, pues bastaría con añadirlos al classpath.

Trabaja fuertemente con anotaciones. Para mapear un bean (una clase java) con una tabla de la base de datos, tendríamos que escribir lo que se llama un Entity.

Esto es tan sencillo como escribir nuestro Bean, con sus atributos y métodos get y set. Y después añadirle la anotación “@Entity” a la par que seleccionamos uno de sus atributos como clave primaria con “@Id”. Por ejemplo, el siguiente trozo de código podría ser un Entity, que nos permitiría 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 podríamos insertar, actualizar o eliminar entradas en una tabla llamada “Usuario” aunque esta aún no existe, siquiera. A que mola!!

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 qué base de datos vamos a atacar, y cuál es la política de creación de esta base de datos.

Este fichero “persistence.xml” debe colgar de un directorio “META-INF” que este accesible en el CLASSPATH. Esto es, si tu código por ejemplo lo estas dejando en la carpeta “src”, tendrás que crear una carpeta “src/META-INF” y ahí dentro crear el fichero “persistence.xml”.

El contenido de este fichero es similar al que puedes ver en la siguiente imagen:

Fíjate en el XML un momento:

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

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

- Y por último están los properties. En estos properties estamos definiendo el mecanismo de conexión a la base de datos. Cambiando estos valores por los adecuados podemos conectar a cualquiera otra base de datos que tengamos.

- Existe una última propiedad que

...