lunes, 21 de septiembre de 2009

Hibernate - Parte 7: HQL Primera Parte

Hibernate proporciona un lenguaje de consultas muy poderoso llamado "Hibernate Query Language" (HQL).

HQL es muy parecido al SQL estándar, con la diferencia de que es completamente orientado a objetos (usamos nombres de clases y sus atributos en lugar de nombres de tablas y columnas), por lo que podemos usar cosas como herencia, polimorfismo y asociaciones.

Nosotros escribimos las consultas en HQL y Hibernate se encarga de convertirlas al SQL usado por la base de datos con la que estemos trabajando y ejecutarla para realizar la operación indicada.

En este tutorial veremos cómo usar este lenguaje para hacer algunas consultas típicas dentro de nuestras aplicaciones para poder recuperar objetos simples, y arboles de objetos.

viernes, 18 de septiembre de 2009

Día del programados

Feliciades a todos los programadores que visitan este blog, aunque un poco tarde ^-^!.

El día doscientos cincuenta y seis de cada año, o en binario el 1111111, se celebra el "Día del Programador". Esta año cayó justamente el 13 de Septiembre

La celebreación fué propuesta por Valentine Balt, un empleado de Parallel Tecnologies, a prinicpios del 2002 el intentó hacer llegar una petición firmada al gobierno de de Rusia para que el día se reconozca como el dia oficial del Programador.

El día 24 de julio de 2009 el ministro de Comunicación e Informatización de Rusia, presentó un borrador de una decreto para fijar el día de Programador, así que el día 11 de septiembre de 2009, el presidente de Rusia Dmitry Medvedev firmó el decreto y el día del prorgamador quedó oficializado (al menos en Rusia).

Esta festividad tiene por motivo reconocer esfuerzo de todos los que nos dedicamos a esta noble profesión.

Las tradiciones de este día incluyen jugar viejos juegos de computadora, hacer pequeños programas inútiles, poner un nick alusivo en los distintos medios de chat, enviar mensajes de texto y emails con felicitaciones a nuestros conocidos que se desarrollen en esta área, comportarse de maneras tontas, editar la Wikipedia, jugar con computadoras viejas, etc.

El día número 256 resulta el 13 de septiembre, excepto en los años bisiestos, en los que cae el 12.

Así que feliciades a todos los programadores.

lunes, 24 de agosto de 2009

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.

domingo, 2 de agosto de 2009

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 ^-^).

viernes, 31 de julio de 2009

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.

domingo, 28 de junio de 2009

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

sábado, 27 de junio de 2009

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.

jueves, 4 de junio de 2009

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).

miércoles, 13 de mayo de 2009

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.

viernes, 1 de mayo de 2009

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.

domingo, 26 de abril de 2009

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.


sábado, 18 de abril de 2009

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).


viernes, 17 de abril de 2009

Creación de Reportes con JasperRepots y iReports - Parte 6: Grupos

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 7 de este tutorial: Subreportes

En el tutorial anterior vimos como usar grupos para generar la gráfica de los datos de un reporte. Es esa ocasión los grupos fueron un elemento secundario que usamos para auxiliarnos en la generación de dicha gráfica.

Ahora veremos cómo deben ser usados los grupos para, bueno, agrupar un conjunto de datos relacionados y mostrar estos grupos de forma clara en el reporte. Usaremos la misma idea del tutorial anterior, en la que se mostraron las ventas de las consolas de última generación (Wii, XBox 360, y PS3). Solo que en este caso mostraremos por cada consola el nombre de los jugadores que las han comprado, separados claramente de los que han comprado las otras consolas.


lunes, 13 de abril de 2009

Creación de Reportes con JasperRepots y iReports - Parte 5: Gráficas en Reportes

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 6 de este tutorial: Grupos
Visita la parte 7 de este tutorial: Subreportes

Algunas veces es más fácil entender la información cuando se nos presenta en una imagen. En el caso de los datos, cuando estamos haciendo comparaciones, lo más fácil es visualizarlos en una gráfica de barras o en una gráfica de pie o pastel. En este tutorial mostraré cómo podemos colocar gráficas en nuestros reportes para hacer comparaciones de un conjunto de datos.


jueves, 2 de abril de 2009

