Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Creación de Reportes Con JasperRepots y Ireports
Creación de Reportes Con JasperRepots y Ireports
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)
En este primer post veremos cómo 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 su página oficial. Usando el conector para Java
versión5.1.13 que pueden descargar desde la página de MySQL. Pero cualquier base de
datos que les guste funcionará para nuestros ejemplos.
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
participante
insert 1'); into
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
participante
insert 2'); into
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
participante
insert 3'); into
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
insert into
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
participante 7');
insert into
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
participante 8');
insert into
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
participante
insert 9'); into
'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS')
Ahora que tenemos nuestros datos crearemos un "datasource" en iReport para poder
acceder a nuestros datos y hacer pruebas directamente, sin necesidad de una aplicación Java
(por el momento). Para crear este datasource hacemos clic en el ícono "Report
Datasources" ubicado en la barra de herramientas de iReport:
Ahora pasaremos a crear nuestro nuevo reporte. Esta será la primer y única ocasión en la que
haremos uso del "Report Wizard" para ayudarnos a generar el reporte. Para esto vamos al
menú "File -> New...". Con esto se abrirá la ventana de "New File" en la que
seleccionaremos el formato de nuestro reporte. En mi caso seleccionaré la plantilla "Wood"
aunque pueden seleccionar la que ustedes deseen, y hacemos clic en el botón "Launch
Report Wizard"
Este wizard nos ayudará a crear un reporte 100% funcional en 6 pasos (en realidad 5 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:
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á.
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 clic 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 nosotros seleccionamos el datasource
"Conexion MySQL Pruebas" (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, efectivamente, 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:
Nosotros haremos uso del diseñador de consultas. Hacemos clic en el botón "Design query"
con lo que se abrirá una nueva ventana que está dividida en tres secciones.
La consulta que haremos será para obtener todos los datos de la tabla "participantes", con
excepción del "ID". Para esto hacemos doble clic 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 clic 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 clic 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 clic 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 clic en el
botón "Next".
El último paso es el solamente una felicitación por haber creado un nuevo reporte ^-^.
Ahora hacemos clic 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.
Tenemos una base de datos poblada (esto es muy importante, ya que si no tiene
datos obtendremos un mensaje de error).
Tenemos un datasource 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.
Si queremos compilar nuestro reporte de forma manual podemos hacer clic en el botón
"Compile Report" de la vista de diseño:
Haremos algunas modificaciones para que este reporte se vea un poco mejor: primero
cambiaremos el título que dice "Wood Title" por "Reporte de Participantes",
cambiamos el color de texto a negro, y eliminamos el fondo y el subtitulo que tiene.
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.
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 fue colocado por el wizard no lo
explicaré hasta el siguiente post, por ahora solo confíen 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 clic 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".
Hacemos clic 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.
Con esto se abrirá la ventana del "Library Manager". En esta ventana hacemos clic 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".
jasperreports-3.7.6.jar
jasperreports-3.7.6-javaflow.jar
jasperreports-fonts-3.7.6.jar
commons-beanutils-1.8.0.jar
commons-collections-2.1.1.jar
commons-digester-1.7.jar
commons-logging-1.0.4.jar
commons-javaflow-20060411.jar
groovy-all-1.7.5.jar
iText-2.1.7.jar
png-encoder-1.5.jar
poi-3.6.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 clic en el botón "Add Jar/Folder" y con esto tendremos lista nuestra biblioteca
"JasperReports" para agregarla a nuestro proyecto.
Ahora hacemos clic 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..."
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).
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/pruebareport
Nota: No olviden agregar el jar del driver de MySQL que bajamos anteriormente (mysql-connector-
java-5.1.13-bin.jar) al proyecto al nodo "Libraries" de la ventana "Project" usando la opción
"Add JAR/Folder" o también pueden agregar la biblioteca "MySQL JDBC Driver" que ya trae incluido
el NetBeans, de la misma forma que agregamos la de JasperReports.
Seguramente en este momento el NetBeans les está marcando un error en estas dos líneas
que hemos agregado. Esto es porque 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 usaré) es agregar la clausula throws Exception en el métodomain:
Class.forName("com.mysql.jdbc.Driver");
Connection conexion =
DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebareport
run:
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
este reporte con los datos que obtendrá de la base de datos. Para esto usamos la clase
"net.sf.jasperreports.engine.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):
conexion);
Pasamos "null" como segundo parámetro porque no estamos pasando ningún parámetro al
reporte (esto también lo veremos después).
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 "net.sf.jasperreports.view.JasperViewer", el cual es un
componente swing, y agregar este último a un panel.
PDF
HTML
CSV
RTF
TXT
XLS
XML
XLSX
DOCX
PPTX
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
"net.sf.jasperreports.engine.export.JRPdfExporter" y lo asignamos a nuestra
referencia exporter:
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 objeto "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.
Si ahora ejecutamos nuestra aplicación veremos que en el directorio raíz del proyecto se ha
creado un archivo llamado "reportePDF.pdf":
Ahora, para que nuestro reporte sea exportado a formato HTML cambiamos la línea:
por
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: net.sf.jasperreports.engine.exportJRPdfExporter
HTML: net.sf.jasperreports.engine.exportJRHtmlExporter
CSV: net.sf.jasperreports.engine.exportJRCsvExporter
RTF: net.sf.jasperreports.engine.exportJRRtfExporter
XLS: net.sf.jasperreports.engine.exportJRXlsExporter
XML: net.sf.jasperreports.engine.exportJRXmlExporter
TXT: net.sf.jasperreports.engine.exportJRTextExporter
XLSX: net.sf.jasperreports.engine.export.ooxml.JRXlsxExporter
DOCX: net.sf.jasperreports.engine.export.ooxml.JRDocxExporter
PPTX: net.sf.jasperreports.engine.export.ooxml.JRPptxExporter
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
exporter.setParameter(JRExporterParameter.JASPER_PRINT,
jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new
java.io.File("reportePDF.pdf"));
exporter.exportReport();
}
}