JPA, implementando la capa de persistencia

Hola Jabatos:

La Java Persistence API es la biblioteca estandar encargada de la persistencia de los datos de nuestras aplicaciones. La versión 2.0 de JPA nos permite funcionar de manera óptima en las operaciones CRUD de las bases de datos.

Como sabéis, la capa de persistencia corresponde a la M del modelo MVC. Las clases creadas permitirán abstraerse al resto de la aplicación de todo lo relativo a la persistencia y a las bases de datos empleadas.

JPA 2.0 requiere, por un lado, de la configuración del fichero persistence.xml, y de otra parte, de la creación de unos ficheros pojos con anotaciones, denominados "entity".

El fichero persistence.xml

En este fichero vamos a declarar un par de cosas. Por un lado, declararemos las clases (los ficheros pojos) encargadas de interactuar con la base de datos.

Por otro lado, crearemos la información para que nos podamos conectar con la base de datos: definición de ddbb, tipo, conexión, user, password, etc.

En el fichero persistence.xml podemos definir una o varias bases de datos. Y en cada una de ellas definiremos la conexión y las clases que vamos a manejar. Si no incluimos alguna clase dentro del persistence.xml, el código no generaría error pero fallaría en la ejecución porque no alcanzaría el fichero en la base de datos. Por lo tanto hay que ser muy cuidadoso con ese asunto.

Ejemplo de fichero persistence:

<?xml version="1.0" encoding="windows-1252" ?>
<persistence 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_2_0.xsd"
             version="2.0">
  <persistence-unit name="ModelSportCalendar">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <jta-data-source>java:/app/jdbc/jdbc/Connection sportCalendarDS</jta-data-source>
    <class>model.Deportes</class>
    <class>model.Usuarios</class>
    <class>model.Recorridos</class>
    <class>model.Agenda</class>
    <properties>
      <property name="eclipselink.target-server" value="WebLogic_10"/>
      <property name="javax.persistence.jtaDataSource" value="java:/app/jdbc/jdbc/Connection sportCalendarDS"/>
      <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
      <property name="javax.persistence.jdbc.password" value="06C72776E80B1999AFAB7153E60C083A"/>
      <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost/sportcalendar"/>
      <property name="javax.persistence.jdbc.user" value="pepillo"/>
    </properties>
  </persistence-unit>
</persistence>

Remarcado en verde podemos observar:

• El nombre identificador (creado por nosotros) de la base de datos. Ese nombre es para cuando invoquemos el EntityManagerFactory para crear la conexión, el emf sepa donde obtener los datos.
• Las anotaciones <class> son los nombres de nuestros ficheros pojos declarados. El emf manejará a los integrantes de esta lista para, a través de ellos, generar objetos de acceso a la base de datos.
• Las anotaciones <properties> son la configuración necesaria para conectarte a la base de datos. Cada base de datos tiene diferente configuración, pero en general, siempre hay que darles el tipo de conexión, el driver, la url, el user y el password. Toda esta información coincide con la información de la base de datos.

He de destacar que, generalmente, el IDE que empleéis os facilitará mucho las cosas Tanto Eclipse como NetBeans así como JDeveloper pueden crear de forma automática el fichero persistence.xml si previamente has configurado (mediante wizard) la base de datos en el IDE.

Los ficheros entity (pojos)

Un java entity parte de un fichero pojo (plain old java object). Son ficheros simples que solo constan de sus atributos privados y los getters/setters de acceso. Estos ficheros que implementan "al detalle" los distintos campos: por cada campo de la base de datos debe haber un atributo en el fichero entity. Los ficheros entities serán ficheros model de nuestra aplicación.

En JPA los entities deben implementar el interface Serializable, y además llevar anotaciones:

@Entity
@Table(name = "\"usuarios\"")
public class Usuarios implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private long id;
    @Column(name = "keyuser", nullable = false)
    private String keyuser;
    @Column(name = "login", nullable = false)
    private String login;
    @Column(name = "nameuser", nullable = false)
    private String nameuser;
    @Column(name = "password", nullable = false)
    private String password;
   @Column(name = "email", nullable = false)
    private String email;

    public Usuarios() {
    }
           // GETTERS Y SETTERS
}


Sin entrar ahora en el detalle de construir un fichero entity de manera eficiente, observamos varias cosas:

1. Es un class que implementa serializable, ya que hace operaciones de E/S
2. @Entity lo define como un bean especializado en la implementación de la persistencia. Es por eso que a los ficheros model se les llama "entity".
3. Cada uno de los atributos tiene un conjunto de anotaciones. En caso de faltar las anotaciones se toman por defecto, pero pueden ocasionarse errores al interactuar con la base de datos. Las anotaciones sirven para orientar a JPA en cuanto a las relaciones con la base de datos. Y en este contexto, las anotaciones del campo id nos informan de  que @Id le dice que es la clave id (key) de grabación; @GeneratedValue está diciendo que será la base de datos la que le asignará el número que le corresponda a la id de forma automática; @Column se refiere a varias opciones del atributo, name es el nombre en la base de datos (no tiene porque coincidir con el de java), nullable=false le dice que la DB no admitirá campos null, etc.

Resumiendo...

Crear la capa de persistencia en JPA 2.0 consiste en crear el fichero persistence.xml y los ficheros pojos (entities) que representan cada uno a una tabla de la database.

El IDE nos facilitará, en muchos casos, mediante procedimientos automatizados, tanto la creación de persistence.xml como la de los "entities". No obstante, es necesario y pertinente hacer los ajustes correspondientes en los "entities", ya que la automatización si bien nos libera de mucho trabajo, no es perfecta.