Creación de Reportes con JasperRepots y iReports - Parte 4: Reportes en Aplicaciones Web

Esta es la cuarta entrega de esta serie de tutoriales sobre JasperReports. En la primer parte, vimos cómo generar reportes haciendo uso de una conexión a base de datos como nuestro DataSource. Después, en la segunda parte, aprendimos a hacer esto mismo pero con un DataSource propio, lo que nos evita en tener las consultas SQL directamente en nuestro reporte y tener que pasarle posteriormente un objeto de tipo “java.sql.Connection”. Finalmente, en la tercer parte, vimos cómo hacer uso de parametros y variables para hacer nuestros reportes más dinámicos.

Ahora, en esta cuarta parte, veremos cómo hacer que un usuario pueda descargar o ver en su navegador estos reportes haciendo uso de Servlets y JSPs respectivamente.

lunes, 30 de marzo de 2009

Creación de Reportes con JasperRepots y iReports - Parte 3: Parámetros y Variables

En el tutorial anterior vimos como hacer uso de los Fields para indicar la posición dentro de nuestro reporte en la que deben quedar los valores que obtenemos de nuestra aplicación Java.

Ahora hablaré de los otros dos tipos de expresiones que proporciona JasperReports: Parameters y Variables. Y la forma en la que podemos usarlos para hacer más dinámicos nuestros reportes.

lunes, 2 de marzo de 2009

Creación de Reportes con JasperRepots y iReports - Parte 2: Uso de DataSources Personalizados

En el primer post de la serie de JasperReports hablé de cómo crear una biblioteca para trabajar con JasperReports y cómo crear un reporte en múltiples formatos. Además hicimos un ejemplo de creación de reportes usando una conexión JDBC directa a nuestra base de datos.

Ahora veremos cómo generar nuestros reportes sin hacer uso de una conexión. Esto puede ser muy útil en los casos en los que ya tengamos los datos en memoria y no necesitemos realizar una conexión a la base de datos; o en el caso en que, por alguna razón ajena a nosotros, no podamos obtener la conexión.

domingo, 8 de febrero de 2009

Creación de Reportes con JasperRepots y iReports - Parte 1: Reportes con Conexión a Base de Datos

En un post anterior hablé un poco de las ventajas que tenemos al crear reportes con el API JasperReports y la herramienta iReport.

Ahora veremos unos ejemplos de cómo usarlos en nuestras aplicaciones Java. Dividiré estos ejemplos en varios post dedicando cada uno a una forma muy particular de la creación de reportes.

Para estos ejemplos usaremos las últimas versiones de ambas herramientas (que en esta actualización son las 3.7.6)

domingo, 1 de febrero de 2009

Instalación de Plugins en NetBeans

Es importante para la fase de desarrollo que nuestro IDE nos de soporte para el tipo de aplicación que estemos haciendo (si estamos desarrollando una aplicación swing podamos ver cómo va quedando la interface de usuario sin necesidad de correrla, si hacemos una aplicación para móviles poder iniciar de forma automática un emulador y hacer el deploy de nuestra aplicación, si hacemos algo web poder levantar nuestro servidor y hacer el deploy y undeploy de la aplicación, etc.).

Cuando hablamos de cómo configurar el NetBeans para trabajar bajamos la versión básica del IDE y dijimos que bajaríamos otros paquetes o plugins conforme los fueramos necesitando. En este post enseñaré a instalar estos plugins y de paso enseñaré cómo configurar el Tomcat para trabajar con aplicaciones web.


miércoles, 28 de enero de 2009

Creación de Reportes con Múltiples Formatos usando JasperReports y iReport

Frecuente, o mejor dicho siempre, los clientes desean ver reportes sobre los datos que se generan en el sistema y, en ocasiones, se encuentran almacenados en nuestra base de datos.

Si han tenido que hacer reportes de 7 o más columnas sabrán que esto no es tan sencillo como muchos de nosotros podríamos pensar. Muchos desarrolladores me han comentado que es lo más fácil que hay ya que, a lo más, nos tardaremos media hora en "crear el query" para obtener los datos que necesitamos...

Si bien esto podría ser cierto en la mayoría de los casos, lo que no siempre es fácil es mapear estos datos a los objetos que vamos a usar y aún menos el formaterarlos de manera que nuestro reporte sea fácil de entender y le proporcione al cliente la suficiente información como para que este le sea de utilidad.

