Mostrando entradas con la etiqueta Hibernate. Mostrar todas las entradas
Mostrando entradas con la etiqueta Hibernate. Mostrar todas las entradas

martes, 3 de marzo de 2015

Usando una relación @ManyToMany (JPA) desde JSF

Antecedentes 

El relevante rol de JPA (Java Persistence API) en cualquier aplicacion java es innegable, desde aplicaciones de escritorio hasta el ambito empresarial JEE; es por ésto que el presente post pretende abordar la relación ManyToMany (una de las anotaciones de mapeo que JPA tiene para relacionar el mundo orientado a objetos con el mundo de tablas relacionales de base de datos).

En forma general JPA es un API destinado a la persistencia de datos es decir,  sirve de puente para poder interactuar entre las tablas de una base de datos con un mundo orientado a objetos y mediante un proveedor de persistencia (Hibernate, EclipseLink, TopLink, etc) poder conseguir manipular la informacion que formará parte de las tablas.

Una de las piezas clave para trabajar con JPA son las entidades, que basicamente son la representación en código java de una tabla de la base de datos (claro usando anotaciones especiales para ello). JPA usa un EntityManager que en definitiva es quien se encarga de adminstrar las Entidades y a su cargo tambien está el hacer posible acciones como: crear, borrar, actualizar, etc.; pero lo repito, todo ésto es posible gracias a un proveedor de persistencia pues JPA como tal no puede trabajar si no cuenta con un proveedor de persistencia, de ahí que un error común es pensar que JPA es igual o podría trabajar autónomamente tal cual  una herramientas ORM como Hibernate, y hay que dejar en claro que JPA es la especificación para peristencia en Java, mientras que Hibernate, Toplink, EclipseLink son proveedores de persistencia, es decir implementan lo que la especificación de persistencia define.

Hablando de JPA surgen algunas dudas comunes:

¿Por que Java no usa un proveedor de peristencia propio de JPA?. 
Porque eso precisamente refuerza la idea de libertad en uso de software libre, es decir, que el propio desarrollador decida cuál es la mejor implementación (o proveedor de persistencia) que se ajuste a sus necesidades.

¿Cual es el mejor proveedor de persistencia?
Hibernate por la experiencia y recorrido que tiene probablemente podría ser la mejor elección al momento de definir el proveedor de persistencia, pues de heho sirvió como blueprint para la definición de JPA, y no lo niego, Hibernate es una muy buena alternativa, sin embargo, por la experiencia propia de trabajar con EclipseLink debo decir que he tenido muy buenos resultados, por tanto queda a criterio de cada desarrollador el uso del proveedor de persistencia.

¿La peristencia en Java se consigue unicamente con JPA?
No, existen diversas tecnologías como la tradicional JDBC, harramientas ORM como Hibernate, el proyecto Apache Cayenne, Data Nucleous, etc.

Manos a la obra:
Como lo mencióne antes, el presente post se enfoca en la relación ManyToMany pues la misma supone un poco más de esfuerzo que las relaciones tradicionales @OneToOne, @OneToMany... sin embargo si el tema de persistencia es interesante para la comunidad (y si me lo hacen saber) podría escribir mas posts sobre cada una de ellas tanto unidireccional como bidireccionalmente.

El objetivo de éste post es lograr almacenar información de una relacion ManyToMany entre dos tablas desde una aplicacion web empresarial JEE.

En términos generales la relación se puede esquematizar como lo demuestra la siguiente imagen, donde es notorio el relacionamiento entre dos tablas (A y B) y una tabla intermedia de relacionamiento (A_B):

Nuestro caso de uso de ejemplo sera una anulación de documento en el que se pueda seleccionar multiples errores para dicha anulación, es decir, muchas anulaciones de documento pueden contener varios errores (escenario típico de una relacion Many To Many).

Nuestras tablas son las siguientes: ANULACION, ERROR y la tabla de rompimiento ANULACION_ERROR. Considérese que tanto ANULACION como ERROR deben tener bien definida su clave priaria (que posterioremente se transladara a la tabla de rompimiento).




La tabla ANULACION_ERROR (como se muestra en la siguiente imagen), se compone de dos claves foráneas, transladadas desde las tablas ANULACION y ERROR.


