Hibernate - Parte 6: Relaciones / Muchos a Muchos

En ocasiones necesitamos relacionar muchas entidades de un tipo con muchas entidades de otro tipo. Este tipo de relaciones es muy común cuando trabajamos con bases de datos relacionales, por eso es importante saber cómo trabajar con ellas.

En este último tutorial de la serie veremos cómo crear los últimos dos tipos de relaciones el framework de Hibernate: relaciones muchos a muchos unidireccionales y bidireccionales.

Hibernate - Parte 5: Relaciones / Muchos a Uno

Ya hemos visto, en los tutoriales anteriores, cómo generar 4 de los 7 tipos de relaciones que podemos crear con Hibernate.

En esta ocasión veremos cómo crear relaciones uno a muchos unidireccionales (ya que, como dije en el tercer tutorial, las relaciones uno a muchos bidireccionales son iguales a las relaciones muchos a uno bidireccionales ^-^).

He regresado ^-^ y traigo mejoras

Este último mes estuve trabajando en un proyecto un poco pesado, además de estar dando un curso en una empresa. Por esa razón descuidé un poco el blog, así como las preguntas que hacían en los cometarios de cada una de las entradas.

Pero afortunadamente ambos parece que terminaron bien, así que trataré de regresar al ritmo normal de posteo de tutoriales y poder responder todas las dudas que comenten. También aprovecharé para hacer unos pequeños cambios en cuanto al estilo de los tutoriales, esperando que todo quede mejor.

Entre otras cosas, subiré los archivos de los ejemplos para que puedan probarlos ustedes mismos. Comenzaré subiendo los ejemplos de los tutoriales nuevos que vaya creando y poco a poco iré subiendo los de los que ya están en el blog.

En unos días estaré continuando con los tutoriales de Hibernate.

Además, algunos de los tutoriales están comenzando a cargar bastante lento, esto es por el elevado número de comentarios que se encuentran en algunos, así que implementaré una política de 30 comentarios. Una vez que un tutorial alcance los 30 comentarios cerraré los mismos. Los comentarios que ya estaban seguirán ahí, pero ya no se podrán colocar más. Pero no se preocupen, si tienen alguna duda pueden enviarla directamente a este correo:

programadorjavablog@gmail.com

Y con todo gusto los ayudaré.

Bien, creo que por el momento es todo.

Saludos y muchas gracias.

Acepto Donaciones

Debido a problemas económicos me he visto en la necesidad de agregar en el blog un botón para aceptar donaciones vía paypal .

Las donaciones son en dolares debido a la gran cantidad de visitantes extranjeros que recibe el sitio.

Si este blog te ha servidor de algo o de alguna forma ha podido ayudarte y tienes la posibilidad de donar por favor, no lo dudes ^-^.

Saludos

Hibernate - Parte 4: Relaciones / Uno a muchos

En el tutorial anterior dijimos que en las bases de datos existen 7 tipos de relaciones, y vimos cómo crear relaciones uno a uno, tanto unidireccionales com bidireccionales, con Hibernate usando archivos de mapeo y anotaciones (en ejemplos separados). Cubriendo con eso 2 de los 7 tipos.

Ahora veremos como trabajar con relaciones Uno a Muchos, unidireccionales y bidireccionales. Con lo que cubriremos otros dos tipos.

HIbernate - Parte 3: Relaciones / Uno a uno

En los tutoriales anteriores vimos cómo persistir objetos simples en la base de datos usando Hibernate, tanto con archivos de mapeo XML como con anotaciones. Gracias a eso no tuvimos que escribir ni una sola línea de código SQL.

Sin embargo solo en raras ocasiones deberemos guardar un objeto simple como lo vimos. Por lo regular guardamos grafos de objetos u objetos relacionados con otros objetos. En estos casos querremos que los objetos se guarden, actualicen, o eliminen en el momento que lo haga nuestro objeto principal (o tal vez no ^-^!).

En este tutorial veremos cómo manejar los objetos relacionados (con mapeos y con XML).

HIbernate - Parte 2: Persistiendo Objetos Simples usando Anotaciones (metadatos)

En el tutorial anterior vimos como crear una pequeña aplicación con Hibernate usando mapeos en archivos XML. Aunque esto es bastante útil (en algunas situaciones) puede ser bastante engorroso, especialmente en aplicaciones muy grandes.

