Miércoles, 04 Junio 2014 19:44

Introducción a JPA (JAVA PERSISTENCE API)- CRUD

Escrito por 
Valora este artículo
(1 Voto)

Java Persistence API (JPA) proporciona un modelo de persistencia basado en POJO"s para mapear bases de datos relacionales en Java. El Java Persistence API fue desarrollado por el grupo de expertos de EJB 3.0, aunque su uso no se limita a los componentes software EJB. También puede utilizarse directamente en aplicaciones web y aplicaciones clientes, como lo haremos en este post ; incluso fuera de la plataforma Java EE, por ejemplo, en aplicaciones Java SE.
En su definición, se han combinado ideas y conceptos de los principales frameworks de persistencia como Hibernate, Toplink y JDO, y de las versiones anteriores de EJB. Todos estos cuentan actualmente con una implementación JPA.

El mapeo objeto/relacional, es decir, la relación entre entidades Java y tablas de la base de datos, se realiza mediante anotaciones en las propias clases de entidad, por lo que no se requieren ficheros descriptores XML. También pueden definirse transacciones como anotaciones JPA.

Java Persistence API consta de tres áreas:

•    El Java Persistence API
•    El lenguaje de query
•    El mapeo de los metadatos objeto/relacional

Basicamente JPA es una API para ORMs ( Object-Relational mapping) y te permite:
-Abstraerte del proveedor de persistencias, que no es mas la implementacion que uses. Por ejemplo puede utilizar Hibernate, Toplink, JDO y otros utilizando la misma API (al estilo de JDBC y los drives para cada BD)
-Eliminar la necesidad de escribir el SQL que mapea la BD a tus objetos utilizando simples anotaciones. Ya no escribiremos líneas sql en nuestro programas, sino que realizaresmo xonsultas sobre nuetros objetos.
-Poder crear relaciones ManyToOne, OneToOne, OneToMany y ManyToMany entre cualquier cantidad de objetos que quieras una vez mas solo con anotaciones
-Controlar la transaccionalidad (utilizando JTA o JDBC) de las consultas y demas
-Obviamente te ayuda mucho con el tema de la concurrencia y en la forma en que se gestiona
-Tiene un cache de primer nivel que por defecto evitar estar iendo a la BD muchas veces para lo mismo en una misma transaccion.
-Puedes utilizar un cache de segundo nivel que incrementar muchisimo el rendimiento de la app y la escalabildidad
-Trae un lenguaje de consultas OO super facil de usar que te permite hacer navegacion entre tablas como si fueran objetos. por ejemplo algo asi como .... where empresa.ciudad.pais.nombre = "COLOMBIA"  donde empresa ciudad y pais son tres tablas diferentes y nombre es una propiedad de Pais.

Para una mayor referencia podemos leer los siguietes articulos

Tarjeta de referencia de JPA.

Una mas

Lo que haremos en este post es crear mediante netbeans 6.8 una simple aplicación J2SE,  en la que haremos utilización de JPA, trabajaremos mediante el netbeans que  nos hara la tarea mas sencilla, ya que no tendremos que escribir todo el codigo, sino que este...comenzamos

Antes que nada  nesecitaremos tener creada una base de datos MYSQL, para este ejemplo utilizamos la base de datos de este post.

En primer lugar creamos un nuevo proyecto, vamos a Archivos->Proyecto Nuevo

Elegimos aplicación java le damos en siguiente, luego el nombre, le damos ubicación y demás (para una mayor referencia sobre creación de proyectos en java podes mirar este post) y por ultimo  en terminar.


Ya tenemos el proyecto creado ahora procedemos a crear 2 paquetes “Entidades” y ”Controladores”

El árbol del proyecto nos debe quedar asi


Ahora procederemos a crear entidades a partir de una  base de datos ,para este ejemplo como mencionamos anteriormente usaremos la base de datos de este post.

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 la tabla “empleados”:

  1. public class Empleados
  2. {
  3. @Id
  4. private String id;
  5. private String nombre;
  6. private String apellido;
  7. }

Lo anterior seria un simple ejemplo de una entidad, pero nosostros lo haremos sutomaticamente desde el netbeans de la siguiente manera.
Le damos click derecho sobre el paquete Entidades->Nuevo y luego ubicamos Clase Entidad a partir de una Base de Datos (Si no la ubicamos en el menú textual nos dirigimos a otro y luego en el menú persistencia estará “Clase Entidad a partir de una Base de Datos”)