NOTA: Si decidimos que JPA realicé el mapeo de una relacion ManyToMany desde código java para que  generen las tablas de la base de datos  de manera automática, JPA seguirá estándares de generación (como muestra la siguiente imagen): El nombre de la tabla de rompimiento se formará por la unión de las dos tablas de los extremos por ejemplo, entre una tabla A y una tabla B, la tablade rompimiento se llamará A_B; y JPA generará automáticamente una key por las dos claves foráneas heredadas (mírese la imagen SYS_C0069738) pero como se mostrará en el desarrollo del post no es necesario ésto ultimo.


Ahora desde el código Java, necesitamos dos clases que representen a las tablas; éstas clases se llaman entidades y deben cumplir dos requisitos básicos: 1) llevar las anotación @Entity u @Id y 2) Implementar la Interfaz Serializable (por ser objetos que serán enviados a travez de una red).

La entidad para la tabla ANULACION se muestra a continuación:


La entidad para la tabla ERROR se muestra a continuación:

Considérese:
1) El uso de la anotacion @Table para indicar la tabla correspondiente a cada entidad.
2) La anotacion @ManyToMany  indica que hay una relacion ManyToMany entre la Entidades: Anulacion y Error1.
3) el argumento: mappedBy indica cuál es el lado dueño de la relacion, para éste caso mappedBy = "err" indica que el propietario de la relacion es Anulacion, es decir primero debo asignar el listado de errores a Anulacion y posteriormente persisto Anulación con sus errores correspondientes, en la tabla ANULACION_ERROR se reflejará los datos de Anulacion y Error.



4) No hace falta una Entidad para la tabla intermedia ANULACION_ERROR.
5) Si la tabla intermedia estuviera constuida fuera de los standares de generación automática de tablas que usa por defecto JPA, deberá usarse la anotación @JoinTable donde indicaremos el nombre de la tabla así como las columnas foráneas. Por ejemplo:

Ahora, desde la capa de vista invocamos la relación de la siguiente manera:

En donde, en un backing bean llamado "anulacionController" tendremos una referencia a: - erroresAnulacion que es un List de Error1, que mediante algun método de la lógica de negocio (en nuestro caso usamos la tecnología EJB) lo poblamos con los objetos que están guardados previamente en la base de datos :


- selectedErroresAnulacion que es un List de Errores que almacenará los Errores seleccionados por el usuario y que se persistirán en la tabla ANULACION_ERROR

Nótese también que se hace uso de un  convertidor, el cual se localiza dentro del controlador en la vista para de Error1 con el siguiente código:

Finalmente desde la vista se podrá visualizar los diversos campos de error, los cuales se seleccionarán para realizar el guardado en la base de datos:


Recomendación:  Como se vio en el código al manejar las relaciones para minimizar la complejidad y mejorar el rendimiento, se recomienda realizarlo con objetos propios de la aplicación, por ej: Anulacion, Error, etc.  en lugar de realizarlo con Objetos de tipo SelectItem o DataModel.

sábado, 30 de abril de 2011

Integración de JSF(PrimeFaces) y Hibernate(JPA)



Primeramente debo agradecer la super buena acogida de mi post anterior sobre la Integración de los frameworks JSF-Spring-Hibernate. Muchas gracias a la gente que me ha escrito y ya que muchos me han pedido que muestre como sería la integración JSF-Hibernate (sin la presencia de Spring) procedo a hacer éste post bajo pedido, y claro, siempre es un gusto colaborar con la comunidad.

El objetivo de éste post es generar la misma aplicación que hice al integrar JSF-Spring-Hibernate (pero sin Spring de por medio), es decir generaremos una aplicación web que interactúe con una base de datos (en MySQL) sobre la cual haremos inserciones, recuperación de datos y claro el despliegue de información en la capa de vista:



