La Preeminencia Corte

La preeminencia
JasperReport & Ireport

Autor:
José Luis Ayerdis Espinoza
Índice de contenido
Requisitos para comprender y practicar........................................................................4
Convenciones................................................................................................................4
Los códigos..............................................................................................................4
La consola de comandos..........................................................................................5
Tablas de descripcion ..............................................................................................5
Notas o Referencias..................................................................................................5
Errata.............................................................................................................................5
I. Introducción a JasperReport...........................................................................................6
Breve Historia...............................................................................................................6
¿Que es JasperReport?..................................................................................................6
Características...............................................................................................................7
Posicionamiento de elementos flexibles..................................................................7
Múltiples maneras de presentar datos......................................................................7
Múltiples fuentes de datos........................................................................................7
Soporte a subreportes...............................................................................................8
Capacidad de exportación .......................................................................................8
Obtener JasperReport....................................................................................................8
Construcción de las fuentes(sources) con Ant.........................................................8
Formatos soportados...................................................................................................10
Donde Conseguir Soporte...........................................................................................11
Resumen de Capitulo..................................................................................................11
II. Comenzando JasperReport..........................................................................................12
Configurando todo......................................................................................................12
Plantilla de Reporte JRXML ......................................................................................13
¿Que es JRXML?...................................................................................................13
Estructura de una plantilla......................................................................................13
Previsualizando diseño de plantilla JRXML...............................................................14
Creando binario a partir de plantilla (.jasper).............................................................16
Compilando plantilla con programaticamente.......................................................16
Previsualizando el precompilado con ant...............................................................18
Compilando plantilla con Ant................................................................................19
Rellenar el reporte (filling).........................................................................................21
Visualización del reporte............................................................................................23
Durante el capitulo anterior aprendimos detalles fundamentales para la utilizacion de
JasperReport, estos seran de vital importancia en los capitulos subsiguientes,
terminologias y usos particularmente de ant. Algunos puntos fundamentales:..........24
III. Estructura de Reportes...............................................................................................25
Elementos de Reportes(tags).......................................................................................25
Propepiedades ( <property> ): ..............................................................................25
Importacines ( <import> ): ...................................................................................25
Parametros ( <parameter> ): .................................................................................26
Cadena de consulta( <queryString> ): ..................................................................26
Campos( <field> ): ...............................................................................................26
Variables( <variable> ): .......................................................................................26
Bandas de Reportes.....................................................................................................26
Background............................................................................................................26
Title........................................................................................................................27
Page Header...........................................................................................................27
Column Header......................................................................................................28
Report Detail..........................................................................................................28
Column Footer.......................................................................................................28
Page Footer.............................................................................................................29
Last Page Footer.....................................................................................................29
Summary................................................................................................................29
Practicas de elementos con Ireport.............................................................................30
¿Que es Ireport?.....................................................................................................30
Ireport 3.0, creando reportes..................................................................................30
Estudiando JRXML generado por Ireport..............................................................34
Proceso de creacion de un reporte..............................................................................35
Vistazo JasperReport API...........................................................................................36
JasperDesign..........................................................................................................36
JasperCompileManager..........................................................................................36
JasperReport...........................................................................................................36
JasperPrint..............................................................................................................37
JasperFillManager..................................................................................................37
JasperPrintManager................................................................................................37
JasperExportManager.............................................................................................37
IV. Reportes dinámicos, con fuentes de datos JDBC......................................................38
Fuentes de Datos.........................................................................................................39
Tipos ......................................................................................................................39
Ventajas..................................................................................................................40
Crear Fuentes de Datos JDBC....................................................................................40
Fuentes de datos JDBC ¿que sucede?........................................................................44
Creacion de Reportes Dinamicos: Uso de la fuente de datos.....................................45
Filtros.....................................................................................................................50
Ordenar...................................................................................................................53
Invocar Reporte Dinamico desde Java........................................................................54
Pregunta Bonus: ¿Como cambiar propiedades reporte desde java?..........................55
V. Reportes: diseño y propiedades utiles.........................................................................57
Estilos personalizados.................................................................................................57
Agrupaciones de Reportes..........................................................................................59
Parametros ..................................................................................................................61
Parametros no modificables (NonModifiable )....................................................61
Parametros modificables (Modifiable)...................................................................62
Utilizar parametros dentro de consultas.................................................................64
Variables.....................................................................................................................65
Variables no modificables (NonModifiable)........................................................65
Variables modificables (Modifiable).....................................................................65
Utilizar Variables en Reportes...............................................................................66
Uso de parametros con Java........................................................................................67
Bonus: Como colocar Imagenes con Blob (como flujos de bytes).............................68
Crosstabs.....................................................................................................................68
Prefacio
Requisitos para comprender y practicar.
Es necesario que el lector tenga conocimiento medio de J2SE 5,

familiarizacion con MySQL 5.x*, conocimiento basico documentos XML
y basico entendimiento de ant como herramienta de compilacion.
Para realizar los ejemplos es requisito tener configurado apropiadamente

versiones por encima de JDK 1.5, iReport 3.x, y ANT 1.6.
Tambien para los capitulos X, Y y Z se debe estar familiarizado con

Framework como JPA, Hibernate u TopLink, ademas de cierto
conocimientos en JSP para nuestro sitio Web para incorporarlos a los
mismos, sin embargo si ud no tiene experiencia Web tambien se discute
basado en una aplicacion Desktop la incorporacion de reportes.
Convenciones
En este documento ud observara distintos estilos de textos, todos tienen un
proposito especifico para que le preste particular atencion.
Los códigos
package com.org.report;
import java.util.HashMap;
import net.sf.jasperreports.engine.JREmptyDataSource;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
Codigos con bloques relevantes, prestar mayor atencion a las negrillas para
orientarse mejor:
<title>
<band height="50">
<textField>
<reportElement x="0" y="0" width="200" height="50" />
<textFieldExpression
class="java.lang.String">$P{Title}</textFieldExpression>
</textField>
</band>
*Es posible usar cualquiera pero recomendamos mysql por su facilidad

</title>
La consola de comandos
~$ ant -help
Tambien terminos importantes son resaltados en el texto, que este

leyendo.
Tablas de descripcion
Método Descripción
nombredelMetodo() Breve descripción del metodo, resaltando
los warnings, o algo importante.
Fuente( Generalmente Traducida): URL, referencia, autor, etc.
Notas o Referencias
Para notas o referencias en particular se hara uso de una caja como esta!!!
Errata
Este documento esta propenso a errores, quizas si encuentra alguno con

respecto a semantica, ortografia y/o codigo, el autor estaria agradecido que
le reportara a joseayerdis@gmail.com.
I. Introducción a JasperReport
Breve Historia
El proyecto de JasperReport comenzó en 2001 por Teodor Danciu, cuando enfrento la
tarea de evaluación de reportes para un proyecto en el que trabajaba. La solución
existente que encontró era demasiado cara para el presupuesto, por ello decidió escribir
su propia herramienta de reportes. El proyecto por el cual el estaba evaluando los
reportes se cancelo; sin embargo el empezó a trabajar en JasperReport en su tiempo
libre y lo registro como un proyecto en SourceForge en septiembre del 2001. Poco
después empezó a recibir correos sobre potenciales interesados a pesar de no haber
liberado aun el código. La versión 0.1.5 fue liberada en Noviembre de 2001 desde
entonces su éxito se lo ha convertido en una de las herramientas de generación de
reportes mas populares de todas.
En Abril del 2005 JasperSoft formalmente patrocino el proyecto, la versión 1.0 fue
liberada en Julio de ese mismo ano, y originalmente se licencio como CopyLeft para
luego ser movido a GPL permitiendo incluir un paquete de productos mas amplio como
iReport Visual Designer para JasperReport. Entre productos derivados de JasperSoft
están JasperServer una aplicación web de Java que provee capacidad avanzada de servir
reportes con permisos.
Actualmente el proyecto ha crecido tanto que permite la incorporación múltiples

formatos de exportación como: PDF, CSV, HTML, etc. Incorporación a los IDE mas
importantes como NetBeans, Eclipse e incluso IBM Websphere Studio Application
Developer. Además de herramientas de terceros como:
● SWTJasperViewer que es un componente embebido reutilizable de cualquier

aplicación SWT/JFace como Eclipse IDE.
● WebReportBuilder, una aplicación J2EE web que permite a desarrolladores y
no desarrolladores crear reportes avanzados y básicos basados en un Servidor
Web de Reportes.
¿Que es JasperReport?
JasperReport es una librería de código abierto que permite la creación de reportes en
Java con facilidad de exportación a múltiples formatos. JasperReports es un contenido
de la prestación de biblioteca, no una aplicación independiente. Esta escrita en código
Java y es soportada por cualquier plataforma que soporte Java.
Toda su funcionalidad depende del Jar jasperreports-x.x.x.jar, a pesar de esto depende