En la ventana elegimos la conexión a la base de datos, en este caso la bd “empresa”, agregamos  las dos tablas, y le damos click en siguiente

Observamos las cajas de texto con las ubicaciones y demás, también podemos ver que no tenemos creada la unidad de persistencia, el ide nos sigiere crearla, ya que sin esta no haremos nada.

"Crear unidad de persistencia" nos creara e Este es un fichero muy importante, en este  indicar precisamente que clases son Entity, sobre que base de datos vamos a trabajar, y cual es la politica de creacion de esta base de datos.

Se nos abre la siguiente ventana, nos pide el nombre de la unidad de persistencia,la dejamos tal cual esta. También nos pide la biblioteca de persistencia, tenemos 3 opciones, en este caso elegimos la de hibérnate, luego en la estrtegia de generación de tablas elegimos “ninguno”, para finalizar le damos en crear.


Las opciones de mapeo la dejamos tal cual esta y le damos en terminar


Si observamos el árbol de proyectos ya tenemos creada la entidad Empleados y Departamentos  , la cual es una clase serializable con todos sus métodos modificadores (set y get ) y la unidad de persistencia persistence.xml, esta ultima un archivo xml, la cual podemos modificar de maner visual o mediante líneas xml, siempre respetando los tags de jpa.


Ahora crearemos la clase controladora, es decir la clase que nos hara las altas bajas, modificaciones y un par de ocnsultas del las tablas epleados y departamentos, a través de sus correspondientes entidades. Le damos click derecho sobre el paquete Controladores->Nuevo y luego ubicamos Clase Controladora JPA de Clase Entidad (Si no la ubicamos en el menú textual nos dirigimos a otro y luego en el menú persistencia estará “Clase Controladora JPA de Clase Entidad”)


En la lista clase entidades disponibles el ide ya nos detecta las dos  clases entidades, anteriormente creada, la agregamos a la lista derecha, y le damos en siguiente y luego en terminar.


Oservamos el árbol del proyecto y ya tenemos de manera fácil creada nuestra clase controladora necesaria para el CRUD de nuestras tablas También el ide nos crea un paquete de excepciones con sus respectivas clases.
El árbol extendido nos queda asi (esto es para netbeans 6.8, recuerdo que en el 6.5 no me creaba las excepciones)


Bien hasta aquí tenemos creada la entidad con su respectiva clase controladora, ahora veremos como crear un objeto de esa clase entidad, setear sus propiedades, y luego insertar modificar y eliminar atravez de la clase controladora
Antes de cada ejecución nos aseguramos de incluir la biblioteca JDBC de MYSQL a nuestro proyecto, vamos al Bibliotecas->Agregar Biblioteca


Localizamos la de mysql  y le damos en añadir bibioteca


La biblioteca nos tiene que quedar de esta manera

CRUD

Para ello vamos al Main generado por el ide
Primeramente, recordemos que vamos a utilizar las clases entidades y las controladoras, como están en otro paquete la debemos importar
Agregamos estas líneas después del package AplicacionJava1;

import Entidades.*;

import Controladores.*;

El código nos tiene que quedasr asi



ALTA

Agregamos las siguientes líneas, al método main principal

  1.         //instanciamos un onjeto de la clase empleados
  2.         Empleados empleado=new Empleados();
  3.         //instanciamos un onjeto de la clase controladora de empleados
  4.         EmpleadosJpaController control=new EmpleadosJpaController();
  5.         //seteamos la propiedad Nombres de empleados
  6.         empleado.setNombresEmp("SUSANA");
  7.         //seteamos la propiedad apellidos de empleados
  8.         empleado.setApellidoEmp("GIMENEZ");
  9.         //seteamos la propiedad Direccion de empleados
  10.         empleado.setDireccionEmp("BS. AS.");
  11.         //seteamos la propiedad Dni de empleados
  12.         empleado.setDniEmp(10234987);
  13.         //seteamos la propiedad Telefono de empleados
  14.  // recordamos q no seteamos la propiedad id ya que es autogenerada
  15.         empleado.setTelEmp("011-52341642");
  16.         //utilizamos el metodo create para crear un nuevo empleado
  17.         // al metodo solo le pasamos la clase ya seteada
  18.         control.create(empleado);


El código nos queda asi