Ya que mencioné la capa de vista, la librería JSF que usaré será PrimeFaces 2.1 ¿por qué? porque el IDE que emplearé para éste ejemplo (Netbeans 7.0 beta 2) brinda ésta librería por defecto para trabajar con JSF 2.0.
Y ¿Por qué se usa Netbeans en éste post? porque las personas que me han escrito me pidieron que desarrollara éste ejemplo con Netbeans. Por cierto ¿Es mejor Netbeans que Eclipse? la respuesta es NO, ambos son extremadamente poderosos y personalmente ambos me gustan mucho, claro en la actualidad ando más inclinado por Netbeans pues gestiona los nuevos aspectos de la plataforma JEE6 de manera más transparente; pero en resumen ambos IDE´s son realmente buenos y todo programador debe estar abierto a trabajar con cualquiera de ellos en cualquier momento.

Nota: El servidor que uso es Glassfish 3.1 ¿por qué? porque viene por default instalado en la version de Netbeans que uso, pero aclaro que no hay restricción para quien estuviera usando alguna otra alternativa como Tomcat, Jboss, etc. y de hecho al trabajar con frameworks ligeros como JSF, Spring o Hibernate basta con Tomcat ya que no requerimos características de contenedor EJB.

Let´s do it!.

1) Creamos un proyecto web en Netbeans (añadiendo características de JSF y Hibernate).

2) Creamos el archivo de configuración de hibernate (hibernate.config.xml)



3) Escribimos la entidad Persona para lograr el mapeo de nuestra clase java al mundo relacional de la base de datos (no olvide incluirse el mapeo de ésta entidad en el archivo de configuración de hibernate)



4) Creamos la clase HibernateUtil la cual es la responsable de gestionar las sesiones de Hibernate para acceder a la base de datos.



5) Creamos la clase PersonaBB, como Backin Bean de JSF. Nótese el uso de anotaciones que se hace y como se crea lógica de negocio en él.



6) Creamos nuestra la página index.html con la cual podremos insertar y desplegar información en y desde la base de datos.



CONCLUSIÓN
Al realizar aplicaciones web Java, como es notorio en éste y mi anterior
posts el progamador no tiene reglas fijas que definan el uso que debe hacer de uno u otro framework, de hecho en el ejemplo de éste post excluimos por completo el uso de Spring, pero sea cual fuere la estrategia que un programador implemente como solución EE, ésta siempre debe estar enfocada en cumplir con las mejores prácticas y patrones que define la industria, por eso aclaro que éste post tuvo fines netamente educativos al integrar JSF con Hibernate, pero se sugiere a los lectores que tomen muy en cuenta las potencialidades que Spring brinda, resultado la combinación JSF-Spring-Hibernate una tripleta extremadamente poderosa para aplicaciones web.

El código del ejemplo (Proyecto en Netbeans 7.0 beta 2) puedes descargarse aquí.
Las librerías necesarias para probar el proyecto pueden descargarse aquí.

sábado, 5 de marzo de 2011

Integración de JSF-Spring-Hibernate(JPA)



Hace algunos días en el proyecto hermano de evangelización Java: Profesor Java dicté una conferencia sobre la integración de los frameworks: JSF, Spring y Hibernate, y agradezco mucho la tremenda buena onda que me brindó la comunidad que asistió desde países como: Argentina, México, Colombia, El Salvador, Ecuador, Perú, etc. con lo cual es gratificante corroborar que sí es posible generar proyectos latinoamericanos con filosofía colaborativa. Muchas gracias a todos los que asistieron y para aquellas personas que no pudieron asistir y que me han pedido que escriba un post con los contenidos del curso, aquí lo tienen y que espero sea de utilidad pues lo repito, ESTAMOS AQUÍ PARA DARNOS UNA MANO ;)

La arquitectura empleada en el ejemplo que desarrollamos es una arquitectura dividida en capas:


Como es notorio, empleamos éste modelo arquitectural por ser un modelo que impulsa un desarrollo bien hecho, y con el cual obtenemos grandes beneficios como:

1) Una clara separación entre capas para delegar funcionalidades específicas en cada una y con ésto evitar tener un código altamente cohesionado y "spaghettizado" (Real academia de la lengua ahí tienen una nueva palabra castellanizada por mi a la fuerza jejeje).

