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.

Lo primero que haremos es bajar el JasperReports y iRepot. Este

último lo usaremos en su faceta de aplicación standalone y no como
plugin para NetBeans. Esto por aquellos que nos les guste usar el
NetBeans y además porque parece que en la versión actual de este
plugin existe un problema en la instalación.

Como ya habia dicho: La última versión de iReport está basada en el

NetBeans por lo que, como puden observar en la imagen siguiente,
las interfaces de ambos son muy parecidas.

En este primer post veremos como crear reportes haciendo uso de

una conexión a la base de datos directamente desde nuestro reporte.

Lo primero que haremos es crear una base de datos con tablas y

datos de pruebas para poder tener algo interesante que ver en
nuestros reportes. En este caso usaré MySQL versión 5.1, el cual
pueden descargar desde aquí. Usando el conector para Java versión
5.1.7 que pueden descargar desde aquí. Pero cualquier base de datos
que les guste funcionará para nuestros ejemplos.

La base de datos que usaré se llama "pruebaReportes" y contiene la

tabla "participantes". Este es el script para la creación de esta
tabla:
 CREATE TABLE `participantes` (
`ID` bigint(21) NOT NULL,
`NOMBRE` varchar(100) NOT NULL,
`USERNAME` varchar(100) NOT NULL,
`PASSWORD` varchar(100) NOT NULL,
`COMENTARIOS` varchar(100) default NULL,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Y este es el script para poblar la tabla anterior (creo que aquí no se

ve completo, pero si lo seleccionan pueden copiar el código
completo):

insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (1,'Participante 1','par1user','part1pass','comentarios
participante 1');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (2,'Participante 2','par2user','part2pass','comentarios
participante 2');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (3,'Participante 3','par3user','part3pass','comentarios
participante 3');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (4,'Participante 4','par4user','part4pass','comentarios
respecto al participante 4');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (5,'Participante 5','par5user','part5pass','sin comentarios
para el participante 5');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (6,'Participante 6','par6user','part6pass',NULL);
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (7,'Participante 7','par7user','part7pass','comentatios
participante 7');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (8,'Participante 8','par8user','part8pass','comentarios
participante 8');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (9,'Participante 9','par9user','part9pass','comentarios
participante 9');
insert into
`participantes`(`ID`,`NOMBRE`,`USERNAME`,`PASSWORD`,`COMENTARIOS`)
values (10,'Participante 10','par10user','part10pass',NULL);

Ahora que tenemos nuestros datos crearemos un "datasource" en

iReport para poder accesar a nuestros datos y hacer pruebas
directamente, sin necesidad de una aplicación Java (por el momento).
Para crear este datasource nos dirigimos al iReport y abrimos el
menú "Tools -> Report Datasources".

Con lo que se abrirá la ventana de "Connections / Datasources"

que en este momento debe contener solo un "Empty datasource".
Ahora hacemos click en el botón "New" para crear nuestro nuevo
datasource.
En la nueva ventana que se abre seleccionamos "Database JDBC
connection" y presionamos el botón "Next". En la siguiente ventana
debemos proporcionar algunos datos como el nombre se le dará al
datasource y los datos para realizar la conexión de la base de datos.
Después de llenar estos datos su ventana debe haber quedado más o
menos como la siguiente (recuerden usar el "JDBC Driver" que
corresponda al manejador de base de datos que estén usando:

Antes de guardar esta configuración hagan click en el botón "Test"

para probar que todos los datos proporcionados son correctos.

Si todo ha salido bien, al hacer click en el botón "Save" la ventana

actual debe cerrarse y nuestro datasource debe estar ahora en la
ventana "Connections / Datasources".

Ahora pasaremos a crear nuestro nuevo reporte. Esta será la primer

y unica ocasión en la que haremos uso del "Report Wizard" para
ayudarnos a generar el reporte. Para esto vamos al menú "File ->
Report Wizard".

Este wizard nos ayudará a crear un reporte 100% funcional en 7

pasos (en realidad 6 ya que empezamos directamente en el paso 2)
que podremos ver desde el mismo iReport sin necesidad de escribir
una solo línea de código Java. Estos 7 pasos son:

1. Selección del template del reporte (de forma

automática).
2. Selección de la ubicación en la que se guardará nuestro
reporte.
3. Selección del datasource e introducción del query para
obtener los datos que nos interesan.
4. Selección de los datos que queremos mostrar en el
reporte.
5. Creación de grupos para el reporte (se explicará en un
post posterior).
 6. Selección del layout o acomodo de los datos en el
reporte
7. Felicitación por tenerminar nuestro reporte =D.
Los pasos interesantes son el 3 y el 4, así que será en estos en los
que nos enfocaremos más.

El paso 1 se realiza de forma automática, así que no tenemos mucho

que hacer en él. En el paso 2 (en donde comenzamos) seleccionamos
el directorio en el que queremos guardar nuestro reporte y el nombre
que tendrá. En mi caso el nombre será "primerReporte".

Nota: La extensión de documentos de reportes generados por JasperReports es .jrxml

que significa "jasper reports xml", y es un documento xml que contiene los datos para
generar un archivo compilado (.jasper) que es el que usaremos principalmente en
nuestras aplicaciones Java (aunque también podriamos optar por compilar nuestro
archivo .jrxml desde la misma aplicación Java y así generar el archivo .jasper
correspondiente).

En este momento no importa mucho en donde guardemos el archivo

que se generará, ya que posteriormente tendremos que moverlo para
que nuestra aplicación java pueda encontrarlo. Por mi parte llamaré
al archivo "reporte1".

Hacemos click en el botón "Next" para continuar con el paso 3. En

este paso debemos seleccionar el datasource desde el que los datos
del reporte serán tomados. Por default está seleccionado el "Empty
datasource". Así que nosostros seleccionamos el datasource
"Conexion MySQL pruebareportes" (el datasource que creamos
anteriormente).

Al hacer el cambio del datasource veremos que aparece un textarea

con el título "Query(SQL)" y en la parte inferior debemos tener un
mensaje de error que dice "Invalid query".
Esto ocurre porque, efectivamenete, en el textarea no tenemos una
consulta válida (de hecho no tenemos ninguna). Por lo que ahora
corregiremos eso. Para esto tenemos 3 opciones:

1. Escribir una consulta nosotros mismos de forma directa.

2. Cargar una consulta que tengamos guardada en algún
archivo .sql o .txt.
3. Crear una consulta usando el "diseñador de
consultas".
Nosotros haremos uso del diseñador de consultas. Hacemos click en
el botón "Design query" con lo que se abrirá una nueva ventana que
está dividida en tres secciones.

La primer sección es la de la estructura de la consulta. Aquí

básicamente podremos cambiar entre las sentencias que estamos
editando (SELECT, WHERE, ORDER BY, etc.). La segunda sección es la
de los elementos de nuestra base de datos (tablas, vistas, y
temporales locales). Aquí podremos seleccionar los elementos de los
que queremos obtener datos para la consulta. Finalmente la tercer
sección nos muestra los elementos que hemos seleccionado de la
segunda sección para que podamos seleccionar los datos a obtener.

La consulta que haremos será para obtener todos los datos de la

tabla "participantes", con excepción del "ID". Para esto hacemos
doble click sobre el nombre de la tabla "participantes" en la
segunda sección de la ventana que tenemos abierta. Con esto
aparecerá en la tercer sección otra ventana con el título
"participantes" y un conjunto de checkboxes, cada uno con un
campo de nuestra tabla. Para generar la consulta que nos interesa
solamente seleccionamos todos los checkboxes (con excepción del
ID) y veremos que la consulta se genera en la primer sección. Ya solo
damos click en el botón "OK".

Con esto ya tendremos nuestra consulta en el textarea

correspondiente y podemos continuar con el paso 4, para lo que
hacemos click en el botón "Next".

En este paso solo tenemos que seleccionar cuáles campos del query
generado en el paso anterior queremos que se muestren en el
reporte. Como nosotros queremos que se muestren todos pasamos
todos los campos del lado izquierdo al lado derecho y hacemos click
en el botón "Next".
Ahora en el paso 5 debemos seleccionar cómo queremos que los
datos sean agrupados. Esto lo explicaré en algún otro post, pero por
el momento dejemos todo en blanco y demos click en el botón
"Next".

En el paso 6 tenemos que seleccionar el layout o acomodo de

nuestros datos. Por default solo tenemos 2: Columnar y Tabular.
Seleccionen el que más les agrade. En mi caso seleccionaré el
"Tabular Layout". Hacemos click en el botón "Next" para ir al último
paso.

El último paso es el solamente una fecilitación por haber creado un

nuevo reporte ^-^.

Ahora hacemos click en el botón "Finish" y ya podremos ver la

plantilla de nuestro reporte.

Si queremos ver como se

verá el reporte final, en este caso, podemos ver un preview con los
datos reales si cambiamos a la vista de preview en la ventana del
editor.

En este caso el repote puede ser previsualizado por que las siguientes
condiciones se cumplen:

Tenemos una base de datos poblada.

Tenemos un data source configurado para esta base de
datos.
Nuestro reporte hace una consulta directa a esta base de
datos a través del datasource anterior.
El reporte está preparado para mostrar los datos
recuperados anteriormente.
Como veremos en los siguientes posts, podría ser que no todas estas
condiciones se cumplan al mismo tiempo, por lo que tendremos
problemas para ver los datos en el preview del reporte.

Algo importante que ocurre al hacer este preview es que el reporte se

compila generando el archivo "reporte1.jasper" el cual es el archivo
que usaremos desde la aplicación Java que crearemos en un
momento.

Nota: Hasta ahora esta es la única forma que he encontrado para compilar
los reportes. Si alguien conoce otra forma por favor avisenme.

Haremos algunas modificaciones para que este reporte se vea un

poco mejor: Primero cambiaremos el título que dice "Classic
template" por "Reporte de Participantes". Además cambiamos el
título de cada una de las columnas por algo más claro. Por ejemplo,
podemos cambiar el título de la columna "participantes_USERNAME"
a "Usuario", "participantes_NOMBRE" a "Nombre", etc.

Al final mi reporte quedó de esta forma:

con este preview:

Ahora que tenemos un reporte que nos agrada (o al menos que no se

ve tan mal) veremos cómo generar este reporte desde una aplicación
Java.

Nota: Hay algunas notaciones usadas en la plantilla del reporte que tal vez
no comprendan como $F{participantes_USERNAME} y
$V{PAGE_NUMBER}. Esta es una sintaxis especial que usa JasperReports
para definir campos de objetos y variables, respectivamente. Existe otro
tipo de dato que se usa llamado propiedades ($P{propiedad}). Como todo
esto fué colocado por el wizard no lo explicaré hasta el siguiente post, por
ahora solo confien en que deben estar ahí.

Lo primero que haremos es crear un nuevo proyecto en NetBeans.

Para esto vamos al menú "File -> new Project...". En la ventana
de nuevos proyectos seleccionamos la categoría "Java" y de tipo de
proyecto seleccionamos "Java Application" y hacemos click en el
botón "Next". En la siguiente ventana introducimos el nombre de
nuestro proyecto y dejamos seleccionada la opción "Create Main
Class" y "Set as Main Project".
Hamos click en el botón "Finish" para que nuestro proyecto se
genere. Lo que haremos a continuación es crear una biblioteca que
contenga los archivos jars básicos necesarios de JasperReports. De
esta forma no tendremos que agregar cada uno de los jars cada vez
que necesitemos usar JasperReports en un proyecto. Además si
actualizamos la versión del API que usamos, solo debemos actualizar
esta biblioteca.

Para crear nuestra biblioteca vamos al menú "Tools -> Libraries"

Con esto se abrirá la ventana del "Library Manager". En esta

ventana hacemos click en el botón "New Library".
En la ventana que se abre escribimos el nombre de la nueva
biblioteca (en mi caso será "JasperReports") y en el tipo de la
biblioteca seleccionamos la opción "Class Libraries".

Al hacer click en el botón "OK" regresaremos al "Library Manager" y

tendremos nuestra nueva biblioteca creada. Pero aún nos hace falta
agregar los archivos jars que conformarán esta biblioteca. Nos
aseguramos que la pestaña "Classpath" esté seleccionada y
hacemos click en el botón "Add Jar/Folder" situado a la derecha. Se
abrirá un cuadro de dialogo para que seleccionemos los jars que
queremos agregar.
Navegamos hasta el directorio en el que tenemos los jars de
JasperReports que bajamos anteriormente. Para que los ejemplos que
haremos más adelante (en los siguientes posts) funcionen, debemos
agregar a la biblioteca los siguientes jars:

jasperreports-3.1.3.jar
jasperreports-3.1.3-javaflow.jar
commons-beanutils-1.7.jar
commons-collections-2.1v
commons-digester-1.7.jar
commons-javaflow-20060411.jar
iText-2.1.0.jar
png-encoder-1.5.jar
poi-3.2-FINAL-20081019.jar
Algunos de estos jars se encuentran en el directorio dist y otros en
el directorio lib del archivo .zip de JasperRepots que bajamos
anteriormente.

Hacemos click en el botón "Add Jar/Folder" y con esto tendremos

lista nuestra biblioteca "JasperReports" para agregarla a nuestro
proyecto.

Hacemos click en el botón "OK" para regresar al ambiente de trabajo.

Ahora hacemos click derecho en el nodo "Libraries" de la ventana

"Projects". Con esto se abrirá un menú contextual con 4 opciones,
seleccionamos la opción "Add Library..."

En la ventana que se abre seleccionamos la biblioteca que creamos

anteriormente ("JasperReports") y hacemos click en el botón "Add
Library". Al hacer esto veremos se agregar al nodo "Libraries" de
nuestro proyecto todos los jars que tiene nuestra biblioteca.

Nota: Si no crearon la biblioteca como se indica en pasos anteriores pueden agregar

cada uno de los jars manualmente seleccionando la opción "Add JAR/Folder..." del menú
contextual
¿Recuerdan que cuando vimos el preview del reporte que creamos en
iReports se generó un archivo "reporte1.jasper"? Tomamos este
archivo y lo colocamos en el directorio raíz del proyecto de NetBeans
que acabamos de crear (la raíz del proyecto es el directorio en el que
se encuentran los subdirectorios "nbproject", "src", entre otros).

Ahora veremos el código para

generar el reporte en varios formatos.

Lo primero es crear una conexión a la base de datos que creamos

anteriormente. Si no saben cómo crear una conexión JDBC desde
Java pueden ver este artículo. Si recuerdan nuestra base de datos se
llama "pruebareportes". Por lo que el código para generar la
conexión en el siguiente:

Class.forName("com.mysql.jdbc.Driver"); Connection conexion =

DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebareporte
s", "usuario", "password");

Nota: No olviden agregar el jar del driver de MySQL que bajamos anteriormente (mysql-
connector-java-5.1.7-bin.jar) al proyecto al nodo "Libraries" de la ventana
"Project" usando la opción "Add JAR/Folder". Además de esto para que
JasperReports funcione correctamente hay que agregar un jar más, "commons-logging-
1.1.1.jar", que usa JasperReports internamente para el manejo de la bitácora.

Seguramente en este momento el NetBeans les está marcando un

error en estas dos líneas que hemos agregado. Esto es por que al
tratar de hacer la conexión es posible que ocurra un error, y por lo
tanto es posible que se lance una excepción de tipo
java.sql.SQLException. Para solucionar esto pueden hacer dos
cosas. La primera es rodear estas líneas (y las siguientes que
crearemos) en una clausula try/catch. La segunda opción (la que yo
usé) es agregar la clausula throws Exception en el método main.
Pueden probar que la conexión se realiza correctamente presionando
F6 o haciendo click en el botón "Run Main Project". Si la conexión
se realiza correctamente veremos el mensaje
run:
BUILD SUCCESSFUL (total time: 1 second)
en la ventana "Output". De lo contrario verán el error el en
stacktrace de la excepción que se lanzó. Una vez que la conexión se
realice exitosamente podremos proseguir con los pasos restantes.

Lo siguiente que debemos hacer es cargar el archivo .jasper generado

anteriormente y colocarlo en un objeto JasperReport. Para esto
hacemos uso de la clase de utilidad JRLoader:

JasperReport reporte = (JasperReport)

JRLoader.loadObject("reporte1.jasper");

Nota: Podemos cargar el archivo de esta forma gracias a que colocamos el archivo
"reporte1.jasper" en la raíz del proyecto. Si lo colocaron en otra ubicación será
necesario que pasen como parámetro al método loadObject la url absoluta en la que
se encuentré el archivo.

Ahora el objeto "reporte" contiene la definición del reporte, pero aún

hace falta que llenemos el reporte con los datos que obtendrá de la
base de datos. Para esto usamos la clase JasperFillManager. Esta
clase tiene un método estático (fillReport) que nos permite llenar
el reporte con datos obtenidos de distintas fuentes de datos (una de
estas fuentes es la sentencia SQL que escribimos al generar el
reporte con el wizard en iReports y la conexión que usaremos en un
momento, veremos qué otras fuentes de datos existen y cómo
usarlos en los siguientes posts). En este caso la fuente de datos es la
conexión directa a la base de datos que creamos anteriormente (el
objeto conexion):

JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null,

conexion);

Pasamos null como segundo parámetro por que no estamos pasando

ningún parámetro al reporte (esto también lo veremos después).

El objeto JasperPrint que obtenemos como resultado de la

invocación del método fillReport es la representación de nuestro
reporte (ahora con datos) que puedemos mandar a imprimir, mostrar
en pantalla (si estamos usando una aplicación swing o awt), o (como
en este caso) guardar en un archivo.

Si están haciendo una aplicación swing y quieren mostrar este

reporte directamente en un componente pueden pasar el objeto
JasperPrint que acabamos de crear como parámetro a un nuevo
objeto JasperViewer, el cual es un componente swing, y agregar
este último a un panel.

Para guardar este reporte a un archivo debemos usar un

"JRExporter". JRExporter es una interface, y las clases que la
implementan nos permiten generar el reporte en distintos formatos
de una forma sencilla. Veremos como generar los reportes en los
siguientes formatos:

PDF
HTML
CSV
RTF
TXT
XLS
XML
Primero declaramos una referencia a un objet de tipo JRExporter de
la siguiente forma:

JRExporter exporter =

Será esta referencia la que usaremos de ahora en adelante. Para que

nuestro reporte sea guardado en formato PDF creamos un objeto de
tipo JRPdfExporter y lo asignamos a nuestra referencia exporter:

JRExporter exporter = new JRPdfExporter();

Ahora, las siguientes líneas son comunes no importando el formato

en el que vaya a quedar nuestro reporte:

exporter.setParameter(JRExporterParameter.JASPER_PRINT,jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE,new
java.io.File("reportePDF.pdf"));
exporter.exportReport();

La primer línea asigna a nuestro exporter el jasperPrint (el

reporte con datos) que creamos anteriormente. La segunda línea le
dice al exporter cuál será el nombre del archivo generado (en este
caso "reportePDF.pdf"). Recuerden cambiar el nombre y la
extensión del archivo cada vez que cambiemos de formato.

La última línea es la que realiza el proceso de exportación.

Si ahora ejecutamos nuestra aplicación veremos que en el directorio

raíz del proyecto se ha creado un archivo llamado "reportePDF.pdf":

Con el siguiente contenido:

Por lo que nuestra prueba ha sido exitosa ^-^.

Ahora, para que nuestro reporte sea exportado a formato HTML

cambiamos la línea:

JRExporter exporter = new JRPdfExporter();

por

JRExporter exporter = new JRHtmlExporter();

y el nombre del archivo de "reportePDF.pdf" a "reporteHTML.html".

Al ejecutar nuevamente nuestra aplicación tendremos veremos que
se genera el archivo "reporteHTML.html" en el directorio raíz de la
aplicación:

Con el siguiente contenido:

Como pudimos ver, con un par de modificaciones pudimos hacer que
nuestro reporte se generara en un formato completamente distinto.
Con el resto de los formatos es igual de simple. Usamos las
siguientes clases para generar los reportes en los siguientes
formatos:

PDF -> JRPdfExporter

HTML -> JRHtmlExporter
CSV -> JRCsvExporter
RTF -> JRRtfExporter
XLS -> JRXlsExporter
XML -> JRXmlExporter
TXT -> JRTextExporter
Para generar archivos .txt tendrán que agregar además estas dos
líneas:

exporter.setParameter(JRTextExporterParameter.CHARACTER_WIDTH,
12);//text exporter
exporter.setParameter(JRTextExporterParameter.CHARACTER_HEIGHT,
12);//text exporter

Este es el código fuente final de la aplicación (perdón por lo

pequeño):

import java.sql.Connection;

import java.sql.DriverManager;

import net.sf.jasperreports.engine.JRExporter;

import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JasperFillManager;

import net.sf.jasperreports.engine.JasperPrint;

import net.sf.jasperreports.engine.JasperReport;

import net.sf.jasperreports.engine.export.JRPdfExporter;

import net.sf.jasperreports.engine.util.JRLoader;

/**

* @author Alex

* @version 1.0

* @date 12/02/2009

*/

public class Main

public static void main(String[] args) throws Exception

Class.forName("com.mysql.jdbc.Driver");

Connection conexion =

DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebareportes",

"usuario", "password");

JasperReport reporte = (JasperReport) JRLoader.loadObject("reporte1.jasper");

JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, conexion);

JRExporter exporter = new JRPdfExporter();

// JRExporter exporter = new JRHtmlExporter();

// JRExporter exporter = new JRCsvExporter();

// JRExporter exporter = new JRRtfExporter();

// JRExporter exporter = new JRTextExporter();

// JRExporter exporter = new JRXlsExporter();

// JRExporter exporter = new JRXmlExporter();

exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);

// exporter.setParameter(JRTextExporterParameter.CHARACTER_WIDTH, 12);//text

exporter

// exporter.setParameter(JRTextExporterParameter.CHARACTER_HEIGHT, 12);//text

exporter
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new

java.io.File("reportePDF.pdf"));

exporter.exportReport();

Espero que este post, aunque algo largo, les sea de mucha utilidad.
El los post siguientes ampliaré un poco la forma en la que es posible
trabajar con JasperRepots.