de librerías de terceros para su correcta funcionalidad como por ejemplo para
transformaciones PDF o XLS. Esta diseñada propiamente para asistir a los
desarrolladores en la tarea de agregar capacidades de reportes a aplicaciones Java. No
es propia para usuarios finales. Y a pesar de que fue diseñada para agregar capacidad de
reportes vía Web por Servlet no tiene ninguna dependencia del API Servlet o cualquier
otra librería Java EE. Por ello no esta limitado a aplicaciones web.
JasperReport Requiere del Java Development Kit JDK 1.3 en adelante para compilarse
con éxito. Las versiones mas antiguas dependen de tools.jar en el Classpath que esta
incluido en el JDK y no en el JRE. Sin embargo las veriones 0.6.4, fue permisible
prescindir de tools.jar para implementar la aplicaciones.
Características
JasperReport tiene un sin numero de características que hacen que sea la librería de
generación de reportes mas completa de todas para Java. Entre las generales estan los
soportes para imágenes, flujos de datos (InputStream), gráficas y cuadros, estos ultimo
con la ayuda de JFreeChart. En resumen mencionamos las siguientes:
● Posicionamiento de elementos flexibles.
● Múltiples maneras de presentar datos.
● Proporciona múltiples formas de fuentes de datos.
● Soporte para subreportes.
● Exportación a una gran variedad de formatos comunes.
A continuacion se describen las características.
Posicionamiento de elementos flexibles.
JasperReport nos permite separar los datos en secciones opcionales del reporte, estas se
representan como bandas e incluyen las siguientes:
● Report Title(Titulo del Reporte): Esta aparece al tope del la pagina del
reporte.
● Page Header(Encabezado de pagina): aparece al tope de cada pagina.
● Detail Section(Seccion de detalle): contiene la informacion vital del reporte.
● Page footer(Pie de pagina): se posiciona al final de cada pagina del reporte.
● Sumary Section(Resumen): la cual aparece al final del reporte.
Múltiples maneras de presentar datos.
JasperReport provee la capacidad de presentar información de manera textual o gráfica.
Nos permite utilizar extensiones generadas para mostrar información dinámica.
Múltiples fuentes de datos.
JasperReport como tal provee además de un extenso soporte para multiples tipos de
conexiones JDBC, Hibernate, EJB o XML DataSource. Tambien da la oportunidad de
pasar informacion como parametros a traves de cualquier clase Java que lo requiera.
Soporte a subreportes
Entre las mas destacadas caracteristicas es la de subreportes, estos facilitan la creacion
de reportes con gran variedad de informacion que requieren informacion de multiples
fuentes de datos como los maestro detalles.
Capacidad de exportación
Una de las grandes riquezas de JasperReport es que se auxilia de otras librerías para
agregar utilidad, particularmente en la exportación de reportes a múltiples formatos (ver
formatos soportados mas abajo).
Obtener JasperReport
Al ser una librería la cual se auxilia de muchas otras para su extensión, como hemos
hablado, entonces mas que hablar de instalación, podríamos referirnos a como hacer
obtenerlo . Lo primero que haremos es dirigirnos a la pagina de descarga y descargamos
la ultima versión disponible del proyecto:
http://sourceforge.net/projects/jasperreports/
Imagen 1-1. Descarga de JasperReport 3.x desde Sourceforge.net
Ahora que tenemos el jasperreports-3.0.0.jar, ahora para usarlo haremos uso del
ClassPath, con la opcion -cp al compilar.
Construcción de las fuentes(sources) con Ant
Para los mas atrevidos, vamos a descargarnos desde la misma pagina del proyecto:
(http://sourceforge.net/projects/jasperreports/ )las fuentes(source) de JasperReport, para
compilarlas con Ant, este tambien tiene una serie de ejemplos con JasperReport.
Ant es una herramienta de compilacion, estas facilitan el proceso de compilar

(valga la redundancia), un proyecto que contiene multiples codigos, proyectos
como Netbean hacen uso de Ant para compilar el mismo, este hace uso de
un archivo XML llamado build.xml que contiene acciones de lo que se
compilara, si ud esta familiarizado con Make entonces le enontrara mas
sentido, si no puede visitar el sitio web ofical para ahondar en la materia:
http://ant.apache.org/
Una vez descargado el archivo jasperreports-project-3.0.0.tar.gz (tambien se puede
descargar el jasperreports-project-3.0.0.zip sin inconveniente),nos dirigimos a la
carpeta donde descomprimimos y encontraremos carpetas como:
Carpeta Descripcion
/build Donde se encuentra los .class del proyecto
compilado.
/src aquí estan las fuentes generalmente .java

de JasperReport.
/dist los .jar para la distribucion por ejemplo:

jasperreports-3.0.0.jar, tambien esta el
javadoc de la API del JasperReport.
/lib las librerias de las que dependen algunas

extensiones de JasperReport, como
jxl-2.6.jar, jfreechart-1.0.0.jar, etc
Escribimos en consola:
~$ ant -p
Imagen 1-2. Resultado del comando ant -p, muestra las opciones de compilacion.
Nos desplegara las opciones de compilación, para conseguir por ejemplo la
distribución, utilizamos el comando ant con la opcion de compilacion jar
~$ ant jar
Imagen 1-3. Resultado del comando ant jar, muestra como se compila el
jasperreport-3.0.0.jar, con ant.
Formatos soportados
JasperReport provee como una característica principal el soporte a gran variedad de

formatos comunes y portables. Además de tener su formato estándar que tiene extensión
jrprint, soporta los siguientes formatos:
● Potable Document File (PDF). ● Excel bajo XLS.
● Rich Text Format. ● OpenOffice con ODT.
● XML. ● HyperText Markup Language

(HTML).
● Valores separados por coma CSV. ● Texto plano.

Donde Conseguir Soporte
Al ser soportado por JasperSoft el soporte no debería ser difícil de encontrar, y a pesar
que tienen una comunidad de foros donde se puede dirigir para JasperReport o iReport,
no es tan efectivo y rápido como tendría que ser. Puede visitar:
http://jasperreports.sourceforge.net.
http://www.jaspersoft.org
Existe documentación en linea, pero es demasiado básica y sin contemplar característica
avanzadas de JasperReport. También puede optar por conseguir cualquiera de los
siguientes dos textos con los que el autor se auxilio para crear este documento:
● The Definitive Guide to JasperReport, Teodor Danciu and Lucian Chirita.
● JasperReports for Java Developers, David R, Heffelfinger.
(El auto no tiene ninguna relacion con los autores de los libros anteriores, ni con
editoriales, y/o afines).
Tambien puede consultarme directamente a joseayerdis@gmail.com.
Resumen de Capitulo
A lo largo del capitulo anterior logramos conocer:
Aspectos fundamentales de JasperReport, su inicio como proyecto libre y el impacto

que actualmente tiene siendo soportado por una solida empresa como JasperForge.
Definimos JasperReport sus características a nivel generales son: posicionamiento de

elementos flexibles, múltiples maneras de presentar datos, proporciona múltiples formas
de fuentes de datos, soporte para subreportes, exportación a una gran variedad de
formatos comunes.
Como obtener JasperReport, ya sea por medio de la pagina de sourceforge.net,

descargando directamente jasperreports-3.0.0.jar, o descargando las fuentes del
proyecto con jasperreports-project-3.0.0.tar.gz y compilándolas con ant
II. Comenzando JasperReport
Al finalizar el capitulo Ud podrá:
● Definir los conceptos teóricos y prácticos básicos para los archivos JRXML.
● Podrá saber que es Jasper, y las diferencias con los JRXML.
● Métodos de compilación con ant y clases de Java para JRXML.
● Previsualizar y Visualizar un reporte.
Es inevitable que en cualquier proceso de aprendizaje se comienza por pasos a

centímetros, el siguiente capitulo abordara los aspectos necesarios, “las bases” que nos
llevaran a la correcta creación de reportes. Para ello necesitaremos configurar nuestro
ambiente de trabajo, y las plataformas que se requieren para trabajar, luego
estudiaremos que es una plantilla de reporte JRXML, y como visualizarlos con ant.
También la compilación y vejecucion de los mismos. Empecemos!!!
Configurando todo
Para tener nuestro ambiente óptimo de trabajo nos auxiliaremos por momentos de
cualquier procesador de texto plano, en lo personal el auto utilizara la herramienta vim,
pero ud podrá hacer uso de la que mas se adapte a sus necesidades, si esta en ambiente
Win32 le recomendaría Notepad++ (http://notepad-plus.sourceforge.net/es/site.htm). Si
se preguntara si utilizaremos IDE, lo haremos en los próximos capítulos, y se explicara
como configurarlo para hacer uso de JasperReport y los Plugin que contienen para hacer
uso de iReport mas fácilmente.
● Crearemos una carpeta donde tengamos los ejemplos, le llamare cap2 (ud puede
crearla como guste).
● Ubicaremos la carpeta JasperReport compilada, dentro de una ubicación en
nuestro Disco duro. (En los ejemplos la ruta ubicada sera /usr/lib/jasperreport)
● Nos aseguramos de tener ant instalado.
● Escogemos un editor de texto y la consola lista y ahora manos a la obra.
A los usuarios de win32, a diferencia de sistemas GNU/Linux, Ant no viene

incluido dentro de su SO. Por tanto deberán configurarlo apropiadamente,
visita http://ant.apache.org/ para mas información.
Plantilla de Reporte JRXML
Antes de comenzar ha hablar acerca de las plantillas de reporte, definamos que es
JRXML.
¿Que es JRXML?
Es un formato basado en XML, esto significa que esta compuesto por etiquetas (tags),
bajo esta extensión se almacena la descripción de la plantillas de reportes, con
información que la librería utiliza para compilar el reporte y transformarlo en un
.jasper. Esta es la diferencia entre ambos formato, el primero(JRXML) debe ser
compilado en tiempo de ejecución y el segundo no, simplemente se visualiza. Esto es
similar al proceso de ant, para la compilación basado en un XML generalmente
build.xml. Si desea obtener información a profundidad sobre el DTD del formato puede
descargarlo directamente de http://jasperreports.sourceforge.net/dtds/jasperreport.dtd.
Sin embargo abordaremos durante todo el libro casi todos los rasgos de esta extensión
dado que se considera como la mas básica e importante al momento de crear reportes
con JasperReport.
Estructura de una plantilla
Siguiendo con la lógica del capitulo, tengamos presente que una plantilla es un
documento con extensión JRXML y que tienen una estructura estándar basada en el
DTD del mismo. JasperReport a través del formato JRXML sigue la siguiente estructura
del archivo PrimerPlantilla.jrxml:
<?xml version="1.0"?>
<!DOCTYPE jasperReport
PUBLIC "-//JasperReports//DTD Report Design//EN"
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport name="Plantilla">
<detail>
<band height="200">
<staticText>
<reportElement x="20" y="0" width="300" height="30"/>
<text><![CDATA[Este es un ejemplo de reportes con JasperReport
3.0]]></text>
</staticText>
</band>
</detail>
</jasperReport>
Como vera el codigo anterior no es complicado, lleva la estructura básica de un archivo

XML y algunas etiquetas definidas como detail, band, staticText, etc., Las cuales se
profundizaran a su debido tiempo.
Previsualizando diseño de plantilla JRXML
JasperReport también cuenta con un preview de la plantilla, para visualizar la posición
en donde se ubicaran los elementos, para el ejemplo del jrxml anterior, se crea un
build.xml, quien en conjunto con ant provee la opcion de JasperPreview. Procedemos
entonces a crear el siguiente archivo en la carpeta donde trabajamos el archivo anterior:
<project name="Primer preview de reporte" default="verDiseno"

basedir=".">
<description>Previsualizar la plantilla</description>

<property name="file.name" value="PrimerPlantilla"/>

<property name="jasper.dir" value="/usr/lib/jasperreport"/>

<property name="classes.dir" value="${jasper.dir}/build/classes"/>

<property name="lib.dir" value="${jasper.dir}/lib"/>
<path id="classpath">
<pathelement location="./"/>
<pathelement location="${classes.dir}"/>
<fileset dir="${lib.dir}">
<include name="**/*.jar"/>
</fileset>
</path>
<target name="verDiseno"
description="Cargando preview de la plantilla">

<java classname="net.sf.jasperreports.view.JasperDesignViewer"
fork="true">
<arg value="-F${file.name}.jrxml"/>
<classpath refid="classpath"/>
</java>
</target>
</project>
Ahora para previsualizar utilizamos ant, para instruir basados en el build.xml anterior.
Si se observa el valor del directorio de Jasper, es donde se tiene la carpeta descargada y
compilada. Tambien que se invoca PrimerPlantilla.jrxml, concatenando e nombre del
reporte con la extension, jrxml.
Ahora si bien, JasperReport como tal no posee una GUI de avanzada que ayude a
diseñar los reportes( es necesario auxiliarse de iReport). Sin embargo lo que si posee es
una clase basada en Swing llamada net.sf.jasperreports.view.JasperDesigner la cual
carga y despliega una plantilla como la antes creada.
Imagen 2-2. Para visualizar se digita ant, donde se guardo el build.xml.
El resultado de la previsualizacion seria esto:
Imagen 2-3. El resultado del comando ant, con la previsualizacion de la plantilla.
Es valido aclarar que JasperDesignViewer, tan solo presenta informacion que contenga
texto, como en este caso particular, pero no se espera ver recursos que tengan
operatividad con base de datos, en vez obtendrá la expresion de dicha fuente. (Lo
veremos mas adelante), esto es por que esta clase (JasperDesignViewer), no accede a
fuentes de datos o parametros del reporte.
Creando binario a partir de plantilla (.jasper)
Hasta ahora hemos visto el formato basico JRXML, que en realidad es un XML que
describe el reporte y el posicionamiento de sus elementos. Pero en realidad estos no
pueden ser usados directamente para visualizar un reporte es nada mas para crear la
estructura del mismo, es por esto que las plantillas (JRXML), son compiladas para
generar la vista final del mismo estos documentos se denominan Archivos Jasper, en
honor a la extension .jasper que contienen. Existen dos metodos para crear este
documento, como dijimos estos tienen que provenir de un JRMXL, la primera manera
es programaticamente, y la segunda es mediante la compilacion Ant.
Compilando plantilla con programaticamente
Este metodo es particularmente efectivo cuando se necesitan que el reporte sea
dinamico en tiempo de ejecucion pueda cambiar algunas particularidades del JRXML.
Se utlizan un metodo provista por las librerias de jasperreport, llamado
compileReportToFile.
Clase: net.sf.jasperreports.engine.JasperCompileManager
static String compileReportToFile(String Compila el diseño del reporte XML,
sourceFileName) especificado por el parámetro.
static void compileReportToFile(String Compila el diseño del reporte XML
sourceFileName, String destFileName) especificado en el
parámetro(sourceFileName), y coloca el
resultado del archivo especificado por el
segundo parámetro.
static void Compila el diseño del reporte recibiendo
compileReportToFile(JasperDesign un objeto de JasperDesign1 y colocando
jasperDesign, String destFileName) el .jasper en el segundo parametro de
destino.
Fuente(Traducida): http://jasperreports.sourceforge.net/api/net/sf/jasperreports/engine/
JasperCompileManager.html
1 JasperDesign es una clase que se utiliza como una representacion en memoriadel diseño, la cual puede
ser facilmente creada con el archivo JRXML o viceversa. Ver (http://jasperreports.sourceforge.net/api/
net/sf/jasperreports/engine/design/JasperDesign.html)
Para la compilación de cogido escribimos una clase Java que haga uso de
JasperCompileManager, similar a la siguiente:
//Importaciones
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperCompileManager;
public class CompileProgramaticly

{
public static void main(String... args)
{
try
{
System.out.println("Compilando el reporte");
//Invocamos al metodo estatico de la clase JasperCompileManager
JasperCompileManager.compileReportToFile("PrimerPlantilla.jrxml");
System.out.println("Terminado");
}
catch (JRException ex)
{
System.err.println("Opps Un error");
ex.printStackTrace();//imprimimos el stack
}
}
} //fin de la clase
Ahora compilamos el código anterior, en consola (Linux) seria un comando parecido al

siguiente.
~$ javacc -cp jasperreports-3.0.0.jar CompileProgramaticly.java
Recordemos que el -cp especifica algo adicional al classpath de java, en windows seria
algo parecido a lo siguiente:
C:\javac -cp .;jasperreports-3.0.0.jar CompileProgramaticly.java
Ahora utilizamos un comando parecido para correrlo:

~$ java -cp :jasperreports-3.0.0.jar:lib/* CompileProgramaticly
Algunas particularidades con el anterior es que se agrega lib/*, que son las
dependencias propias de jasperreport, como el Apache Digester, es una librería que
se utiliza para la creación de reglas a traves de XML. Las cuales se profundizan en los
capítulos X, XX, XXX.
Si todo esta, como debería entonces vera que se creo un archivo .jasper en directorio de
trabajo.
Imagen 2-4. Archivo jasper creado gracias a la compilación de JasperCompileManager

Previsualizando el precompilado con ant
Al igual que con el archivo jrxml, que se creo se podia visualizar las posiciones, etc.
Con las extensiones .jasper se puede utilizar un archivo XML para mostrar una vista de
diseño. En este caso nuestro target se llamara “viewDisenoCompilado” al final del
archivo build.xml quedara algo asi:

basedir=".">
JasperReport-->
lib-->
</fileset>
</path>
terminar ant-->
fork="true">
</java>
</target>
<target name="viewDisenoCompilado"
description="Lanza la aplicacion de previsualizar el diseño
compilado.">
fork="true">
<arg value="-F${file.name}.jasper"/>
</java>
</target>
</project>
Si nota el archivo que busca es .jasper y no .jrxml, por tanto se comprueba que los
.jasper también pueden ser previsualizado. Para ver como funciona digitemos en
consola con el target definido.
~$ ant viewDisenoCompilado
Compilando plantilla con Ant
Ant es una poderosa herramienta ampliamente usada con el manejo de JasperReport,

permite darnos ahorrarnos tarea de compilacion de reporte, y tambien la escritura de
codigo para hacerlo lo cual podria resultar mas facil. Sin embargo no significa que
nunca tengamos que escribiro compilar de manera programatica dado que al momento
de cambiar un reporte dinamicamente en tiempo de ejecucion (Runtime), es
particularmente util. Las tarea de ANT esta incluida en JasperReport y se conoce como
JRC, defnida en la clase net.sf.jasperreports.ant.JRAntCompileTask . Permite agregar
objetivos de terceros al build.xml e invocarl el JRC. Recordemos que editamos el
build.xml quedara algo asi:

basedir=".">
JasperReport-->
lib-->
</fileset>
</path>
<target name="compilar" description="Compila el Reporte XML y nos da
el .jasper">
<taskdef name="jrc"
classname="net.sf.jasperreports.ant.JRAntCompileTask">
</taskdef>
<jrc destdir=".">
<src><fileset dir=".">
<include name="**/*.jrxml"/>
</fileset>
</src>
</jrc>
</target>
terminar ant-->
fork="true">
</java>
</target>
<target name="viewDisenoCompilado"
description="Lanza la aplicacion de previsualizar el diseño
compilado.">
fork="true">
<arg value="-F${file.name}.jasper"/>
</java>
</target>
</project>
Lo ejecutamos con el comando

~$ ant viewDisenoCompilado
Buildfile: build.xml
compilar:
[jrc] Compiling 1 report design files.
[jrc] File : /home/necronet/Escritorio/lapreeminencia/preem/cap
2/plantillas/PrimerPlantilla.jrxml ... OK.
BUILD SUCCESSFUL
Total time: 2 seconds
Imagen 2-5. Compilacion de repotes con Ant genera un .jasper

Rellenar el reporte (filling)
En JasperReport los reportes necesitan de parametros auxiliares para funcionar, ya sean
creados por nosotros o simplemente sean parametros por defecto, asi como fuentes de
datos ampliamente utilizadas con conexiones de datos, para ello se utiliza
JRDataSource o un objeto Connection de JDBC. Sin embargo dado que el reporte es
simple, estatico y sin parametros adicionales. Para hacer el proceso de relleno
utilizamos una clase llama para invocar al metodo fillReportToFile, proveniente de la
clase JasperFillManager, el cual guarda un reporte rellenado en el disco duro.
Clase: net.sf.jasperreports.engine.JasperFillManager
static String fillReportToFile(String Rellena el diseño del reporte y lo carga a
sourceFileName, java.util.Map un archivo especifico. Y retorna el nombre
parameters) del archivo creado.
static String fillReportToFile(String Rellena el diseño del reporte y lo carga en
sourceFileName, java.util.Map un archivo, ademas utiliza connection
parameters, java.sql.Connection como fuente de datos y ejecutar consultas
connection) SQL. Y retorna el nombre del archivo
creado.
static String fillReportToFile(String Rellena el diseño del reporte y lo carga en
sourceFileName, java.util.Map un archivo, usa un JRDataSource como
parameters, JRDataSource dataSource ) fuente de datos. Y retorna el nombre del
archivo creado.
static void fillReportToFile(String Rellena el diseño del reporte y lo carga a
sourceFileName, String destFileName, un archivo especifico. Y lo coloca en el
java.util.Map parameters) archivo destino especificado
Fuente(Traducida): http://jasperreports.sourceforge.net/api/net/sf/jasperreports/engine/
JasperFillManager.html
Existen una variedad de metodos a utilizar puede ver mas informacion en el API oficial
de JasperReport.
A continuacion crearemos la clase Java que nos permitira rellenar el reporte:
import static java.lang.System.*;
import java.util.HashMap;
import net.sf.jasperreports.engine.*;
public class FillReportClass
{
public static void main(String... args)
{
try
{
out.println("Rellenando el reporte");
JasperFillManager.fillReportToFile("PrimerPlantilla.jasper",new
HashMap(), new JREmptyDataSource());
out.println("Rellenado con exito!!");
}
catch (JRException e)
{
err.println("Error JRException");
e.printStackTrace();
}
}
}
El codigo es bastante sencillo la linea mas importante es el relleno en el cual se pasa

como parametro el reporte compilado .jasper, un HashMap y una fuente vacia de datos
JREmptyDataSource dado que no requerimos ninguna conexión o consulta de datos
externamente. Para compilar el codigo puede hacer uso de este comando:
Compilar con:
~$ javacc -cp jasperreports-3.0.0.jar FillReportClass.java
Ejecutar con:
~$ java -cp :jasperreports-3.0.0.jar:lib/* FillReportClass
Observara que se creo un nuevo archivo con extension jrprint, el cual es el reporte
rellenado listo para visualizarse.
Visualización del reporte
La escencia de cada reporte esta en poder ser visualizado por el usuario, una vez que se
compila y rellena el reporte puede ser visto gracias a una clase especial de JasperReport
llamada net.sf.jasperreports.view.JasperViewer, que puede ser utilizada para generar
reportes. Como en caso anteriores nos hemos auxiliado de ant en la creacion de target
en el build.xml, continuaremos el proceso y editaremos el archivo para ant build.xml y
agregamos las siguientes lineas como target:
<target name="ver"
description="Ejecuta el reporte listo para ser visto">
<java classname="net.sf.jasperreports.view.JasperViewer"
fork="true">
<arg value="-F${file.name}.jrprint"/>
</java>
</target>
Ahora ejecute en la linea de comando:

~$ ant ver
Buildfile: build.xml
ver:
Imagen 2-6. Visualizacion del Reporte con JasperViewer, compilado por ant.
Resumen de Capitulo
Durante el capitulo anterior aprendimos detalles fundamentales para la
utilizacion de JasperReport, estos seran de vital importancia en los capitulos
subsiguientes, terminologias y usos particularmente de ant. Algunos puntos
fundamentales:
JRXML es un formato basado en XML, estandar para la creacion de plantillas en

JasperReports.
Los pasos basicos para crear un reporte son:
● Crear la plantillas.
● Previsualizar la plantilla (opcional).
● Tecnicas de creacion de .jasper:
○ Por programacion
○ Por compilacion ant.
● Rellenar plantillas binarias .jasper
● Visualizar Reportes
III. Estructura de Reportes
Al finalizar el capitulo Ud debera poder:
● Conocer y aplicar los elementos que conforman un reporte en JasperReport.
● Visualizar un reporte dentro de un navegador.
● Familiarizarse con el API de JasperReport.
Al igual que en muchos aspectos de la programacion, la creacion de reportes se divide

mediante estructuras, estas estructuras simplifican el trabajo y nos permite trabajar de
una manera mas sencilla dentro de los mismos. Dedicaremos este capitulo para analizar
aspectos acerca de esta estratificacion. Asi como tambien a otro tipo de visualizacion y
un rapido recorrido por el API de JasperReport.
Elementos de Reportes(tags)
Todos los reportes en JasperReport se encuentran divididos en partes que representan
distintos elementos dentro de la creacion de los mismos; dicho de una manera mas facil
“cada reporte tiene elemento, y cada elemento sirve para visualizar algo de manera
distinta”. Por tanto sin darse cuenta ud ya ha hecho uso de estos elementos a los que se
denominan (tags) o etiquetas, por ejemplo la etiqueta <detail> se utiliza para desplegar
texto estatico. Sin embargo, JRXML puede contener muchos mas elementos, de hecho
existen al menos 8 elementos como <detail>, que se conocen como bandas, por
reportes, aunque no es obligatorios usarlos todos, es depende de que tipo y como desea
desplegar esa informacion.
Algunos de los siguientes elementos pueden ser utilizados, dado que las bandas las
discutiremos por luego:
■ Propepiedades ( <property> ):
Es un elemento arbitrario y opcional, generalmente coloca informacion
adicional al reporte. Estas pueden ser retribuidas como un Java Property
invocando el metodo JasperReport.getProperty().
<property name="mipropiedad" value="mivalor"/>
■ Importacines ( <import> ):
Mediante este elemento es posible importar paquetes o clases de Java.
Se utiliza una para cada importacion por ejemplo:
<import value=”java.util.Vector”>
■ Parametros ( <parameter> ):
La etiqueta permite tener parametros definidos en el reportes, los cuales
luego pueden ser sustituido al invocar el reporte mediante un objeto de
java.util.Map, un reporte puede tener cero o mas parametros:
<parameter name="miparametro" class="java.lang.String"/>
<parameter name="parametroInt" class="java.lang.Integer"/>
■ Cadena de consulta( <queryString> ):
Este elemento permite colocar una sentencia para una consulta SQL, para
obtener datos de una base de datos, un reporte solo puede contener entre
cero y un elemnto queryString, es necesario para realizar consultas:
<queryString> <![CDATA [select columna1,columna2 from
tabla ]]</queryString>
■ Campos( <field> ):
Es un elemento visualizable en el reporte, utilizado comunmente para
desplegar informacion de una fuente de dato, pueden ser combinados con
otros elementos para obetener salidas necesarias, es posible tener cero o
mas campos:
<field name="Nombre_Campo" class="java.lang.String"/>
<field name="Cantidad" class="java.lang.Integer"/>
■ Variables( <variable> ):
Se utiliza varias veces, ayuda a simplificar expresiones, en los reportes
puede tener de cero a mas:
<variable name="MiVariable" calculation="Sum"
class="java.lang.Integer > <variableExpression>
$F{Cantidad}</variableExpression> </variable>
Bandas de Reportes
Las bandas son elementos mas visibles en los reportes, delimitan sectores o regiones en
los cuales se pueden colocar elementos, a partir de estas secciones los elementos
contenido se visualizaran diferentemente.
Background
El bacground es un elemento usado para colocar un fondo al reporte, es util al momento
de colocar una imagen o texto como marca de agua. Es la banda mas simple de utilizar y
se coloca al fondo de cada pagina del reporte. Esta banda puede ser usada a lo sumo una
vez:
<background>
<band height="820">
<image scaleImage="Clip" hAlign="Left" vAlign="Bottom">
<imageExpression>"image_fondo.gif"
</imageExpression>
</image>
</band>
</background>
Title
Otra basica pero util banda del reporte, se muestra a manera de encabezado y aparece
tan solo una vez en cada reporte, un reporte solo tiene un <title>, en este puede colocar
informacion relevante como el Nombre del reporte, una resumen del reporte, etc.
<title>
<band height="80">
<staticText>
<text>
<![CDATA[Titulo del Reporte]]>
</text>
</staticText>
</band>
</title>
Page Header
Este elemento se imprime al inicio de cada pagina del reporte, es un encabezado que
identifica elementos por paginas. Un reporte solo puede contener un pageHeader
<pageHeader>
<band height="40">
<staticText>
<text>
<![CDATA[Encabezado de Pagina]]>
</text>
</staticText>
</band>
</pageHeader>
Column Header
El siguiente es un encabezado que aparece por columna, la cantidad de elementos debe
concordar con la cantidad de columnas especificadas en el reporte.
<columnHeader>
<band height="20">
<staticText>
<text>
<![CDATA[Encabezado de columnas]>
</text>
</staticText>
</band>
</columnHeader>
Nota: En caso de existir una sola columna este elemento es ignorado
Report Detail
Este elemento define la seccion mas importante y repitende de datos en el reporte,
deacuerdo a la cantidad de filas y factores de agrupacion proporcionados por la fuente
de datos. La plantilla solo puede contener entre 0 a 1 elementos de detalles, la mayoria
contiene un detalle dado que es la mejor manera de visualizar repeticiones de datos.
<detail>
<band height="20">
<textField>
<textFieldExpression class="java.lang.String">
<![CDATA[$F{campoBD}]]>
</textFieldExpression>
</textField>
</band>
</detail>
Column Footer
Los elementos de tipos footer se colocan luego de terminar los detalles siguen la misma
logica que sus homologos header y en general se utilizan para presentar resumenes de
totales/subtotales, cantidades promediadas, etc.
<columnFooter>
<band height="20">
<staticText>
<text>
<![CDATA[Pie de columnas]]>
</text>
</staticText>
</band>
</columnFooter>
Nota: En caso de existir una sola columna este elemento es ignorado
Page Footer
El page footer representa un pie de que se coloca en cada pagina, puede ser provechoso
al momento de presentar datos como: el numero de la pagina, la persona que solicito el
reporte, o algun mensaje adicional.
<pageFooter>
<band height="20">
<staticText>
<text>
<![CDATA[Pie de Pagina]]>
</text>
</staticText>
</band>
</pageFooter>
Last Page Footer
Es el ultimo footer que aparece en la pagina de los reportes, en vez del pageFooter
corriente.
<lastPageFooter>
<band height="20">
<staticText>
<reportElement x="0" y="5"
width="200" height="20"/>
<text>
<![CDATA[El Ultimo pie de pagina es este]]>
</text>
</staticText>
</band>
</lastPageFooter>
Summary
Este elemento se imprime una vez que el reporte ha terminado. Util para hacer un
resumen general de los datos presentados en el reporte. Un reporte contiene entre 0 y 1,
banda de resumen.
<summary>
<band height="20">
<staticText>
<text>
<![CDATA[Resumenes de datos]]>
</text>
</staticText>
</band>
</summary
Practicas de elementos con Ireport
Probablemente al ver tanto XML estes pensando en renunciar a esto de hacer reportes
con Java, pero fue exactamente la razon por la cual aparecion Ireport la cantidad de
XML que se tenia que escribir para generar un reporte era bastante y controlar tanto
XML no es tan divertido como parece. En fin para no hacer largo el cuento a partir de
ahora nos auxiliaremos de iReport, para la creacion de reportes; sin embargo
seguiremos estudiando el JXML que se genera para no descuidar la escencia del
documento.
¿Que es Ireport?
Ireport es una herramienta visual que permite la rapida creacion de reportes basados en
las librerias JaperReport de java, actualmente es la aplicación mas completa de
generacion de reportes en Java basado en RAD de codigo abierto, y es soportada por
JasperForge. Desde su aparicion en 2005 su popularidad ha incrementado y se ha
convertido en el icono de creacion de reportes, sin envidiarle nada a las herramientas de
creacion de reportes como CrystalReport, XtraReport, ActiveReport, etc. Las cuales
tienen licencias comerciales.
Ireport 3.0, creando reportes
La instalacion de iReport no tiene ninguna ciencia en particular, lo unico que se tiene

que hacer es lo siguiente:
1. Descargar de sitio oficial (http://jasperforge.org/ ).
Imagen 3-1. Descarga Ireport del sitio oficial. http://jasperforge.org/

2. Una vez que tengas el paquete de instalacion*, deberia ver una estructura de
carpetas como la siguiente:
Imagen 3-2.Estructura de archivos de Ireport 3.0
3. Haz Click sobre Ireport.sh o Ireport.exe dependiendo de la plataforma en la que

te encuentres; veras Ireport, ahora click en File->New Document, para que crear
el nuevo reporte:
Imagen 3-3.Creacion de reporte

Como se muestra vemos campos de Nombre del reporte, Tipo de Pagina: AX, BX,
Legal, Ledger, etc. Tambien puedes configurar otras oopciones como los margenes,
columnas, Scriptlet Class (hablaremos luego de ello), Configuraciones adicionales y
estandares I18N (Internacionalizacion).
* El autor recomienda descargar la version comprimida, dado que en todo caso iReport es una
aplicación hecha en Java asi que se ajusta a toda plataforma que tenga JVM X.X deacuerdo a
especificaciones. Sin embargo hay un instalador generico para windows en caso que se desee
descargar.
4. Como apreciamos las bandas discutidas en el segmento anterior se muestran de
manera visual y en orden correcto. Las propiedades del reporte tambien son
visualizadas.
Imagen 3-3.Ireport, bandas y propiedades del reporte.
Es posible modificar el tamaño de cada banda, para no mostrarla simplemente se le da

una altura de cero. Durante el transcurso de este libro veremos mas a profundidad las
propiedades que se despliegan en el reporte y como podemos utilizarlas para distintos
casos.
5. Para colocar un titulo, ireport provee un set de herramientas en la parte superior.

Para crear un texto estatico damos click en el siguiente icono:
Ubicado en la parte superior, o simplemente nos dirijimos a Edit>Insert

Element>Static Text. Trazamos un rectangulo del texto y escribimos.
Es posible cambiar el estilo del texto, tamaño, color, decoraciones, etc. La
siguiente figura muestra un texto con Tamaño 16 y color rojo:
Imagen 3-4.Ireport, bandas y propiedades del reporte.

6. Por ultimo para “compilar y/o correr” el reporte tenemos tres iconos que nos
facilitan la tarea:
Compilar: Se Utiliza para la compilacion de reportes, identifica si existen errores

en el reporte ya sean visuales como el mal ajuste de una campo de una banda, logicos
como un campo erroneo que no puede encontrar en la fuente de datos, o un mal Casting
de una clase, etc.
Ejecutar sin fuente de datos o Ejecucion Pasiva: compila yejecuta el reporte sin
tomar en cuenta las fuentes de datos, osea que sin conexión activa para conseguir o
retribuir informacion externa. Este tipo de ejecucion es ideal para reportes con carácter
estatico que solo presentan informacion que muy dificilmente cambie.
Ejecucion con fuente de datos o Ejecucion de conexión activa: En este caso se

toma en cuenta la fuente de datos al momento de la ejecucion para llenar el set de
campos que dependen de la misma.
Ejecutamos con la segunda opcion e ireport solicitara guardar el jrxml y veremos lo

siguiente:
Imagen 3-5. JasperViewer desplegando un reporte estatico.

Para evitar algunos inconvenientes aquí estan unos tips que pueden ser util
al usar Ireport:
● Los nombres de reportes nunca lleven espacios en blanco, dado que

seran suceptible a errores con la lectura de los mismos, tambien que
al momento de ejecutar un reporte.
● Se guarde primero para que la compilacio tenga efecto.
● Nunca hacer caso omiso de los warnings a no ser que se sepan que
son inofensivos
● Al momento de trabajar en varios reportes hacer uso de Save All, para

evitar inconvenientes de perdida de informacion.
Estudiando JRXML generado por Ireport
Puedes optar por saltar esta seccion, pero si eres lo suficientemente curioso para
atreverte a ojear el codigo generado por iReport del anterior reporte, veras no es nada
diferente de loque hemos venido estudiando.
Las importaciones:
<import value="java.util.*" />
<import value="net.sf.jasperreports.engine.*" />
<import value="net.sf.jasperreports.engine.data.*" />
Texto estatico:
<staticText>
<reportElement x="40" y="12" width="431" height="30" forecolor="#FF0000"
key="staticText-1"/>
<box></box>
<textElement>
<font size="24"/>
</textElement>
<text>
<![CDATA[Mi primer Reporte en Ireport]]>
</text>
</staticText>
Observen el CDATA especifica el texto estatico para el reporte.
Entre otras basicas etiquetas que ya han sido mencionadas en este capitulo. De aquí en
adelante se detallara tan solo el JXML que sea de carácter relevante; pero se utilizara
iReport com herramienta principal de desarrollo en ambientes mas interesantes como
Conexiones de datos.
Proceso de creacion de un reporte
Un reporte es una tarea que lleva un proceso fundamental desde su creacion como
plantilla hasta su visualizacion/exportacion. Acontinuacion se muestra un diagrama de
flujo que simplifica dicho proceso.
Imagen 3-6. Proceso de creacion de un reporte

La siguiente tabla indica que instancia nos ayuda a llevar a cabo cada labor:
Acción API/Herramienta
Crear la plantilla JRXML Editor de texto, iReport, JasperDesign
Compilacion de la plantilla JasperCompileManager
Llenar el reporte JasperFillManager
Exportar JasperExportManager
Mostrar JasperPrintManager
A continuacion veremos mas a fondo las clases descritas en la tabla anterior.
Vistazo JasperReport API
Toma un tiempo para conocer parte de la estructura la interfaz de programacion de

aplicaciones (API) de jasperReport; tomalo en consideracion por que a lo largo de toda
tu vida como “reporteador Jasper”, son clases que literalmente veras a diario.
Imagen 3-7. Esquema de JasperReport API.

Fuente: http://confluence.atlassian.com
El proximo conjunto de clases se encuentran dentro del paquete

net.sf.jasperreports.engine:
JasperDesign
Esta clase es fundamental para la creacion de un reporte, es una representacion
programatica de las propiedades y caracteristicas del reporte en tiempo de diseño,
facilmente creado a partir de un XML asi como almacenado en uno. Su caracteristica
principal de uso es que provee la habilidad de modificar las propiedades del reporte en
tiempo de ejecucion (run-time).
JasperCompileManager
Responsable de la administracion de la compilacion del diseño del reporte y
transformarlo en una instancia lista para llenarse (ready-to-fill). La compilacion de los
reportes para esta clase es delegada a travez de JRDefaultCompiler (la cual esta
@Deprecated).
JasperReport
Es la representacion de una reporte compilado (generalmente por
JasperCompilerManager), la gran diferencia entre un reporte compilado y uno en
tiempo de diseño esta en que el primer proceso requiere compilacion y validacion por
tanto existen muchas propiedades (caracteristicas) del diseño que pasan a modo lectura
(read-only).
JasperPrint
Esta clase se identifica como una instancia de “documento orientado a la pagina” el cual
puede ser visto, impreso o exportado a distintos formatos. Una vez que el se llena el
diseño del reporte con los datos, el motor interno de JasperReport produce una instancia
de esta clase serializada, con compatibilidad de exporacion a PDF, HTML, XLS, CSV o
XML.
JasperFillManager
La clase que se encarga de cargar la informacion respectiva al reporte para
transformarse en un objeto de impresion JasperPrint. Esta clase puede hacer uso de
fuentes de datos para la carga de informacion, ademas todos los metodos reciben un
Map<T> de objetos el cual debera contener los parametros del reporte, estos tendran
una llave de asignacion unica que sera utilizada para la asignacion de dichos parametros
dentro del reporte. Existen don formas de llenar el reporte:
● Los metodos que reciban instancias provenientes de implementaciones de
JRDataSource.
● Metodos que reciban instancias directas de la interfaz Connection de JDBC y
retribuyan informacion del reporte ejecutando sentencias SQL.
Ambos metodos son detallados con mas detalle en el capitulo XXXX.
JasperPrintManager
Una vez compilado y llenado esta clase facilita la capacidad de visualizar el documento
ya creado, la cual contiene metodo para la impresion de visualizacion del reporte, con el
visor interno o bien desplegar el contenido como instancia de java.awt.Image.
JasperExportManager
Como ya ha sido mencionado existe la posibilidad de exportacion del documento a
formatos mas estandares y portatiles tales como PDF, CSV. Esta clase es la encargada
de llevar a cabo dicha tarea
Resumen de Capitulo
Este Capitulo nos introdujo de manera mas practica al mundo de JasperReport e
iReport, aprendimos las etiquetas basicas de lectura de JasperReport asi como la
utilizacion de iReport como herramienta fundamental de creacion de reportes.
Los procesos de creacion de reportes desde que se crea la plantilla hasta su
visualizacion/exportacion y el detalle de las clases que nos ayudaran a hacer y mostrar
nuestros reportes. En el proximo capitulo abarcaremos mas sobre la naturaleza real de
los reporte que es el dinamismo y como crearlo utilizando fuentes de datos JDBC.
IV. Reportes dinámicos, con
fuentes de datos JDBC
Al finalizar el capitulo Ud debera poder:
● Conceptualizar el principio de las fuentes de datos (tipos, importancia,
ventajas y usos)
● Crear y usar fuentes de datos SQL con iReport.
● Creacion de filtros, ordenamiento
● Creara aplicaciones java que puedan invocar dichos reportes.
● Modificaciones dinamicas basicas a travez de Java
Le recordamos al lector que los ejemplos presentados durante este se encuentran

en la carpeta preem/cap4. Aquí se disponen de ejemplos que requieren de
compilaciones y ejecuciones con CLASSPATH considerablemente largos por ello se
crearon archivos ejectables.
run1.sh
run1.bat
run2.sh
run2.bat
Para compilar y correr dentro del ambiente window y linux. Si no
dispone de la carpeta lib favor coloquela junto a la carpeta preem.
El objetivo principal de los reportes es el de proporcionar informacion breve, precisa, de

la manera mas eficiente y reflejada de la forma mas sencilla. Los reportes deben a su
vez ser dinamicos, los mas dinamicos posibles. La base para la creacion de dichos
reportes yace en la creacion de fuentes de datos, las cuale alimentaran al reporte con
los datos requeridos. Durante este capitulos nos enfocaremos en la creacion,
administracion y uso de las fuentes de datos, asi como estas nos ayudaran con la
creacion de reportes dinamicos.
Antes de definir que es una fuente de datos, demosle un vistazo a la siguiente imagen:
Imagen 4-1. El proceso de creacion de un reporte
Nos recuerda un poco el capitulo anterior, donde aprendimos las caracteristicas basicas
de un reporte, se muestra la fuente de datos (JRDataSource), que es la que alimenta al
reporte con informacion generalmente se refleja una fuente JDBC.
Fuentes de Datos
Los DataSources nos permiten vincular nuestra herramientas de creacion de reportes
con fuentes de almacenamientos de informacion, tales como Bases de datos, objetos
java POJO (Plain Old Java Objects), XML, CSV, etc. Estas fuentes alimentaran de
informacion al reporte. Lo interesante de dichas fuentes de datos es la diversidad y la
capacidad de iReport para interpretarla; algunas veces utilizando API's de terceros para
la correcta interpretacion de la informacion
Tipos
Diversos tipos de fuentes de datos encontramos en JasperReport, la tabla a continuacion
resume el tipo y una breve descripcion de la misma.
Tipo de Fuente de Dato (DataSource) Descripcion
JDBC Es probablemente la mas conocida y usada
permite el enlace a travez de conexiones
JDBC con iReport para el despliege de la
informacion mediante sentencias SQL las
cuales almacena las respectivas columnas
interpretando el tipo de dato, con su
correspondiente Casting (ej. varchar-
String) y asignandolo a un campo en
iReport.
JavaBeans Esta Fuente de datos puede reconocer dos
tipos de implementaciones: Collections o
Arreglos de objetos Java, su disponibilidad
yace debido al uso de Reflection. Es
particularmente util al momento de
realizar reportes a traves de EJB,
Hibernate, objetos JDO e incluso POJO's.
TableModels En muchas aplicaciones del lado del
clientes, los datos son desplegados de
manera tabular, JasperReport permite la
impresion de este tipo de formato como
reporte al pasar la fuente de dato como un
TableModels.
XML XML es un formato universal entre
aplicaciones ampliamente usado con
SOAP y por supuesto soportado por
JasperReport utilizando expresiones Xpath
para la extraccion de informacion.
CSV En ocasiones atipicas se hace necesario el
uso del formato CSV quizas pequeñas
aplicaciones o que no requieran de un
SGBD para manipular la informacion,
CSV es un formato comun el cual
JasperReport soporta su propio enlace de
datos a travez de
net.sf.jasperreports.engine.data.JRCsv
DataSource.
EmptyDataSource Se refiere a fuentes de datos vacias, su uso
es la simulacion de una fuente de datos
con un numero de datos “virtuales” osea
ficticios dentro.
Ventajas
● Creacion de reportes dinamicos.
● Facilita la abstraccion de informacion mediante enlaces separados.
● No Requiere de extensa configuracion
● Es una sencilla forma de obtener informacion externa
Crear Fuentes de Datos JDBC
La creacion de enlace de datos con SQL es de hecho realmente simple con iReport. Solo
siga los siguientes pasos para crear su propia fuente de datos:
1. Crear un nuevo reporte luego click en el menu superior:

Data>Connections/Data sources
Imagen 4-2. Creacion de Fuente de Dato JDBC - 1
La GUI de iReport 3.0, tambien tiene iconos de acceso rapido para la

configuracion de enlaces de datos a su par la fuente de datos en uso. La lista
de fuentes de datos es de particular uso cuando se generan reportes con
multiples conexiones.
Imagen 4-3. Icono Acceso rapido a Configuracion de fuente de datos y fuente de

dato en uso.
2. Luego se despliega un dialogo con la Conexiones / fuentes de datos existentes ,

para generar una nueva damos click en nuevo. Aparecera un dialogo con los
tipos de fuentes de datos.
Click en “Database JDBC connection”, para generar una conexión JDBC.
Imagen 4-4. Creacion de enlace de datos JDBC - 2

3. Ahora aparecera un dialogo para configurar la conexión JDBC, una vez llenado
los datos probamos la conexión (Click en el boton Test).
Name: Indica el nombre de nuestra fuente de datos.
JDBC Driver: Determina el Driver de conexión a utilizar dependiendo de nuestro
gestor de datos, tambien tiene soporte ODBC-Bridge ( por ejemplo:
org.gjt.mm.mysql.Driver, oracle.jdbc.driver.OracleDriver, etc).
JDBC URL: La direccion estandard para la conexión con el origen de datos.
JDBC URL: Wizard: es un pequeño panel que nos ayuda a generar el URL
automaticamente llenando la informacion necesaria (Database y Server Address).
User Name: El usuario de conexión con la base de datos.
Password: La contraseña con la cual el usuario se conecta.
Save password: para evitarnos colocar la contraseña al momento de trabajar con la
fuente de datos.
Imagen 4-5. Creacion de enlace de datos JDBC - 3a

Imagen 4-6. Creacion de enlace de datos JDBC - 3b
Le recordamos al lector que no es recomendable utilizar el usuario root
para la creacion de reportes por motivos de seguridad, este usuario esta
reservado para alcance administrativo.
4. Por ultimo click en salvar y nuestra conexión esta creada y lista para utilizarse.
Como se aprecia es posible modificar, eliminar y establecer por defecto (para
cuando tenemos multiples fuentes). La exportacion e importacion son temas que
veremos con mas detalle luego.
Imagen 4-7. Creacion de enlace de datos JDBC - 4

Fuentes de datos JDBC ¿que sucede?
Al momento de crear la fuente de datos, iReport lo unico que efectua es un proceso

interno de instanciacion de una conexión mediante un Driver determinado en la
configuracion; utiliza dicha configuracion para crear un puente JDBC y ejecutar las
sentencias. La clase net.sf.jasperreports.engine.JRResultSetDataSource es una muy
util implementacion de net.sf.jasperreports.engine.JRDataSource nos ayuda a
envolver los datos en un objeto Resultset. Y como la mayoria de los reportes se utilizan
con bases de datos relacionales es probablemente la interfaz con mayor uso dentro del
API de JasperReport.
Con las fuentes de datos JDBC lo que sucede es lo siguiente: cuando se especifica la
consulta a ejecutar dentro del reporte para la extraccion de la informacion, el motor del
reporte envuelve tanto la conexión creada, como la sentencia retornando un
java.sql.ResultSet posteriormente en una instancia de
net.sf.jasperreports.engine.JRResultSetDataSource Pero en general al momento de
crear o llamar el reporte lo que se le asigna es un objeto de tipo java.sql.Connection,
luego JasperReport ejecutara lo necesario para hacer lo antes dicho.
Tambien la pregunta gira en torno en donde iReport almacena la informacion de la

fuente de dato dado que no lo hace en el JRXML. Bueno en las versiones de
compatibles con Linux, tomara ~/.ireport/config.xml este archivo contiene la
informacion creada del datasource:
<iReportConnection name="fcys"
connectionClass="it.businesslogic.ireport.connection.JDBCConnection">
<connectionParameter name="ServerAddress">
<![CDATA[localhost]]></connectionParameter>
<connectionParameter name="SavePassword">
<![CDATA[true]]></connectionParameter>
<connectionParameter name="Url">
<![CDATA[jdbc:mysql://localhost/fcys]]></connectionParameter>
<connectionParameter name="JDBCDriver"><![CDATA[com.mysql.jdbc.Driver]]>
</connectionParameter> <connectionParameter name="Database">
<![CDATA[fcys]]></connectionParameter> <connectionParameter
name="Password">
<![CDATA[fcys]]></connectionParameter>
<connectionParameter name="Username">
<![CDATA[mi_password]]></connectionParameter> </iReportConnection>
<QueryExecuter factory="com.jaspersoft.jrx.query.JRXPathQueryExecuterFactory"
fieldsProvider=""><![CDATA[xpath2]]></QueryExecuter> </iReportProperties>
Creacion de Reportes Dinamicos: Uso de la
fuente de datos
Una vez poseamos un enlace de datos, es necesario hacer uso de el. Recordemos que los
enlaces de datos son solamente conexiones preconfiguradas para la ejecucion de
consultas y obtencion de informacion.
Caso de estudio en el que no enfocaremos durante los siguientes capitulos es con la base
de datos FCYS que es un sencillo EJEMPLO de diagrama relacional de entidades
universitarias o colegiadas.Tenemos docentes, asignaturas, semestres, cursos lectivos.
Conforme avanzemos el diagrama va ir incrementandose y nos va proporcionar mas
potenciales reportes. Empezemos con tres tablas sencillas:
Imagen 4-8. Parte del diagrama relacional de FCYS.

Se solicita un reporte que visualize todas las asignaturas su nombre y descripcion. La
realizacion del reporte seguira los siguientes pasos:
1. Creamos la consulta con los datos necesarios (es recomendable que se pruebe la
consulta antes de utilizarla). En este caso listar todas las asignaturas con su
nombre y descripcion:
~$mysql > select nombre,descripcion from asignatura;
2. Luego la consulta anterior la colocamos dentro de nuestro reporte. Nos

dirigimos al menu superior: Data>Report Query.
Imagen 4-9. Creacion de reporte dinamico – 1
Al igual que con el acceso a la configuracion de enlace de datos se cuenta

con un rapido acceso al Report Query:
Imagen 4-10. Icono Acceso rapido al Report Query.

3. Ahora colocamos la consulta en el dialogo de “Report Query”. Si todo esta en
orden entonces automaticamente apareceran las columnas las cuales
automaticamente se les asigna un Field dentro del reporte abajo y su respectivo
Casting a un objeto Java. Mas adelante aprenderemos a utilizar las expresiones
de filtro y orden. (Filter and sort Option). Click Ok
4. Una vez que la consulta sea cargada al reporte los campos respectivos son
creados automaticamente. Para visualizarlos dentro del reporte hay una seccion
llamada “Document Structure” generalmente se encuentra en el borde
izquierdo, que mantiene la estructura del documento tal como campos (fields),
variables (variables), parametros (parameters); asi como otras particularidades
como la estructura de cada banda.
Imagen 4-12. Seccion Estructura del documento. Creacion de reporte dinamico – 2

Si no logra visualizar la seccion de “Document Structure”, es probable que
este oculta, dirijase al menu superior: View>Docking Panes>Document
Structure
5. Ahora arrastramos cada campos y hacemos algunos ajustes como quitar algunas
bandas colocandole height de “0” o simplemente arrastrandola hasta la banda
superior. Recordemos que los titulos son textos estaticos, lo novedoso es la
variable PAGE_NUMBER, que indica el numero de pagina que nos
encontramos.
6. Al ejecutar el repote (recordemos que se ejecuta en Build>Execute Active

connection), se visualiza algo similar a esto:

A pesar de que este muestra la informacion solicitada no es muy estetico tenerlo todo en
una columna desperdiciando espacio disponible a la derecha. Por ello debemos hacer
unas modificaciones para permitir que iReport cree un reporte con columnas.
Existe una seccion donde se puede navegar por todos los reportes abiertos un arbol con
raiz “Open File” seleccionamos este para optener las propiedades del reporte al borde
derecho “Properties”. Vemos un espacio para las columnas del reporte llamado Report
Column, ahi en la propiedad Column cambiamos el valor de “1” a “4”. Luego
seleccionamos la Opcion de Print Order cambiamos de “Vertical” a “Horizontal”,
esto asegurara que los datos sean impresos de manera horizontal osea por columna en
vez de ser impresos verticalmente o por fila (Imagen 4-15).
Orden imprension Horizontal Java C++ C# Fortran Groovy Python

Orden imprension Vertical Java
C++
C#
Fortran
Groovy
Python
Imagen 4-13. Cambio de las propiedades Columns y Print Order

Ahora el reporte se imprime los mismos datos de esta manera:
Imagen 4-16. Vista del reporte luego de algunos ajustes.
Filtros
Los datos generalmente requieren de algun tipo de ajustes antes de presentarse, y a
pesar que a travez de las consultas SQL es posible realizar la mayoria de los filtros, hay
casos especiales en donde sera mas conveniente utilizar filtros ajustados al reporte. Por
ejemplo en el caso que sean dos reportes con los mismo datos solo que con filtros
distintos, para no utilizar tantos recursos del servidor se obtiene la consulta general y se
filtran, ademas estos filtros estan basados en expresiones Java lo que nos permite una
ventaja al controlar la informacion.
Para generar filtros den iReport es muy sencillo primero vamos al “Report Query”,
que es donde digitamos la consulta, al margen inferior vemos un boton que dice “Filter
Expression”,
Imagen 4-17. Creacion de Filtros -1.
Nuestro filtro seria:
new Boolean( $F{nombre}.startsWith("A") || $F{nombre}.endsWith("a") )
Explicacion:
$F{nombre}*: determina un objeto nombre tipo campo (Field), que ha sido
apropiadamente asignado a una clase en este caso java.lang.String. Dado que es un
objeto de tipo String podemos utilizar sus metodos startWith para disponer la letra de
inicio y endsWith para la letra final. Luego instanciamos a la clase Boolean dado que
JasperReport solo puede interpretar clases para filtros y no tipos de datos primitivos
como boolean.
Esta consulta afirma que filtre las clases que comienzan con “A” o que terminen con
“a”
Es conveniente saber que cuando necesitamos validar una expresion,
iReport cuenta con una especie de Wizard para la creacion de las mismas en
este caso filtros. Estos se representan con este icono.
* Todos los campos se representan con $F{variable_consulta}, las variables con $V{VARIABLE} y los
parametros $P{PARAMETRO}.
Imagen 4-18. Editor de Expresiones iReport 3.0.
La cantidad de datos con el filtro de simplifica en:
Imagen 4-19. Reporte de Asignaturas despues de filtro

Ordenar
Al igual que al momento de efectuar los filtros, el ordenamiento de datos es posible
realizarse al momento de ejecutar la consulta con la instrucción order by, sin embargo
hay escenarios donde se procura se efectuen dichos ordenamiento de informacion
directamente en el reporte. Ireport puede puede efectuar dicho tipo de ordenamiento
mediante JasperReport.
Primero vamos al “Report Query”, que es donde digitamos la consulta, al margen

inferior vemos un boton que dice “Sort options”. Luego click en “Add field” para
especificar el campo en funcion el cual se realiza el orden y el tipo de orden ascendente
o descendente.
Imagen 4-20. Ordenar datos mediante iReport 3.0.

Invocar Reporte Dinamico desde Java
Para invocar un reporte dinamico en java no tiene grandes diferencias. Existen muchas
maneras aquí mostraremos la capacidad para visualizar nuestro reportes enviando
conexión java.sql.Connection. Sin embargo en capitulos posteriores veremos que
existen metodos alternativo. Examinemos el siguiente codigo:
MySQLConexion con=new MySQLConexion();
JasperReport jasperReport=JasperCompileManager.compileReport(reportNames);
JasperPrint jasperprint=JasperFillManager.fillReport(jasperReport,new
HashMap(),con.getConnection());
JasperViewer viewer=new JasperViewer(jasperprint,false);
viewer.setVisible(true);
viewer.setTitle("Reporte Capitulo 4, La Preeminencia");
viewer.setLocation(100,100);
Al igual que en casos de visualizacion la clase JasperViewer es la encargada de

desplegar el reporte. Algunas variantes en este casos esta al momento de llenar el
reporte se le agrega un objeto java.util.Map, lo cual lo discutiremos en el proximo
capitulo con la parametrizacion, y un objeto java.sql.Connection, que eventualmente
sera la fuente de datos para realizar las consultas pertinentes.
Pregunta Bonus: ¿Como cambiar propiedades
reporte desde java?
En el capitulo anterior, cuando se hablo acerca del API de JasperReport, se abordo una
clase llamada JasperDesign, la cual nos permitia modificar el diseño del reporte en
tiempo de ejecucion de Java. No es tan frecuente hacer uso de esta clase dado que el
reporte suele ser una plantilla a la cual se llenan a travez de alguna fuente de datos. Pero
en el peculiar caso que se haga uso de esta caracteristica de JasperReport, el siguiente
codigo ilustra la manera de realizarlo:
....
JasperDesign jasperDesign=JRXmlLoader.load(reportName);
//coloca numero de columnas
jasperDesign.setColumnCount(3);
/*Agregamos una banda de diseno con un texto estatico*/
JRDesignBand newBand= new JRDesignBand();
newBand.setHeight(100);
JRDesignStaticText staticTextField=new JRDesignStaticText() ;
staticTextField.setText("Texto estatic en banda");
staticTextField.setHeight(50);
staticTextField.setWidth(400);
newBand.addElement(staticTextField);
jasperDesign.setSummary(newBand);
JasperReport jasperReport=JasperCompileManager.compileReport(jasperDesign);
.....
Primero se utiliza el JRXmlLoader el cual carga la plantilla JRXML como un objeto

de tipo JasperDesign, luego se procese a hacer la primera modificacion cambiando la
cantidad de columnas disponibles; para hacer un cambio mas serio digamos agregar una
banda el trabajo es un poco mayor se hace uso de la clase JRDesignBand la cual se
ajusta el tamaño y una banda de tipo estatic con sus respectivos componentes. Por
ultimo la banda antes creada se agrega como summary.
Existe una cantidad de propiedades que son posibles modificar a traves de
JasperDesign, algunas de las mas importantes se resumen en la siguiente tabla:
Clase: net.sf.jasperreports.engine.design.JasperDesign
addImport(String value) Permite agregar la importacion de librerias
al reporte.
addStyle(JRStyle style) Para agregar estilos dentro del repote.
setDetail(JRBand band) Para agregar una banda al diseño del
reporte. Este metodo tambien tiene sus
homologos por banda:
setSummary
setTitle
setColumnFooter
setColumnHeader
setOrientation(byte orientation) Para cambiar la orientacion en la que
despliegan los datos. Deacuerdo a
variables finales en el reporte:
● ORIENTATION_PORTRAIT
● ORIENTATION_LANDSCAPE
setQuery(JRDesignQuery query) Modifica la consulta dentro del reporte.

Fuente:
http://jasperreports.sourceforge.net/api/net/sf/jasperreports/engine/design/JasperDesign
.html
Resumen de Capitulo
Como vemos las fuentes de datos son la base para crear reportes dinamicos, estan son
las que realmente proveen la informacion que el reporte hara visible, particularmente las
fuentes de datos JDBC son de gran importancia dado que la mayoria de los sistemas de
informacion en los que se despliegan reportes tienen conexiones JDBC, ademas
pudimos ver los filtros y el ordenamiento de la informacion desde el diseño del reporte
y que escenarios serian convenientes de utilizar. Por ultimo abordamos nuevamente la
visualizacion de los reportes en Java y la capacidad de la clase JasperDesign, para
modificar en tiempo de ejecucion las propiedades generales de los reportes.
V. Reportes: diseño y
propiedades utiles.
Al finalizar el capitulo Ud debera ser capaz de:

● Crear estilos personalizados, agrupaciones, bandas.
● Utilizar variables y parametros.
● Parametrizacion de reportes e invocacion desde Java.
El diseño es un factor fundamental al momento de crear un reporte, este define la

estructura general del reporte, y como sera mostrada la informacion; la librería de
JasperReports tienen una serie de utilidades para la creacion de reportes visualmente
agradables. En el proceso de dicho diseño se deben tomar en cuenta que datos mostrar,
y mantener el principio DRY, en mente, para ello utilizamos parametrizacion de
reportes, todo este tipo de utilidades se describen en este capitulo, comenzemos!! .
Estilos personalizados
Los estilos personalizados son utiles en el diseño de reportes por dos razones:
1. Permiten estandarizar los estilos de los reportes que se crean.
2. Mantienen la capacidad de enfocarse en otras estructuras mas complicadas del
reporte.
Los estilos personalizados no son diferente de los vistos en otros WYGIWYS, son muy
faciles de crear desde iReport, se conocen como Style Library, ubicados en el menu
Format>Style. Creamos el estilo con las propiedades que creamos conveniente:
Imagen 5-1. Creacion de estilo personalizado
Para utilizar el estilo personalizado. Colocamos un titulo, seleccionamos el objeto

campo y en sus propiedades seleccionamos el nuevo estilo creado. Automaticamente
cambiara su formato.
Imagen 5-2. aplicación de estilo personalizado

Agrupaciones de Reportes
Otra caracteristica particularmente util son las agrupaciones, estas permiten tener una
serie de datos que contienen un dato en comun. Como por ejemplo las asignaturas
tienen en comun el semestre al cual pertenece, por ello el campo semestre podria
tomarse como criterio de agrupacion..
Primero seleccionamos de View>Report Group, seleccionamos una nueva agrupacion,

son el nombre de grupo y el campo para agrupar en este caso $F{idSemestre}.
Imagen 5-3. Creacion de agrupaciones
Entre las utilidades que se aprecian en lac creacion de las agrupaciones estan:
1. Start on a New Column: al momento de cambiar el valor de la agrupacion se
inicia en una columna nueva.
2. Start on a New Page: al momento de cambiar el valor de la agrupacion se inicia
en otra pagina.
3. Reset Page Number: para restaurar el contador de las paginas.
4. Print header on each page: para imprimir el encabezado de la agrupacion en cada
pagina.
Ahora ajustamos nuestros datos con el nuevo header creado. Y nuestro nuevo reporte se
vera asi:
Imagen 5-4. Reporte con agrupaciones.

Parametros
Si ud es programador de “x o y” lenguaje entonces sabra el termino parametro y su
utilidad; en JasperReport la perspectiva de parametro se torna inaderible al momento de
ejecutar un reporte con un filtro en particular, quizas una fecha, un usuario o una
conexion. La parametrizacion de reportes no es del todo desconocida a pesar que no la
hemos abordado aun.
En JasperReport existen dos tipos de parametros los modifiable y los non-modifiable.

Estos ultimos son vitales para el correcto funcionamiento del reporte y no pueden ser
modificados, clonados, o editados debido a su naturaleza.
Parametros no modificables (NonModifiable )
Este tipo de parametros son factores en comun en cada reporte, no pueden ser
modificados para mantener la estabilidad de los mismos; esto se define por el Built-in=
yes, asignado. Veamos ahora algunos parametros no modificables y su utilidad dentro
de JasperReport.
Parametro Descripcion
REPORT_PARAMETERS_MAP Mantiene los valores de los parametros de
reportes, en un java.util.Map. Este parametro
trabaja de manera auxiliar, proveiendo los
parametros y valores modificables.
REPORT_CONNECTION Reservada para la conexión
java.sql.Connection, la cual es posible ajustar
su valor al momento de invocar el reporte.
REPORT_TIME_ZONE Parametro para la zona horaria util para saber
el momento de ejecucion de un reporte.
REPORT_DATA_SOURCE En caso de los reportes que se invocan con
fuentes de datos gracias a la clase:
net.sf.jasperreports.engine.JRDataSource
HIBERNATE_SESSION Mantiene valores de sesiones de hibernate el
cual es una popular herramienta ORM que se
ajusta muy bien con iReport.
JPA_ENTITY_MANAGER Para la administracion de entidades con la
clase javax.persistence.EntityManager de
JPA
Parametros modificables (Modifiable)
Los parametros modificables son aquellos que son creados dentro de JasperReport con
un valor propenso a cambio dentro de la ejecucion del reporte. Su utilizacion comun
son:
● Para criterios de filtracion de una consulta SQL.
● Personalizacion de reportes (ej. Titulos distintos o encabezados diferentes).
● La utilizacion de clases propias con caracteristicas inherentes al negocio.
Comunmente sirven como filtros personalizados de las consultas. Para la creacion de un
parametros:
1. Nos dirigimos View>Parameters.
2. Click New (Nuevo)
3. Creamos el nombre del parametro Seleccionamos y el tipo de clase del parametro
4. Le asignamos un valor por defecto.
Imagen 5-5. Creacion de parametros
Existen tres caracteristicas adicionales:

1. Use as Prompt: significa que el usuario podra digitar el valor de la
propiedad mediante un dialogo al momento de aparecer el parametro.
2. Parameter Description: es una breve descripcion del parametro.
3. Edit Parameter properties: es la edicion de las propiedades de los
parametros o agregar nuevas propiedades. Se debe ser muy
cuidadoso con la propiedad que se elijan dado que se aplican a
elementos en particular.
Imagen 5-6. Propiedades de los parametros.
Utilizar parametros dentro de consultas
Para utilizar los parametros en una consulta es sencillo. En el ReportQuery cambiamos
la consulta con el filtro que consideremos pertinente por ejemplo:
Imagen 5-7. Aplicación de los parametros
Dentro de la clausula where vemos que el uso del parametro. Los parametros se
identifican por $P{NOMBRE_PARAMETRO}, esto permite la facil aplicación del
mismo.
Variables
Al igual que con los parametros las variables se clasifican en modificables (modifiable)
y no modificables (non modifiable). Sin embargo la funcion entre ambos (parametros y
variables) es muy distinta. Mientras que los parametros pueden ser modificados al
momento de invocar un reporte, las variables son utilizadas a lo interno del reporte y
sirven en general para calculo (promedios, contadores, sumas, etc) de datos del reporte.
Variables no modificables (NonModifiable)
Las variables built-in o no modificables son de principal orden dentro del reporte y
muy facil de identificar y explicar:
Variable Descripcion
PAGE_NUMBER Variable registra el numero de la pagina
corriente que se despliega en el reporte.
COLUMN_NUMBER Registra el numero de columna que es
desplegada, esta se reinicia con cada pagina.
REPORT_COUNT Mantiene el valor de numeros de repotes
desplegados. (cuenta subreportes).
PAGE_COUNT Contiene el numero de paginas en el reporte.
COLUMN_COUNT Contiene el numero de columnas en el reporte
(no se reinicia).
BAND_NAME_COUNT A cada banda que se crea se asigna un
contador para saber la cantidad de datos que se
despliegan.
Variables modificables (Modifiable)
Las variables modificables son aquellos que se crean para tener una caracteristica
especial y manipulacion particular de los datos. Su uso comun se limita al calculo de
ciertas caracteristicas tales como promedios, sumas, desviaciones estandares, el mayor,
el menor, etc.
Comunmente sirven como filtros personalizados de las consultas. Para la creacion de un
parametros:
1. Nos dirigimos View>Variables.
2. Click New (Nuevo)
3. Creamos el nombre de la variable aquí:
1. Especificamos el tipo de clase para la variable.
2. El tipo de calculo a ejecutar. ( count, sum, average, lowest, highest, etc).
3. Reset Type para ver en que momento la variable puede reiniciarse.
4. Increment Type es para saber en que momento debe incrementar
4. Luego asignamos una expresion y un valor inicial.
Imagen 5-8. Variables Modificables
Custom Incrementer Factory Class: se trata de la creacion de una clase

personalizada (custom), que permita el incremento de la variable deacuerdo
a condiciones o valores. La clase debe implementar net.sf.jasperreports.
engine.fill. JRIncrementerFactory
Utilizar Variables en Reportes
Es muy sencillo de utilizar las variables para que se desplieguen en los reportes.
Simplemente deben ser arrastradas desde Document Structure al lugar donde se
utilizaran.
Uso de parametros con Java
La parametrizacion de reportes es muy comun, dado que estos son utiles para filtrar el
incluir al usuario como una fuente potencial de informacion para que obtenga reportes a
fines a sus intereses es lo mas conveniente. La manera mas comun de colocar
parametros a un reporte java es con un objeto de tipo java.util.Map, teniendo como
llave el nombre del parametro y asignando los respectivos valores. Veamos el siguiente
ejemplo para invocar un reporte y asignar valores a parametros:
...........
MySQLConexion con=new MySQLConexion();
Map parameters=new HashMap();
/*Init parameters*/
System.out.print("Ingrese un # de semestre : ");
Scanner scan=new Scanner(System.in);
int n_semestre=scan.nextInt();
parameters.put("N_SEMESTRE",n_semestre);
JasperReport jasperReport=JasperCompileManager.compileReport(reportNames);
JasperPrint
jasperprint=JasperFillManager.fillReport(jasperReport,parameters,con.getConnecti
on());
JasperViewer viewer=new JasperViewer(jasperprint,false);
viewer.setVisible(true);
viewer.setTitle("Reporte Capitulo 4, La Preeminencia");
viewer.setLocation(100,100);
.........
En el codigo anterior se aprecian tres lineas importantes:

Map parameters=new HashMap();
Se refiere a la creacion del mapa que contendra los parametros. Luego
parameters.put("N_SEMESTRE",n_semestre);
Se asigna valor a dicho mapa, teniendo en cuenta que cada llave trabaja como cada
parametro.
jasperprint=JasperFillManager.fillReport(jasperReport,parameters,con.getConnectio
n());
Por ultimo se refiere el objeto mapa al momento de llenar el reporte para que sea
apropiadamente creado.
Bonus: Como colocar Imagenes con Blob (como
flujos de bytes).
VI. Subreportes
VII. Tecnicas avanzadas de reportes
Crosstabs
Tengamos en cuenta el modelo entidad relacion de la imagen 4-8, bastante

sencillo. Como harias para que un reporte en particular desplegara
informacion con respecto a dos variables. Si estas familiarizado con hojas
de calculo es facil asumir un “Cross tabulation”, bien pues iReport 3.x te
ayuda a crear crosstabs, gracias a JasperReports.
Sugerencias.
Netbean plugin (caso particular con Hibernate)

Eclipse plugin (caso particular con Hibernate)
Bibliografia:
http://ireport.sourceforge.net/manual0.2.0.html

La Preeminencia Corte

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

La Preeminencia Corte

Cargado por

Copyright:

Formatos disponibles

La preeminencia

Es necesario que el lector tenga conocimiento medio de J2SE 5,

Para realizar los ejemplos es requisito tener configurado apropiadamente

Tambien para los capitulos X, Y y Z se debe estar familiarizado con

*Es posible usar cualquiera pero recomendamos mysql por su facilidad

Tambien terminos importantes son resaltados en el texto, que este

Este documento esta propenso a errores, quizas si encuentra alguno con

Actualmente el proyecto ha crecido tanto que permite la incorporación múltiples

● SWTJasperViewer que es un componente embebido reutilizable de cualquier

Toda su funcionalidad depende del Jar jasperreports-x.x.x.jar, a pesar de esto depende

A continuacion se describen las características.

Imagen 1-1. Descarga de JasperReport 3.x desde Sourceforge.net

Ant es una herramienta de compilacion, estas facilitan el proceso de compilar

/src aquí estan las fuentes generalmente .java

/dist los .jar para la distribucion por ejemplo:

/lib las librerias de las que dependen algunas

JasperReport provee como una característica principal el soporte a gran variedad de

● Potable Document File (PDF). ● Excel bajo XLS.

● Rich Text Format. ● OpenOffice con ODT.

● XML. ● HyperText Markup Language

● Valores separados por coma CSV. ● Texto plano.

Aspectos fundamentales de JasperReport, su inicio como proyecto libre y el impacto

Definimos JasperReport sus características a nivel generales son: posicionamiento de

Como obtener JasperReport, ya sea por medio de la pagina de sourceforge.net,

Es inevitable que en cualquier proceso de aprendizaje se comienza por pasos a

A los usuarios de win32, a diferencia de sistemas GNU/Linux, Ant no viene

Como vera el codigo anterior no es complicado, lleva la estructura básica de un archivo

<project name="Primer preview de reporte" default="verDiseno"

El resultado de la previsualizacion seria esto:

Imagen 2-3. El resultado del comando ant, con la previsualizacion de la plantilla.

public class CompileProgramaticly

Ahora compilamos el código anterior, en consola (Linux) seria un comando parecido al

~$ javacc -cp jasperreports-3.0.0.jar CompileProgramaticly.java

Ahora utilizamos un comando parecido para correrlo:

Imagen 2-4. Archivo jasper creado gracias a la compilación de JasperCompileManager

<project name="Primer preview de reporte" default="verDiseno"

Ant es una poderosa herramienta ampliamente usada con el manejo de JasperReport,

<project name="Primer preview de reporte" default="verDiseno"

Lo ejecutamos con el comando

Imagen 2-5. Compilacion de repotes con Ant genera un .jasper

El codigo es bastante sencillo la linea mas importante es el relleno en el cual se pasa

Ahora ejecute en la linea de comando:

JRXML es un formato basado en XML, estandar para la creacion de plantillas en

Al igual que en muchos aspectos de la programacion, la creacion de reportes se divide

La instalacion de iReport no tiene ninguna ciencia en particular, lo unico que se tiene

Imagen 3-1. Descarga Ireport del sitio oficial. http://jasperforge.org/

Imagen 3-2.Estructura de archivos de Ireport 3.0

3. Haz Click sobre Ireport.sh o Ireport.exe dependiendo de la plataforma en la que

Imagen 3-3.Creacion de reporte

Imagen 3-3.Ireport, bandas y propiedades del reporte.

Es posible modificar el tamaño de cada banda, para no mostrarla simplemente se le da

5. Para colocar un titulo, ireport provee un set de herramientas en la parte superior.

Ubicado en la parte superior, o simplemente nos dirijimos a Edit>Insert

Imagen 3-4.Ireport, bandas y propiedades del reporte.

Compilar: Se Utiliza para la compilacion de reportes, identifica si existen errores

Ejecucion con fuente de datos o Ejecucion de conexión activa: En este caso se

Ejecutamos con la segunda opcion e ireport solicitara guardar el jrxml y veremos lo

Imagen 3-5. JasperViewer desplegando un reporte estatico.

● Los nombres de reportes nunca lleven espacios en blanco, dado que

● Se guarde primero para que la compilacio tenga efecto.

● Al momento de trabajar en varios reportes hacer uso de Save All, para

Imagen 3-6. Proceso de creacion de un reporte