2) Hacer de nuestra aplicación una aplicación escalabe, es decir si en algún punto en el ciclo de vida de nuestra aplicación surge la necesidad de migrara hacia nuevas tecnologías, podremos hacerlo facilmente con una "visión lego" (mírese la imagen) en la cual simplemente retiramos la pieza que no necesitamos, para sustituirla por una nueva que se acople a nuestras necesidades; por ejemplo en la arquitectura antes mencionada podríamos migrar en la capa de vista sustituyendo el "lego de JSF" por "lego de Flex" sin necesidad de modificar el código restante de las otras capas, así mismo, empleando el mismo ejemplo podríamos migrar tanto en la capa de Lógica de Negocio de Spring a EJB o en la capa de acceso a datos de Hibernate a TopLink (sin que ésto afecte significativamente al resto de capas y mas que nada al código con el que ya contamos, claro serán necesarias ciertas modificaciones pero que son insignificantes en comparación a los cambios que seran necesarios al migrar una aplicación que no esta hecha bajo esta perspectiva arquitectural de división por capas).

Teniendo en claro el escenario en el cual nos desarrollaremos, empecemos detallando el ejemplo que se desarrolló en el curso:
Nuestro objetivo es generar una aplicación web que corra bajo algún servidor web como Tomcat, Glassfish, Jboss...etc y que interactúe con una base de datos (para este caso MySQL) sobre la cual haremos inserciones, recuperación y despliegue de la información ingresada, ésto a través de los framework: JSF-Spring-Hibernate(JPA) . A continuación una imagen de como luce la interfaz general:



1)Como primer paso creamos la base de datos "frameworks" (vacía) pues usando el potencial de hibernate generaremos las tablas de manera automática.
2)Creamos el archivo de configuración de Hibernate:



3) Hacemos una referencia a Hibernate en el archivo de configuracion de Spring.



4) Creamos la Entidad Persona (hacemos uso de las anotaciones de JPA). Nota: la implementación de la Interface Serializable es necesaria para una entidad que será persisitida como registro de una base de datos.



5) Generamos automáticamente las tablas de la base de datos (añadiendo el mapeo de la entidades en el archivo de configuración de Hibernate).

6) Creamos la Interface PersonaDAO donde mencionamos las características funcionales de inserción y recuperación de registros en la base de datos.



7) Creamos la implementación de la Interfase PersonaDAO, aquí desarrollamos la lógica de negocio en sí de la aplicación (nótese porqué Spring es nuestro aliado en ésto).



8) En el archivo de configuracion de Spring hacemos referencia al bean que implementa a PersonaDAO. Nota: Spring es un bean-factory.



9) Generamos nuestros Backing Beans (para soporte a JSF). Aquí se incluye otro concepto importantísimo de Spring (Inyeccion de dependencia: DI).



10) Generamos nuestro archivo de configuracion de JSF. Nota: podría incluso obviarse el uso de este archivo mediante el uso de anotaciones pero para éste caso decidí mostrar gran parte desarrollada "a mano" desde cero. Para próximos posts podría incluir estas nuevas características orientadas a anotaciones de la plataforma EE.



11) Creamos nuestras páginas JSF.



12) Probamos la aplicacion en algún Servidor Web Java.

El codigo de la aplicacion (Proyecto en Eclipse) puede ser descargado desde aquí.
Librerías aquí

Las diapositivas del curso pueden descargarse desde aquí.

CONCLUSIÓN.

Frameworks ligeros como Hibernate o Spring han sido tremendamente usados por haber emergido como una solución seria ante los "huecos" que la plataforma EE presentaba hace algunos años. Hablando de Hibernate, es una solución tan robusta que incluso ha servido de base para crear nuevas características standares en la plataforma EE actual (en su modelo de persistencia) y si hablamos de Spring, es un framework que cada día crece exponencialmente pues aparte de las características que lo hicieron famoso: Dependency Injection e Inversion of Control (siendo un Bean Factory), ahora brinda una gran variedad de funcionalidades en forma de módulos como: Spring Security, Spring AOP, Spring MVC, etc. por lo cual se ha convertido en la seria competencia a EJB, por tal motivo tanto Spring como Hibernate son dos opciones muy fiables que deben ser tomadas en cuenta por los arquitectos de desarrollo a la hora de implementar soluciones web Java.

NOTA: Por mencionar un ejemplo del uso de estos frameworks, la red social hi5 usa Spring dentro de su arquitectura.