Ejecutamos el Main , y ya tiene que estar agregado nuestro nuevo empleado.
Verificamos en las base de datos.nos dirigimos a Prestaciones->Base de Datos, elegimos el nodo de la base de datos “empresa” y le damos click en conectar


Extendemos los nodo, le damos click derecho, y con el izquierdo en Mostrar Datos


En la ventana anterior observamos el nuevo empleado  agregado


Con esta alta vemos lo sencillo que es, agregar un nuevo empleado tratándolo como un objeto con sus respectivas propiedades.

MODIFICACION

Copiamos las siguientes líneas al método principal del main

      //recordemos que debemos respetar los campos que no pueden
       //ser nulos, ya que de no ser asi dara error---
        //instanciamos un onjeto de la clase empleados
        Empleados empleado=new Empleados();
        //instanciamos un onjeto de la clase controladora de empleados
        EmpleadosJpaController control=new EmpleadosJpaController();
        //seteamos la propiedad, ya que por esta propiedad buscara el
        //empleado indicado
        //en este caso al que agregamos anteriormente
        empleado.setIdEmp(10);//el emp de id 10 sera modificado
        empleado.setNombresEmp("CATALINA");
        //seteamos la propiedad apellidos de empleados
        empleado.setApellidoEmp("LUNA");
        //seteamos la propiedad Direccion de empleados
        empleado.setDireccionEmp("BS. AS.");
        try{//bloque try catch para el control de excepciones
            control.edit(empleado);//utilIzamos el metodo edit,
        }                           // para le modificacion
        catch(Exception e)
        {
            System.out.println(e);//si ocurre un error lo
        }                              //mostramos por salida estandar


Nos queda asi


Ejecutamos el Main
Verificamos refrescando la consulta y observamos los datos modificados.



BAJA

Agregamos las siguientes líneas al metodo principal main


     //para  la baja no es nesesario instanciar
     //el la clase empleados
     // si instanciamos la controladora, ya que esta me busca por id
     EmpleadosJpaController control=new EmpleadosJpaController();

        try{//bloque try catch para el control de excepciones
            // en este caso para eliminar utilizamos el metodo
            //destroy, y le pasamos com parametro el id
            //en este caso eliminaremos el empleado anteriormente creado
        control.destroy(10);}
        catch(Exception e){
        }

El main.java nos queda asi

Ejecutamos el Main
Verificamos el la consulta sql, y vemos q lo elimino y no aparece el empleado anteriormente creado

REALIZANDO UNA CONSULTA

Agregamos las siguientes líneas al metodo principal main

  1.      List lista=new ArrayList();//creamos un objeto de una lista
  2.         //instanciamos un onjeto de la clase empleados
  3.         Empleados empleado=new Empleados();
  4.         //instanciamos un onjeto de la clase controladora de empleados
  5.         EmpleadosJpaController control=new EmpleadosJpaController();
  6.         //atravez de la clase control obtenemos todos los registros
  7.         lista=control.findEmpleadosEntities();
  8.         //creamos un bucle for para recorrer la lista
  9.         for (Object lista1 : lista) {
  10.           //a la clase empleados le damos el valor de la lista
  11.        empleado=(Empleados)lista1;//
  12.        //mostramos por la salida el nombre de los empleados
  13.        //a travez de getNombreEmp
  14.        System.out.println(empleado.getNombresEmp()+"\n");
  15.      }
  16.  
  17.  

El main.java nos queda asi

Ejecutamos el Main
Y la salida del netbeans nos muestra los siguiente

Bien hasta aquí hemos visto como realizar un CRUD, vimos como nos referíamos solamente a objetos, JPA se encargo del mapeo objeto relacional,  no utilizamos en ningún momento líneas sql en nuestra aplicación, solamente anotaciones hibernate de la clase controladora.Cualquier consulta consulten....

Visto 1138 veces Modificado por última vez en Domingo, 20 Julio 2014 19:17

2 comentarios

  • Enlace al Comentario isa Lunes, 04 Mayo 2015 05:48 publicado por isa

    aqui EmpleadosJpaController se debe de modificar;

    public class EmpleadosJpaController implements Serializable {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("esta en el persistence.xml");

  • Enlace al Comentario Erika Domingo, 20 Julio 2014 19:28 publicado por Erika

    Muy bueno

Deja un comentario

Asegúrate de llenar la información requerida marcada con (*). No está permitido el código HTML. Tu dirección de correo NO será publicada.