Afortunadamente existe otra forma de realizar estos mapeos, y es usando anotaciones o metadatos, los cuales se agregan directamente al código fuente y, por lo tanto, es más fácil estar conscientes de estos datos de mapeos al estar editando el código fuente. Además usan muchos valores por default, ya no será necesario que escribamos toda la información para los mapeos.

En esta ocasión mostraré como realizar el mismo ejemplo que en el tutorial anterior, pero haciendo uso de anotaciones en lugar de archivos de mapeo XML.

HIbernate - Parte 1: Persistiendo Objetos Simples usando Mapeos en XML

En la mayoría de las aplicaciones empresariales, si no es que en todas, una parte muy importante es el almacenamiento de datos de forma que estos datos puedan sobrevivir más allá del tiempo que nuestra aplicación está encendida (ya sea en una aplicación standalone o en una aplicación web).

El almacén de datos más común son las bases de datos relacionales. La naturaleza de estas bases hace que no sea tan fácil usarlas en el almacenamiento de datos en aplicaciones orientadas a objetos (por las diferencias entre el modelo de datos de objetos y el modelo de datos relacionales), ya que para guardar un objeto debemos extraer cada una de sus propiedades que queremos persistir y armar con ellos una sentencia INSERT de SQL. De la misma forma, cuando queremos recuperar los datos de un objeto, debemos usar una sentencia SELECT de SQL y después extraer el valor de cada una de las columnas recuperadas y llenar así nuestro objeto.

Esto puede no parecer un problema en aplicaciones pequeñas, pero cuando comenzamos a tener muchos objetos que debemos guardar se vuelve algo muy pesado y engorroso, además de que consume mucho de nuestro tiempo que podríamos dedicar a mejorar la lógica de la aplicación, o a realizar pruebas de la misma.

Instalación de un Servidor de Desarrollo - Parte 1: Virtualizando Linux con VirtualBox

Algunas veces queremos probar el funcionamiento de nuestros sistemas en algún sistema operativo distinto al sistema que tenemos instalado en nuestras máquinas. Comunmente esto ocurre cuando nuestro ambiente de desarrollo se encuentra en un sistema operativo y nuestro ambiente de producción o de deploy se encuentra en otro. O si queremos comprobar que nuestra aplicación funcione en distintos ambientes.

Esto ocurre frecuentemente cuando desarrollamos en Windows e instalamos en un servidor que se encuentra en algún Unix (Linux, HP-UX, Solaris, etc.). Es por eso que es importante que podamos intercambiar de un sistema a otro de forma rápida, y en nuestra misma maquina, mientras nos encontramos en etapas de desarollo.

Es en estos casos en los que es útil usar la virtualización de un sistema. Existen varias aplicaciones que nos permiten hacer esto. Una de ellas que es gratuita y, en lo personal me parece, es fácil de usar y configurar es VirtualBox de Sun Microsystems.

Creación de Reportes con JasperRepots y iReports - Parte 7: Subreportes

Visita la parte 1 de este tutorial: Reportes con Conexión a Bases de Datos
Visita la parte 2 de este tutorial: Usando DataSources Personalizados
Visita la parte 3 de este tutorial: Parámetros y Variables
Visita la parte 4 de este tutorial: Reportes en aplicaciones web
Visita la parte 5 de este tutorial: Gráficas en Reportes
Visita la parte 6 de este tutorial: Grupos

Los subreportes son una característica importante de una herramienta generadora de reportes. Permiten crear reportes más complejos y simplificar el trabajo de diseño.

Los subreportes son muy útiles cuando se crea un reporte maestro de detalles o cuando la estructura de un solo reporte no es suficiente para describir la complejidad del documento de salida deseado.

Un subreporte es solamente un reporte que ha sido incorporado a otro reporte. De hecho podemos tener subreportes dentro de otros subreportes.

En este último tutorial de la serie de JasperReports y iReports veremos cómo crear subreportes haciendo uso de estas dos herramientas. Veremos dos ejemplos, el primero mostrará cómo hacer los subreportes mediante una conexión JDBC a la base de datos. El segundo mostrará como hacerlo con un DataSource propio.

En ambos casos crearemos un reporte de alumnos de una escuela y subreportes de cada uno de los alumnos con la lista de materias que tiene cada uno (aunque por facilidad todos tendrán las mismas materias cuando hagamos el ejemplo con el DataSource propio).