La cosa se complica cuando nos piden reportes en formatos distintos al texto plano o HTML (en el caso de los sistemas web) como por ejemplo PDF, CSV, XLS, RTF, etc., ya que estos formatos no son manejados de forma nativa por Java


domingo, 25 de enero de 2009

Configurando Nuestra Herramienta de Trabajo, el NetBeans

Como programadores nuestro objetivo es facilitarle la vida a alguien a través de nuestras aplicaciones. Para hacer esto de una forma más simple, debemos usar varias y variadas herramientas en cada una de las etapas del ciclo de vida de nuestra aplicación. En esta ocasión me enfocaré unicamente a la etapa de desarrollo. En algún otro post hablaré de las herramientas que pueden servir en las etapas de análisis, diseño, y pruebas.

Con Java solo es necesario que contemos con el compilador (javac) para crear una aplicación. Podemos escribir todo el código fuente de nuestra aplicación en un blog de notas, vi, o cualquier editor de texto simple que nos permita guardar nuestro archivo con la extensión .java.

Una vez que tenemos nuestro archivo solo hay que compilarlo con el comando javac de la siguiente forma:

javac [opciones] Archivo.java

Y listo!! Esto nos genera un archivo .class, el cual es nuestra aplicación.

Sin embargo, cuando tenemos proyectos de un tamaño mediano/grande el hacer uso de un bloc de notas y la línea de comandos para compilar no es lo más recomendable. Comenzamos a necesitar separar nuestra aplicación en varios archivos, cada uno conteniendo una o varias clases. Posteriormente dividimos estas clases en paquetes, y asignamos la responsabilidad de estos paquetes a uno o varios desarrolladores.

La cosa se complica cuando comenzamos a hacer pruebas de rendimiento, y calidad, arreglo de bugs, etc.


miércoles, 21 de enero de 2009

El Obligatorio Primer Post de Presentación

Saludos a todos. Este es el primer post obligatorio en el que explico quién soy y cuál será el futuro de este blog ^-^.

Primero que nada, soy un programador Java con algunos años de experiencia. A lo largo de esos años he "aprendido" a hacer uso de esta tecnología para resolver situaciones de muchos tipos. Desde sencillas aplicaciones de consola para la obtención de datos de rendimiento de sistemas, pasando por aplicaciones para tratamiento de imágenes y reconocimiento de patrones, sistemas web para la creación de comunidades virtuales, videojuegos, sistemas financieros, etc. Por la naturaleza de estos proyectos, he tenido que investigar, entender, probar, evaluar, y finalmente usar varias APIs para agregar funcionalidades a cada una de estas aplicaciones.

Sin embargo, me he dado cuenta de que, como a muchos otros les debe pasar, dejo de usar alguna de estas APIs y olvido cómo se usan o (como es también muy común) salen nuevas versiones de las APIs las cuales pueden ser incompatibles con versiones anteriores y/o la implementación de las mismas funcionalidades con respecto a versiones anteriores es distinta. Claro, recuerdo los detalles básicos de su uso, pero cuando es tiempo de re-implementar esas funcionalidades en otros proyectos hay veces que nos es suficiente con ver el código que dejamos. Necesitamos regresar a la fuente original de la cual obtuvimos el conocimiento para volver a entender su uso. Claro, esto también presenta otros problemas como puede ser el hecho de que la página haya dejado de existir, o que no estén manejando la versión que necesitamos del API.

Es por eso que pretendo que este blog sea una fuente de conocimiento para todos aquellos programadores Java de habla hispana que desean aprender a hacer uso de estas APIs (y de paso me servirá a mi como libreta de apuntes para recordar cómo hacer las cosas).

También publicaré cosas como configuración de servidores (para los amantes de JEE), interacción entre los mismos, etc. No pretendo tocar temas demasiado básicos, a menos que alguien me pida algún tema particular, ni tampoco escribir de forma muy constante.

Además, me encuentro trabajando el algunos proyectos de videojuegos con un lenguaje distinto de Java, ActionScript 3, así que de vez en cuando publicaré algunos post sobre este tema.

Siéntanse en la libertad de dejar sus comentarios, que siempre serán bien recibidos.