5 Confeccindeinformes 121101080558 Phpapp01 PDF

Desarrollo de interfaces:
5.CONFECCIN DE INFORMES
Jose Alberto Bentez Andrades
jose@indipro.es
www.indipro.es
@indiproweb
@jabenitez88
1 Jose Alberto Bentez Andrades jose@indipro.es - @indiproweb
CONFECCIN DE INFORMES iReport Y JasperReports
JasperReports es el ms popular motor de creacin
de informes en cdigo abierto. Est escrito
completamente en Java y es capaz de utilizar los
datos procedentes de cualquier tipo de fuente de
datos y presentar los documentos con precisin de
pxeles, lo cuales se pueden ver, imprimir o exportar
en una variedad de formatos de documentos
incluyendo HTML, PDF, Excel, OpenOffice y Word.
2 Jose Alberto Bentez Andrades jose@indipro.es - @jabenitez88
CONFECCIN DE INFORMES iReport Y JasperReports
iReport es un diseador gratuito y de cdigo abierto
para JasperReports. Crea diseos muy sofisticados
que contienen grficos, imgenes, subinformes,
tablas de referencias cruzadas y mucho ms. Puede
acceder a datos a travs de JDBC, TableModels,
JavaBeans, XML, Hibernate, CSV, y fuentes
personalizadas y luego publicar estos informes en
formato PDF, RTF, XML, XLS, CSV, HTML, XHTML,
texto, DOCX, u OpenOffice.
iReport INSTALACIN
http://community.jaspersoft.com
/download
Debemos descargar
iReportDesigner y JasperReports
Library.
iReport Creacin de un informe
Suponiendo que tenemos instalado un servidor de MySQL en nuestro
ordenador (http://dev.mysql.com/downloads/mysql/)
En primer lugar creamos una pequea base de datos, la llamamos
como queramos y dentro introducimos una tabla con unos registros.
CREATE TABLE participantes (
ID bigint(21) NOT NULL,
NOMBRE varchar(100) NOT NULL,
USERNAME varchar(100) NOT NULL,
PASSWORD varchar(100) NOT NULL,
COMENTARIOS varchar(100) default NULL,
PRIMARY KEY (ID)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
insert into participantes(ID,NOMBRE,USERNAME,PASSWORD,COMENTARIOS) values (1,'Participante
1','par1user','part1pass','comentarios participante 1');
4','par4user','part4pass','comentarios respecto al participante 4');
5','par5user','part5pass','sin comentarios para el participante 5');
6','par6user','part6pass',NULL);
7','par7user','part7pass','comentatios participante 7');
10','par10user','part10pass',NULL);
Una vez hemos creado nuestra base de datos MySQL,
abrimos el iReport. Creamos un datasource clickando
en el icono
Se abrir la ventana
de Connections /
Datasources y
clickamos en New
Seleccionamos
Database JDBC
Connection
Damos un nombre
cualquiera a la conexin.
Seleccionamos el JDBC
Driver de MySQL
En JDBC URL indicamos el
nombre de nuestra BBDD
Insertamos los datos de
nuestro login.
Pulsamos Test para
comprobar que todo
funciona correctamente.
Ahora nos dirigimos al men superior File > New y en Report seleccionamos una
plantilla (yo he seleccionado Wood) y pulsamos Launch Report Wizard
Posteriormente realizaremos 6 pasos:
1. Seleccin de la ubicacin en la que se guardar nuestro reporte.
2. Seleccin del datasource e introduccin del query para obtener los
datos que nos interesan.
3. Seleccin de los datos que queremos mostrar en el reporte.
4. Creacin de grupos para el informe ( en este primer ejemplo no
probaremos esto).
5. Seleccin del layout o acomodo de los datos en el reporte
6. Felicitacin por terminar nuestro informe.
Los pasos interesantes son el 3 y el 4, as que ser en estos en los que nos enfocaremos
ms.
El paso 1 se realiza de forma automtica, 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 extensin 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 tambin podriamos optar por compilar nuestro
archivo ".jrxml" desde la misma aplicacin 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 aplicacin java pueda
encontrarlo. Por mi parte llamar al archivo ReportePruebaCurso"
Hacemos clic en el botn "Next" para continuar con el paso 3. En este paso
debemos seleccionar el datasource desde el que los datos del reporte sern
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
ttulo "Query(SQL)" y en la parte inferior debemos tener un mensaje de
error que dice "Invalid query". (IMAGEN EN DIAPO SIGUIENTE)
Esto ocurre porque, efectivamente, en el textarea no tenemos una consulta
vlida (de hecho no tenemos ninguna). Por lo que ahora corregiremos eso.
Para esto tenemos 3 opciones:
1. Escribir una consulta nosotros mismos de forma directa.
2. Cargar una consulta que tengamos guardada en algn archivo .sql o .txt.
3. Crear una consulta usando el "diseador de consultas".
Nosotros haremos uso del diseador de consultas. Hacemos clic en el botn
"Design query" con lo que se abrir una nueva ventana que est dividida en
tres secciones.
La primer seccin es la de la estructura de la consulta. Aqu bsicamente
podremos cambiar entre las sentencias que estamos editando (SELECT, WHERE,
ORDER BY, etc.). La segunda seccin es la de los elementos de nuestra base de
datos (tablas, vistas, y temporales locales). Aqu podremos seleccionar los
elementos de los que queremos obtener datos para la consulta. Finalmente la
tercer seccin nos muestra los elementos que hemos seleccionado de la
segunda seccin para que podamos seleccionar los datos a obtener.
La consulta que haremos ser para obtener todos los datos de la tabla
"participantes", con excepcin del "ID". Para esto hacemos doble clic sobre el
nombre de la tabla "participantes" en la segunda seccin de la ventana que
tenemos abierta. Con esto aparecer en la tercer seccin otra ventana con el
ttulo "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 excepcin del "ID") y veremos que la
consulta se genera en la primer seccin. Ya solo damos clic en el botn "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 botn
"Next".
En este paso solo tenemos que seleccionar cules 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 botn
"Next".
Ahora en el paso 5 debemos seleccionar cmo queremos que los datos
sean agrupados. Esto lo explicar en algn otro post, pero por el momento
dejemos todo en blanco y demos clic en el botn "Next".
El ltimo paso es el solamente una felicitacin por haber creado un nuevo
informe.
Ahora hacemos clic en el botn "Finish" y ya podremos ver la plantilla de
nuestro informe.
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.
Al hacer clic en la pestaa de "preview", nuestro reporte se compilar y se
mostrar. En este caso el reporte puede ser pre-visualizado porque las
siguientes condiciones se cumplen:
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 travs del
datasource anterior.
El reporte est preparado para mostrar los datos recuperados
anteriormente.
Algo importante que ocurre al hacer este preview es que el reporte se
compila generando el archivo ReportePruebaCurso.jasper" el cual es el
archivo que usaremos desde la aplicacin Java que crearemos en un
momento.
Si queremos compilar nuestro reporte de forma manual podemos hacer clic
en el botn "Compile Report" de la vista de diseo:
Haremos algunas modificaciones para que este reporte se vea un poco
mejor: primero cambiaremos el ttulo que dice "Wood Title" por "Reporte
de Participantes", cambiamos el color de texto a negro, y eliminamos el
fondo y el subtitulo que tiene.
Adems cambiamos el ttulo de cada una de las columnas por algo ms
claro. Por ejemplo, podemos cambiar el ttulo 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 cmo generar este reporte desde una aplicacin Java.
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 categora "Java" y de tipo de proyecto
seleccionamos "Java Application" y hacemos clic en el botn "Next". En la
siguiente ventana introducimos el nombre de nuestro proyecto y dejamos
seleccionada la opcin "Create Main Class" y "Set as Main Project".
Hacemos clic en el botn "Finish" para que nuestro proyecto se genere. Lo
que haremos a continuacin es crear una biblioteca que contenga los
archivos jars bsicos necesarios de JasperReports. De esta forma no
tendremos que agregar cada uno de los jars cada vez que necesitemos usar
JasperReports en un proyecto. Adems si actualizamos la versin del API
que usamos, solo debemos actualizar esta bibliotec
Clickamos en Tools -> libraries
Con esto se abrir la
ventana del "Library
Manager". En esta
ventana hacemos clic
en el botn "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
opcin "Class
Libraries".
Al hacer clic en el botn
"OK" regresaremos al
"Library Manager" y
tendremos nuestra
nueva biblioteca creada.
Pero an nos hace falta
agregar los archivos jars
que conformarn esta
biblioteca. Nos
aseguramos que la
pestaa "Classpath" est
seleccionada y hacemos
clic en el botn "Add
Jar/Folder" situado a la
derecha. Se abrir un
cuadro de dialogo para
que seleccionemos los
jars que queremos
agregar.
Navegamos hasta el directorio en el que tenemos los jars de JasperReports que bajamos
anteriormente. Para que los ejemplos que haremos ms adelante (en los siguientes posts) funcionen,
debemos agregar a la biblioteca los siguientes jars:
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 botn "Add Jar/Folder" y con esto tendremos lista nuestra biblioteca
"JasperReports" para agregarla a nuestro proyecto.
Hacemos clic en el botn "OK" para regresar al ambiente de trabajo.
Ahora hacemos clic derecho en el nodo "Libraries" de la ventana
"Projects". Con esto se abrir un men contextual con 4 opciones,
seleccionamos la opcin "Add Library..."
En la ventana que se abre seleccionamos la biblioteca que creamos
anteriormente ("JasperReports") y hacemos clic en el botn "Add
Library". Al hacer esto veremos se agregar al nodo "Libraries" de
nuestro proyecto todos los jars que tiene nuestra biblioteca.
Ahora debemos recoger el fichero ReportePruebas.jasper que se gener
hace unas diapositivas y lo colocamos en el directorio raz del proyecto
de NetBeans que acabamos de crear (la raz del proyecto es el directorio
en el que se encuentran los subdirectorios "nbproject", "src", entre
otros). Copiamos tambin la imagen wood.jpg si la hemos mantenido en
nuestro informe.
Lo primero que debemos hacer es agregar el conector de mysql al proyecto
JAVA. Para ello debemos descargar el conector de mysql JDBC
(http://www.mysql.com/downloads/connector/j/ ). Una vez descargada la
agregaremos a la biblioteca de nuestro proyecto.
Lo siguiente que debemos hacer ahora es crear una conexin a la base de datos que
creamos anteriormente.
public static void main(String[] args) throws Exception {
// TODO code application logic here
Class.forName("com.mysql.jdbc.Driver");
Connection conexion = (Connection)
DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebascurso", "root",
"cursomysql");
}
Lo siguiente que debemos hacer es cargar el archivo ".jasper" generado
anteriormente y colocarlo en un objeto
"net.sf.jasperreports.engine.JasperReport". Para esto hacemos uso de la
clase de utilidad "net.sf.jasperreports.engine.util.JRLoader":
JasperReport reporte = (JasperReport) JRLoader.loadObject("RepotePruebaCurso.jasper");
Ahora el objeto "reporte" contiene la definicin del reporte, pero an 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 mtodo esttico, "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
conexin que usaremos en un momento, veremos qu otras fuentes de datos
existen y cmo usarlos en los siguientes posts). En este caso la fuente de datos
es la conexin directa a la base de datos que creamos anteriormente (el objeto
conexion):
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, conexion);
Pasamos "null" como segundo parmetro porque no estamos pasando
ningn parmetro al reporte (esto tambin lo veremos despus).
El objeto "JasperPrint" que obtenemos como resultado de la invocacin
del mtodo "fillReport" es la representacin de nuestro reporte (ahora
con datos) que podemos mandar a imprimir, mostrar en pantalla (si
estamos usando una aplicacin swing o awt), o, como en este caso,
guardarlo en un archivo.
Si estn haciendo una aplicacin swing y quieren mostrar este reporte
directamente en un componente pueden pasar el objeto "JasperPrint"
que acabamos de crear como parmetro a un nuevo objeto
"net.sf.jasperreports.view.JasperViewer", el cual es un componente
swing, y agregar este ltimo a un panel.
Para guardar este reporte a un archivo debemos usar un
"net.sf.jasperreports.engine.JRExporter".
"net.sf.jasperreports.engine.JRExporter" es una interface, y las clases
que la implementan nos permiten generar el reporte en distintos
formatos de una forma sencilla. Veremos cmo generar los reportes en
los siguientes formatos:
PDF
HTML
CSV
RTF
TXT
XLS
XML
XLSX
DOCX
PPTX
Primero declaramos una referencia a un objeto de tipo "JRExporter" de la
siguiente forma:
JRExporter exporter =
Ser esta referencia la que usaremos de ahora en adelante. Para que
nuestro reporte sea guardado en formato PDF creamos un objeto de tipo
"net.sf.jasperreports.engine.export.JRPdfExporter" y lo asignamos a nuestra
referencia exporter:
JRExporter exporter = new JRPdfExporter();
Ahora, las siguientes lneas 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 lnea asigna a nuestro objeto "exporter" el "jasperPrint" (el reporte
con datos) que creamos anteriormente. La segunda lnea le dice al "exporter"
cul ser el nombre del archivo generado (en este caso "reportePDF.pdf").
Recuerden cambiar el nombre y la extensin del archivo cada vez que
cambiemos de formato.
La ltima lnea es la que realiza el proceso de exportacin.
Si ahora ejecutamos nuestra aplicacin veremos que en el directorio raz del
proyecto se ha creado un archivo llamado "reportePDF.pdf":
Ahora, para que nuestro reporte sea exportado a formato HTML cambiamos la
lnea:
Por
JRExporter exporter = new JRHtmlExporter();
y el nombre del archivo de "reportePDF.pdf" a "reporteHTML.html". Al ejecutar
nuevamente nuestra aplicacin tendremos veremos que se genera el archivo
"reporteHTML.html" en el directorio raz de la aplicacin:
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 tendrn que agregar, adems, estas dos lneas:
exporter.setParameter(JRTextExporterParameter.CHARACTER_WIDTH, 12);//text
exporter
exporter.setParameter(JRTextExporterParameter.CHARACTER_HEIGHT, 12);//text
exporter
PARTE 2: Uso de DataSources
Personalizados
Ahora veremos cmo generar nuestros reportes sin hacer uso de una conexin.
Esto puede ser muy til en los casos en los que ya tengamos los datos en
memoria y no necesitemos realizar una conexin a la base de datos; o en el caso
en que, por alguna razn ajena a nosotros, no podamos obtener la conexin.
Para poder hacer esto se nos proporciona una interface:
"net.sf.jasperreports.engine.JRDataSource". Esta interface tiene solo dos
mtodos:
getFieldValue(JRField jrField)
next()
Creamos un nuevo proyecto en NetBeans (men "File -> New Project..."). En la
ventana de nuevos proyectos seleccionamos la categora "Java" y como tipo de
proyecto seleccionamos "Java Application" y hacemos clic en el botn "Next".
En la siguiente ventana introducimos el nombre de nuestro proyecto y dejamos
seleccionada las opciones "Create Main Class" y "Set as Main Project".
Para que podamos pasar datos a nuestro reporte es necesario que utilicemos un
datasource. En el ejemplo anterior veamos que el datasource que usbamos
era la base de datos y la conexin a la misma. En esta ocasin el datasource ser
una de nuestras clases. Esta clase deber implementar la interface
"JRDataSource" y contendr la lgica para pasar los datos correspondientes a
nuestro reporte.
Creamos una nueva clase haciendo clic derecho sobre el nodo "Source
Packages" de la ventana "Projects", o sobre el paquete que ya tenemos creado,
y en el men contextual que se abre seleccionamos la opcin "New -> Java
Class...".
En la ventana que se abre escribimos como en nombre de la nueva clase
"Participante" y presionamos el botn "Finish". Con esto veremos en la ventana
de nuestro editor la nueva clase "Participante".
Esta clase "Partcipante" representar los datos que se mostrarn en el reporte,
tal como en el ejemplo anterior cada uno de los registros de la tabla
"participantes" representaba una fila en el reporte final, cada objeto
participante que creemos representar una fila en el nuevo reporte.
Agreguemos los siguientes atributos a nuestra clase:
private int id;
private String nombre;
private String username;
private String password;
private String comentarios;
Adems agregamos sus getters y sus setters y dos constructores, uno sin argumentos y uno que
reciba como argumentos todas las propiedades declaradas anteriormente.
public class Participante
{
private int id;
private String username;
private String password;
private String comentarios;
public Participante()
{
}
public Participante(int id, String nombre, String username, String password, String comentarios)
{
this.id = id;
this.nombre = nombre;
this.username = username;
this.password = password;
this.comentarios = comentarios;
}
public String getComentarios()
{
return comentarios;
}
public void setComentarios(String comentarios)
{
this.comentarios = comentarios;
}
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getNombre()
{
return nombre;
}
public void setNombre(String nombre)
{
}
public String getPassword()
{
return password;
}
public void setPassword(String password)
{
this.password = password;
}
public String getUsername()
{
return username;
}
public void setUsername(String username)
{
this.username = username;
}
}
Ahora, antes de seguir con nuestro
cdigo Java, pasaremos a crear la
plantilla de nuestro reporte con
iReport, por lo que abrimos esta
herramienta.
En esta ocasin no haremos uso de
un wizard para crear el reporte, sino
que lo haremos desde cero.
Para crear el nuevo reporte vamos
el men "File -> New...". En la
ventana que se abre seleccionamos
uno de los formatos "Blank" y
presionamos el botn "Open this
Template":
Despus introducimos el nombre del reporte, yo lo llamar "reporte2.jrxml", y la
ubicacin en la que se guardar. Recomiendo que en esta ocasin guardemos el
reporte en el directorio raz del proyecto de NetBeans que acabamos de crear.
Hacemos clic en el botn "Next" y se nos mostrar un mensaje de felicitacin por
haber creado un nuevo reporte. Cuando presionen el botn "Finish" vern una
hoja dividida en 7 u 8 diferentes porciones horizontales llamadas bandas.
Cuando generamos nuestro reporte final con datos, cada una de estas bandas se
comporta de una forma distinta. Algunas aparecen solo al principio o al final del
reporte, otras aparecen con cada nueva fila que se le agrega, otras solo al final
de los datos, etc.
La plantilla de reportes est dividida en 10 bandas predefinidas. Una banda
siempre tiene el mismo ancho que la pgina. Sin embargo el alto de algunas de
las bandas puede variar durante la fase de llenado de datos, an si establecimos
un alto en el momento del diseo.
Las bandas existentes son:
Background
Title
Page Header
Column Header
Detail 1
Column Footer
Page Footer
Last Page Footer
Summary
No Data
Lo primero que haremos es agregar texto a nuestro reporte. En iReport existen
dos tipos de texto: texto esttico y texto dinmico (tambin llamado
expresiones). El texto esttico es aquel que no cambia, mientras que las
expresiones son como etiquetas que le indican a JasperReports que debe
reemplazarlas por algn valor al momento de generar el reporte final.
Existen 3 tipos de expresiones:
Campos (fields) representados con "$F{nombre_campo}".
Variables representadas por "$V{nombre_variable}".
Parmetros representados por "$P{nombre_parmetro}".
Cada uno de estos tipos de expresiones tiene un uso particular:
Los campos ("$F{}") le dicen al reporte dnde colocar los valores obtenidos a
travs del datasource. Por ejemplo, nuestro objeto "Partcipante" tiene un
atributo llamado "username". Usando una expresin de campo indicamos en
cul parte o seccin del reporte debe aparecer el valor de ese atributo usando
"$F{username}". Esto quedar ms claro un poco ms adelante.
Los parmetros ("$P{}") son valores que usualmente se pasan al reporte
directamente desde el programa que crea el JasperPrint del reporte (en nuestra
aplicacin Java). Aunque tambin existen algunos parmetros internos que
podemos leer pero no modificar. Para hacer uso de estos parmetros
simplemente indicamos el nombre del parmetro en el lugar que queremos
colocarlo. Pueden encontrar los nombres y significados de los parmetros
internos en la documentacin de JasperReports.
Las variables ("$V{}") son objetos usados para almacenar valores como los
resultados de clculos. Al igual que con los parmetros, JasperReports tiene
algunas variables internas que podemos leer. Pueden encontrar los nombres y
significados de las variables la documentacin de JasperReports.
Cada uno de estos elementos tiene un nombre, un tipo (que debe corresponder
con un tipo de objeto Java como String o Integer), y una descripcin opcional.
Adems deben ser registrados para poder ser usados en tiempo de diseo y que
puedan ser entendidos al momento de compilar el reporte, y por lo tanto para
que nuestro reporte funcione correctamente en tiempo de ejecucin. Esto lo
veremos un poco ms adelante.
Regresemos a donde nos quedamos. Queremos agregar un texto esttico a
nuestro reporte a modo de ttulo. Para esto debemos agregar un elemento
llamado "Static Text". Los elementos que podemos agregar a nuestros reportes
estn en una ventana llamada "Palette", que se encuentra en la parte derecha de
iReport, bajo la categora "Report Elements". Si no pueden ver la ventana
"Palette" presionen las teclas "Ctrl + Shift + 8":
De esta ventana arrastramos el elemento "Static Text" a la banda "Title". "Title"
es una banda que solo aparece en la parte superior de la primer pgina. Por lo
que nos sirve para colocar el ttulo del reporte y/o el nombre y logo de nuestra
empresa.
Una vez que hayamos colocado el texto esttico en la banda correspondiente y
mientras an est seleccionado, modificamos sus propiedades usando la ventana
de propiedades del elemento y la barra de formato de texto. Tambin podemos
abrir otra ventana que nos ayude a alinear y controlar el alto y el ancho de los
elementos yendo al men "Window -> Formatting Tools".
Ahora agregamos los encabezados de las columnas en las que se mostrarn los datos que
pasaremos al reporte. Agregamos estos nombres en la banda "Column Header", la cual se
repetir en cada pgina antes de mostrar los datos de las columnas.
Agregaremos las columnas "Nombre", "Usuario", "Contrasea", y "Comentarios". Por lo
que nuevamente arrastramos un elemento "Static Text" para cada una de las columnas.
Tambin podemos ajustar el alto de esta banda para que se ajuste al de nuestro texto, ya
sea movindola directamente en el diseador, o desde la ventana de propiedades:
Nuestro reporte ya casi est terminado, ahora solo nos queda agregar los campos en los
que se mostrarn los datos que pasaremos al reporte en un momento. Para que estos
campos puedan ser reemplazados por el valor real es necesario que usemos las
expresiones (texto dinmico) de las que habl anteriormente. Para esto definiremos un
"field" para cada uno de los campos que queramos mostrar (en este caso sern los mismos
campos para los que definimos las cabeceras de las columnas).
Los fields deben definirse antes de poder ser usados. Esta definicin incluye el nombre del
field y su tipo. Los fields (as como el resto de las expresiones) se definen en la ventana
"Report Inspector" a la izquierda del diseador del reporte. Ah existe un nodo llamado
"Fields" que es donde se encuentran los fields que hemos definido y que por lo tanto
podemos usar.
Hacemos clic derecho en el nodo "Fields" de la ventana "Report Inspector". Con esto se
abre un men contextual. Seleccionamos la opcin "Add Field" (la nica habilitada).
Con esto se agregar un field llamado "field1" que por default es de tipo "java.lang.String".
Cambiamos el nombre de este campo por "nombre" usando la ventana de propiedades.
Esto es importante porque donde pongamos este campo ser en donde se muestre el valor
del campo nombre de nuestros objetos Participantes.
Hacemos lo mismo para el resto de los campos ("username", "password", "comentarios",
"id"). Hay que tener cuidado cuando agreguemos el field "id". Si recuerdan, en la definicin
de la clase "Participante" la propiedad "id" est definida como "int". Sin embargo, a
JasperReports solo podemos pasarle objetos para ser usados como valores, por lo que ser
necesario cambiar el tipo de la clase ("Field Class en la ventana de propiedades) a
"java.lang.Integer" (aunque en realidad no mostraremos el "id" en este ejemplo).
Ahora debemos indicar en qu parte de nuestro reporte queremos que
se muestren los valores correspondientes a los atributos de los objetos
"Participante" que le pasemos. Para eso simplemente arrastramos los
fields correspondientes al lugar en el que queremos que se muestren
(arrastramos el field "nombre" a donde queremos que se muestre el
atributo "nombre", el campo "username" en donde queremos que se
muestre el atributo "username", etc.) desde el "Report Inspector". Al
arrastrar los fields, iReport agregar automticamente un encabezado
para este field, solo borren el encabezado agregado
Estos fields los colocaremos en la banda "Detail 1" la cual se repite cada vez que recibe un
nuevo objeto y coloca sus valores en la misma fila (quedar ms claro cuando ejecutemos
el ejemplo). Al final, el reporte debe quedar de la siguiente forma:
Por el momento esto es todo lo que necesitamos hacer en iReport para mostrar este
reporte bsico. Hacemos clic en el botn "Compile Report" para compilar el reporte y
generar su archivo ".jasper" respectivo.
Podemos ver una vista previa del reporte haciendo clic en la pestaa "Preview".
Asegrense de seleccionar el "Empty datasource" antes de ver el preview, de lo contrario
les aparecer un error indicado que el documento no tiene pginas. Al final deben ver algo
como esto:
Los "nulls" aparecen porque no se recuper ningn valor que coincidiera con el nombre de
ese field usando nuestro datasource (que en este caso est vaco, lo cual solucionaremos a
continuacin).
Regresamos al NetBeans y ahora crearemos una clase que implemente la interface
"JRDataSource" de la que habl antes. Esta clase ser la que usaremos como datasource
para nuestro reporte, y la que regresar los valores correspondientes a cada uno de los
fields que creamos antes.
Primero agregamos a nuestro proyecto la libreria "JasperReports" que creamos en las
primeras diapos de este ppt. En esta ocasin no necesitaremos agregar el jar con el Driver
de la base de datos, ya que no usaremos ninguna.
Creamos una nueva clase llamada "ParticipantesDatasource" y hacemos que esta nueva
clase implemente la interface "JRDataSource". Podemos hacer que NetBeans implemente
de forma automtica los mtodos de esta interface (proporcionando una implementacin
vaca) presionando las teclas "Alt + Insert" y seleccionando la opcin "Implement Method"
en el men contextual que se abre.
Con esto se abrir una ventana llamada
"Generate Implement Methods" en la cual
seleccionamos la interface "JRDataSource"
para que se seleccionen de forma
automtica todos sus mtodos y hacemos
clic en el botn "Generate".
Ahora agregaremos a nuestra clase un atributo de tipo "java.util.List" llamado
"listaParticipantes" que mantendr justamente eso: la lista de los participantes de los cuales
mostraremos los datos en el reporte. Inicializamos esta lista a un objeto de tipo
"java.util.ArrayList", de esta forma:
private List<Participante> listaParticipantes = new ArrayList<Participante>();
Tambin agregamos un contador llamado "indiceParticipanteActual" de tipo "int", que
usaremos enseguida, y lo inicializamos a "-1"; un poco ms adelante explicar por qu este
valor:
private int indiceParticipanteActual = -1;
Ahora implementaremos el mtodo getFieldValue. Este mtodo recibe un argumento de
tipo JRField. Este parmetro nos indicar por cul de los "fields" nos est preguntando el
reporte.
En la implementacin de este mtodo regresaremos los valores correspondientes a cada
uno de los atributos de nuestros objetos "Participante" conforme se vayan pidiendo. Por lo
que el mtodo queda as:
public Object getFieldValue(JRField jrField) throws JRException
{
Object valor = null;
if("nombre".equals(jrField.getName()))
{
valor = listaParticipantes.get(indiceParticipanteActual).getNombre();
}
else if("username".equals(jrField.getName()))
{
valor = listaParticipantes.get(indiceParticipanteActual).getUsername();
}
else if("password".equals(jrField.getName()))
{
valor = listaParticipantes.get(indiceParticipanteActual).getPassword();
}
else if("comentarios".equals(jrField.getName()))
{
valor = listaParticipantes.get(indiceParticipanteActual).getComentarios();
}
return valor;
}
Donde bsicamente ocurre lo que dije anteriormente: cada vez que el reporte pregunta por
el valor de un atributo del objeto "Participante" actual (al que hace referencia el contador
"indiceParticipanteActual") se regresa el valor correspondiente. Esta peticin se hace en
base al nombre del field que creamos desde iReport.
Ahora tal vez se estn preguntando en qu momento se incrementa el contador?, o cmo
sabe JasperReport cuntos participantes existen? Pues bien, ambas cosas ocurren gracias a
la implementacin del mtodo "next()".
public boolean next() throws JRException
{
return ++indiceParticipanteActual < listaParticipantes.size();
}
public void addParticipante(Participante participante)
{
this.listaParticipantes.add(participante);
}
JasperReport pregunta a este mtodo para saber si existe otro "Participante" en la lista. Este
mtodo es el primero que se llama al generar el reporte. Por lo que el contador debe
comenzar en "-1", as cuando este mtodo se llama la primera vez el contador queda en "0",
y cuando se invoca al mtodo "getFieldValue" se regresa el objeto Participante del ndice
adecuado.
Esto es todo lo que necesitamos para que nuestro datasource funcione para generar
reportes. Agregar un mtodo de utilidad a esta clase, llamado "addParticipante", que me
permita agregar un nuevo participante a la lista (aunque si lo prefieren pueden agregar el
setter de "listaParticipantes")
Para finalizar agregaremos en nuestra clase "Main" un ciclo dentro del cual crearemos 10
objetos "Participante", los cuales iremos agregando uno a uno a un objeto de tipo
"ParticipantesDatasource":
ParticipantesDatasource datasource = new ParticipantesDatasource();
for (int i = 1; i <= 10; i++)
{
Participante p = new Participante(i, "Particpante " + i, "Usuario " + i, "Pass " + i, "Comentarios
para " + i);
datasource.addParticipante(p);
}
El resto del cdigo para generar el reporte es similar al de la primera parte de esta
presentacin , solo que en esta ocasin en lugar de pasar un objeto de tipo "Connection" al
mtodo "fillReport" del "JasperFillManager" pasamos nuestro objeto
"ParticipantesDatasource" de esta forma:
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, datasource);
En el progarma principal tendremos el siguiente cdigo
public static void main(String[] args) throws Exception
{
ParticipantesDatasource datasource = new ParticipantesDatasource();
for (int i = 1; i <= 10; i++)
{
Participante p = new Participante(i, "Particpante " + i, "Usuario " + i, "Pass " + i, "Comentarios para " + i);
datasource.addParticipante(p);
}
File reporteFichero = new File("reporte2.jasper");
JasperReport reporte = (JasperReport) JRLoader.loadObject(reporteFichero);
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, datasource);
exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new java.io.File("reporte2PDF.pdf"));
}
Al ejecutar este cdigo debemos terminar con un archivo llamado "reporte2PDF.pdf" en el
directorio raz de nuestro proyecto y que tiene el siguiente contenido:
Podemos ver que los datos importantes (los datos de los "Participantes") aparecen en la
banda "Details 1" (donde colocamos los fields) y que esta banda se repite por cada uno de
los participantes de la lista.
Bien, con esto vemos que podemos crear nuestros propios datasources y pasar datos para
generar reportes sin la necesidad de una conexin a base de datos. Es bastante sencillo,
solamente debemos proporcionar una clase que implemente la interface "JRDataSource" y
que regrese los valores correspondientes a los fields del reporte.
Aunque esto ya es bastante fcil y til, existe una forma an ms simple para crear un
datasource, sin la necesitad de implementar la interface "JRDataSource". Esto es gracias a
un conjunto de clases que JasperReports ya nos proporciona y realizan bsicamente la
misma funcin que la clase "ParticipantesDatasource" que acabamos de crear. Estas clases
son:
JRBeanCollectionDataSource
JRJpaDataSource
JRBeanArrayDataSource
Las cuales ya implementan la interface "JRDataSource". Cada una funciona con distintos
tipos de datos, pero en que nos interesa en este momento es
"JRBeanCollectionDataSource" que puede convertir una "java.util.Collection" en un
DataSource de forma automtica. Modificaremos nuestro mtodo "main" para hacer uso de
esta clase.
Ahora, en vez de llenar nuestro "ParticipantesDatasource" en el ciclo simplemente
llenaremos un "java.util.List":
List listaPariticipantes = new ArrayList();
for (int i = 1; i <= 10; i++)
{
Participante p = new Participante(i, "Particpante " + i, "Usuario " + i, "Pass " + i, "Comentarios
para " + i);
listaPariticipantes.add(p);
}
Y en lugar de pasar un objeto de tipo "Connection" al mtodo "fillReport" del
"JasperFillManager" pasamos un nuevo objeto "JRBeanCollectionDataSource" construido
con la lista "listaPariticipantes":
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, new
JRBeanCollectionDataSource(listaPariticipantes));
Al final nuestra clase "Main" queda as:
{
List listaPariticipantes = new ArrayList();
for (int i = 1; i <= 10; i++)
{
}
JasperReport reporte = (JasperReport) JRLoader.loadObject("reporte2.jasper");
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, new JRBeanCollectionDataSource(listaPariticipantes));
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new java.io.File("reporte2PDF_2.pdf"));
}
PARTE 3: Parmetros y Variables
En la parte anterior vimos como hacer uso de los Fields para indicar la
posicin dentro de nuestro reporte en la que deben quedar los valores
que obtenemos de nuestra aplicacin Java.
Ahora hablar de los otros dos tipos de expresiones que proporciona
JasperReports: Parameters y Variables. Y la forma en la que podemos
usarlos para hacer ms dinmicos nuestros reportes.
Para ello seguiremos usando el ejemplo de la segunda parte.
Abrimos iReport y el reporte de la parte anterior ("reporte2.jrxml"). En
este momento nuestro reporte debe verse como en la siguiente imagen:
En donde solo tenemos textos estticos y "fields" para mostrar un
reporte bsico de los datos de ciertos participantes. Si lo recuerdan, la
salida del reporte al generarlo desde nuestra aplicacin Java, era la
siguiente:
Ahora pasaremos a agregar "Parameters" a este
reporte. Como dije en el tutorial anterior: los
parmetros son valores que usualmente se pasan al
reporte desde el programa que crea el "JasperPrint"
del reporte (nuestra aplicacin Java) haciendo uso de
un "java.util.Map".
En este caso pasaremos dos parmetros: el ttulo del
reporte, y el nombre del autor del mismo.
Al igual que con los Fields, para poder hacer uso de un
parmetro primero hay que declararlo en el "Report
Inspector" (situado en el panel izquierdo del iReport),
por lo que nos dirigimos a esta ventana y hacemos clic
derecho sobre el nodo "Parameters". Al hacer esto se
abrir un men contextual. Seleccionamos la opcin
"Add Parameter" (la nica habilitada).
Con esto se agregar un nuevo parmetro llamado "parameter1" de tipo
"java.lang.String". Cambiamos en nombre del parmetro en la ventana de
propiedades a "titulo" (recuerden que este nombre es el que deberemos
usar desde nuestra aplicacin Java para establecer el valor del
parmetro).
Agregamos otro parmetro llamado "autor" de la misma forma que
agregamos el de "titulo".
Ahora eliminamos el elemento que tenamos como ttulo del reporte (el
que contiene el texto esttico "Reporte de Participantes") y lo
reemplazamos por el parmetro "titulo" arrastrndolo desde la ventana
del "Report Inspector" a la banda "Title".
Ajustamos este elemento
para que tenga el mismo
formato que el ttulo que
tenamos anteriormente.
Ahora agregamos el
segundo parmetro
("autor") en la banda
"Page Header", la cual se
repite en la parte
superior de cada una de
las pginas (en la primer
pgina aparece despus
del ttulo), arrastrndolo
a esta banda.
Si dejamos esta expresin tal y como est ("$P{autor}") solo se mostrar en
nombre del autor en la parte superior de cada una de las pginas (por ejemplo si
el autor del reporte es "Juan", solo veremos la palabra "Juan" en la parte superior
de los reportes). Esto podra no ser claro para quienes revisen este reporte, por lo
que queremos indicar de forma explcita que a lo que se refiere el valor de este
parmetro es el nombre del autor. Para hacer esto nos dirigimos a la ventana de
propiedades de este parmetro (para lo cual debemos tenerlo seleccionado) y
buscamos la categora "Text field properties". Ah se encuentra una propiedad
llamada "Text Field Expression" cuyo valor es "$P{autor}".
Lo que haremos es editar esta
expresin para anteponer la palabra
"Autor: ". Para hacer esto presionamos
el botn "...", con lo que se abrir una
ventana que nos permitir editar la
expresin. En esta ventana
modificamos la expresin "$P{autor}"
para que quede "Autor: " + $P{autor}.
Con esto lo que logramos es que a la
cadena esttica "Autor: " se le
concatene el valor de la expresin
dinmica "$P{autor}". Por lo que ahora
el lo que aparecer en la parte superior
de cada pgina del reporte ser la
cadena "Autor: Juan".
Ahora presionamos el botn "Compile Report" para que se genere el reporte compilado
"reporte2.jasper".
Veamos una vista previa del reporte, para esto hacemos clic en la pestaa "Preview". Nos
pedir los valores de los dos parmetros. Si colocamos para el parmetro "titulo" el valor
"Reporte" y para el parmetro "autor" el valor "Alex" el preview que veremos ser el siguiente:
Ahora veremos cmo pasarle estos valores desde nuestra aplicacin Java, por lo que abrimos
nuestro IDE de trabajo, NetBeans.
Ah nos dirigimos a la clase "Main" que creamos la ltima vez y buscamos la lnea en donde
creamos nuestro objeto "JasperPrint":
Y antes de esta lnea crearemos un objeto "java.util.Map" que contendr nuestros parmetros.
Colocaremos el nombre de los parmetros (en este caso "autor" y "titulo") como llave y sus
respectivos valores, "Juan" para el autor y "Reporte Participantes" para el ttulo, como valores.
Map<String, Object> parametros = new HashMap<String, Object>();
parametros.put("autor", "Juan");
parametros.put("titulo", "Reporte Participantes");
Y pasamos este "Map" como el segundo parmetro del mtodo "fillReport", al que hasta ahora
le hemos pasado "null":
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, parametros, new
El cdigo de nuestro mtodo "main" queda as:
{
List<Participante> listaPariticipantes = new ArrayList<Participante>();
for (int i = 1; i <= 10; i++)
{
}
JasperReport reporte = (JasperReport) JRLoader.loadObject("reporte2.jasper");
Map<String, Object> parametros = new HashMap<String, Object>();
parametros.put("autor", "Juan");
parametros.put("titulo", "Reporte Participantes");
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, parametros, new JRBeanCollectionDataSource(listaPariticipantes));
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new java.io.File("reporte3PDF.pdf"));
}
Si ejecutamos nuestro
reporte obtendremos un
archivo con el siguiente
contenido:
Como podemos ver los parmetros "titulo" y "autor" han sido reemplazados
por los valores "Reporte Participantes" y "Juan" respectivamente.
Gracias a los parmetros podemos pasar valores (como en este caso
cadenas, pero podemos pasar prcticamente cualquier tipo de objeto) a
nuestro reporte directamente desde nuestra aplicacin Java.
Ahora veremos el ltimo tipo de expresin que JasperReports nos
proporciona, las Variables.
En este caso usaremos dos variables. La primera ser una de las variables
internas que ya proporciona JasperReports: PAGE_NUMBER, que nos dice el
nmero de la pgina actual. En este caso como el reporte solo tendr una
pgina solo aparecer el nmero 1, pero pueden extender el ejemplo para
que se generen ms pginas.
La segunda variable que usaremos ser una variable creada por nosotros
mismos y nos mostrar la suma de los puntos de los Participantes (en este
momento los Participantes no tienen puntos, por lo que tendremos que
agregarlos).
Lo primero que haremos es modificar la clase "Participante" agregando el
atributo "puntos" de tipo "int" con sus correspondientes setters y getters:
private int puntos;
public int getPuntos()
{
return puntos;
}
public void setPuntos(int puntos)
{
this.puntos = puntos;
}
y en nuestro mtodo "main" agregamos, en el ciclo que crea los objetos
"Participante", el siguiente cdigo para establecer los puntos de cada uno de
los Participantes:
p.setPuntos(i);
Ahora regresamos a iReport y agregamos un nuevo Field en la ventana
"Report Inspector" llamado "puntos" de tipo "java.lang.Integer". Este field
ser usado para mostrar los puntos que tiene cada uno de los Participantes.
Agregamos una columna, dentro de la banda "Details 1", para mostrar este
field:
Si compilamos nuestro reporte y ejecutamos nuestra aplicacin Java
debemos ver un reporte con el siguiente contenido:
Ahora agregaremos la variable que realizar la suma de los puntos de todos
los Participantes. Para esto agregamos una nueva variable en el nodo
"Variables" de la ventana "Report Inspector" haciendo clic derecho sobre
este nodo y seleccionando la opcin "Add Variable" del men contextual
que se abre.
Modificamos sus propiedades en la ventana "Properties" cambiando su
nombre a "sumaPuntos", su "Variable Class" a "java.lang.Integer", y
"Calculation" a "Sum" (con esto indicamos que la variable mantendr la
suma de los valores que indicaremos ms adelante, otras opciones incluyen
un contador, el promedio, el valor ms alto, etc.).
Ahora indicaremos la suma de cules valores son los que queremos que se
almacene en este variable. Para eso hacemos clic en el botn "..." de la
propiedad "Variable Expression", con lo que se abrir una nueva ventana. Es
esta nueva ventana indicaremos de dnde se tomarn los valores para la
suma. Podemos usar una expresin tan compleja como necesitemos. Como
en este caso solo queremos realizar la suma de los puntos escribimos
$F{puntos}". Y presionamos el botn "OK" para confirmar.
Modificamos sus propiedades en la ventana "Properties" cambiando su
nombre a "sumaPuntos", su "Variable Class" a "java.lang.Integer", y
"Calculation" a "Sum" (con esto indicamos que la variable mantendr la
suma de los valores que indicaremos ms adelante, otras opciones incluyen
un contador, el promedio, el valor ms alto, etc.).
Ahora indicaremos la suma de cules valores son los que queremos que se
almacene en este variable. Para eso hacemos clic en el botn "..." de la
propiedad "Variable Expression", con lo que se abrir una nueva ventana. Es
esta nueva ventana indicaremos de dnde se tomarn los valores para la
suma. Podemos usar una expresin tan compleja como necesitemos. Como
en este caso solo queremos realizar la suma de los puntos escribimos
"F{puntos}". Y presionamos el botn "OK" para confirmar.
Ahora solo arrastramos nuestra variable "sumaPuntos" desde el "Report Inspector"
hasta la banda "Summary". Esta banda se muestra cuando ya se han mostrado todos
los datos de la banda "Details 1" y se muestra justo abajo de ella.
Agregar un texto esttico y una lnea en esta banda solo para que se vea un poco
mejor. Nuestro reporte hasta ahora debe verse as:
Ahora para terminar agregaremos la variable "PAGE_NUMBER" que nos dice el nmero de
pgina actual en el reporte. Arrastramos esta variable desde el "Report Inspector" hasta la
banda "Page Footer", la cual se muestra en la parte inferior de cada pgina.
Agregar tambin un texto esttico solo para indicar que el valor que estamos mostrando
corresponde al nmero de pgina. Al final el reporte queda as:
Ahora guardamos y compilamos
nuestro reporte y ejecutamos
nuestra aplicacin desde el
NetBeans. El reporte generado
debe verse as:
PARTE 4: Grficas en reportes
Algunas veces es ms fcil entender la informacin cuando se nos
presenta en una imagen. En el caso de los datos, cuando estamos
haciendo comparaciones, lo ms fcil es visualizarlos en una grfica de
barras o en una grfica de pie o pastel.
Para este ejemplo los datos que graficaremos son las ventas de consolas
de ltima generacin (Wii, XBox360, y PS3). Tomaremos estos datos de
VG Chartz que, aunque no son cifras oficiales, mantiene sus datos
actualizados. En el momento de escribir este tutorial las ventas van:
Wii: 41.6% para nosotros ser 41%
XBox 360: 29.6% para nosotros ser 30%
PS3: 28.8% para nosotros ser 29%
Bien, para comenzar crearemos un nuevo proyecto Java standalone en
NetBeans (File -> New Project... -> Java -> Java Application), le asignamos un
nombre (que en mi caso ser ReporteGrafica) y presionamos el botn "Finish"
para que el nuevo proyecto se genere y veamos en el editor nuestra clase Main.
Agregamos al nodo "Libraries" de nuestro proyecto la biblioteca "JasperReports"
que creamos en la primer parte del tutorial y el jar "commons-logging-
1.1.1.jar",como lo hemos venido haciendo hasta ahora.
Adicionalmente debemos agregar dos jars ms que nos permitirn generar las
grficas. Puesto que JasperReports hace uso de JFreeChart para generar las
grficas debemos agregar dos de sus jars: jfreechart.jar y jcommon.jar. Si
bajaron JasperReports en el archivo .zip que contiene las bibliotecas de soporte
entonces ya tienen estos jars (que se encuentran en el directorio lib del .zip
anterior), solo deben agregarlos al nodo "Libraries" del proyecto.
Ahora necesitamos, como en los casos anteriores, una clase cuyas instancias
mantendrn los datos que mostraremos en el reporte. En este caso, como
estamos hablando de consolas, creo que lo ms adecuado es que esta sea una
clase "Jugador". As que agreguemos esta clase a nuestro proyecto.
Esta clase tendr tan solo tres atributos: un id , un nombre para distinguir al
usuario, y el nombre de la consola que tiene (que es el dato que nos interesa
para crear la grfica).
El cdigo de la clase Jugador queda de
la siguiente forma:
public class Jugador
{
private int id;
private String consola;
public Jugador(int id, String nombre, String consola)
{
this.id = id;
this.consola = consola;
}
public String getConsola()
{
return consola;
}
public void setConsola(String consola)
{
this.consola = consola;
}
public int getId()
{
return id;
}
{
this.id = id;
}
{
return nombre;
}
{
}
}
El cdigo de la clase Main es el cdigo estndar que hemos estado usando en
esta serie de tutoriales de JasperReports, con excepcin de la parte en la que se
crean los Jugadores. En este caso usaremos tres ciclos, uno para cada consola.
Por lo que esta parte del cdigo queda ms o menos as (listaJugadores es una
lista de objetos Jugador):
for (int i = 1; i <= 49; i++)
{
listaJugadores.add(new Jugador(i, "Jugador " + i , "Wii"));
}
for(int i = 50; i <= 79; i++)
{
listaJugadores.add(new Jugador(i, "Jugador " + i , "XBox"));
}
for(int i = 80; i <= 100; i++)
{
listaJugadores.add(new Jugador(i, "Jugador " + i , "PS3"));
}
Ahora abriremos el iReport y comenzaremos con el diseo de nuestro reporte.
Creamos un nuevo reporte vaco yendo al men Archivo -> New... -> Empty
Report. En la ventana que se abre colocamos el nombre de nuestro reporte
(reporteGrafica.jrxml) y lo guardamos en el directorio raz de nuestro proyecto
de NetBeans:
Ahora abriremos el iReport y comenzaremos con el diseo de nuestro reporte.
Creamos un nuevo reporte vaco yendo al men Archivo -> New... -> Empty
Report. En la ventana que se abre colocamos el nombre de nuestro reporte
(reporteGrafica.jrxml) y lo guardamos en el directorio raz de nuestro proyecto
de NetBeans:
Comencemos colocando un ttulo y los encabezados de nuestras columnas de
datos usando textos estticos, as como los fields para los datos que
obtendremos de cada uno de los objetos Jugador (id, nombre, y consola) de la
misma forma que lo hicimos en este tutorial (no olviden guardar de forma
constante sus avances para no perder su trabajo):
Ahora vienen los pasos interesantes. Primero debemos crear un
grupo. Un grupo nos permite tratar de forma especial un conjunto
de datos que se encuentran asociados (es como un group by en
SQL). Adems, al crear un grupo se genera tambin una variable
que mantiene el conteo de los elementos de cada grupo (como si
hicieramos un count sobre los elementos de los grupos en SQL).
En este caso el grupo que nos interesa es el de las consolas.
Si estuvieramos usando consultas SQL obtener estos datos sera
sencillo. Es ms, si hubieramos creado nuestro reporte usando el
"Report Wizard" podramos haber creado el grupo que nos interesa
desde ah. Pero como estamos usando un DataSource propio,
tenemos que agregar el grupo a mano. Afortunadamente es muy
sencillo agregar grupos desde iReport. Lo nico que debemos hacer
es click derecho sobre el nodo "report name" (la raz de los
elementos del proyecto) en el panel "Report Inspector". Con esto
se abrir un men contextual. De este seleccionamos el elemento
"Add Report Group":
Al hacer esto se abrir la ventana del "Group Wizard". En esta colocamos el
nombre del grupo, en este caso ser CONSOLAS, y en el campo "Group by the
following report object:" seleccionamos el field "consola" que creamos
anteriormente. Con esto conseguiremos que el nuevo grupo que se crear se
haga con respecto al valor del atributo "consola" de nuestros objeto "Jugador".
Presionamos el botn "Siguiente >" y se nos mostrarn dos radio buttons
preguntando si quieremos agregar la cabecera (header) y el pie de pagina
(footer) del grupo. Nosotros deseleccionamos estas opciones (se encuentran
seleccionadas por default) ya que no nos interesa agregar ninguno de estos
elementos. Para terminar presionamos el botn "Finalizar" y ya tendremos
agregado nuestro grupo.
No es muy obvio el que este grupo existe, de hecho los nicos indicadores que
tenemos son que se han agregado en la zona de las bandas del "Report
Inspector" dos nuevas bandas: "CONSOLAS Group Header" y "CONSOLAS Group
Footer", adems se ha agregado una variable llamada "CONSOLAS_COUNT",
que es la variable que nos interesa y por la que hemos creado el grupo, que
mantendr el nmero de jugadores que tienen cada una de las consolas:
Ahora agregaremos nuestra grfica. Para eso arrastraremos desde la Paleta de
elementos del reporte un "Chart" y lo colocamos en la banda "Summary"
(ajusten el tamao de la banda para que la grfica se vea bien).
iReport Confeccin de informe
Al arrastrar la grfica se abrir
una nueva ventana
preguntndonos qu tipo de
grfico queremos mostrar. En
este caso seleccionaremos el
grfico de pie o de pastel (la
primer o segunda opcin):
Presionamos el botn "OK" y la
grfica se agregar a nuestro
reporte, ajstenla para
que abarque toda el rea de la
banda.
Lo ltimo que haremos es configurar la grfica para que obtenga los datos
de los campos y variables que nos interesa mostrar. Para esto, hacemos
click derecho sobre la grfica, con lo que se abrir un men contextual. En
este men seleccionamos la opcin "Chart Data".
Con lo que se abrir una nueva ventana, y en esta ventana seleccionamos
la pestaa "Details". En esta pestaa configuraremos tres valores:
Key expression
Value expression
Label expression
La "Key expression" dice cul ser la base que se usar para cada uno de
las piezas de la grfica. En nuestro caso queremos que cada trozo muestre
las consolas. Por lo que colocamos como valor $F{consola}.
La "Value expression" dice cul ser el tamao de cada una de las piezas
de la grfica. Nosotros queremos que cada pieza sea equivalente al
nmero de consolas que se han comprado. Por lo que colocamos como
valor $V{CONSOLAS_COUNT}.
Label expression es la etiqueta que se mostrar para cada valor. Nosotros
queremos mostrar el nombre de la consola junto con el nmero de
unidades que se han vendido de cada una. Por lo que colocamos como
valor $F{consola} + " - " + $V{CONSOLAS_COUNT}. Lo cual colocar como
valor el nombre de la consola, concatenndole el signo " - " y
concatenndole el nmero de consolas vendidas (el nmero de jugadores
que han comprado cada una de las consolas).
Presionamos el botn "Close" y hemos terminado con nuestro reporte.
Cambiamos a la vista "Preview" para compilar el reporte. No se nos
mostrar nada del reporte final. De hecho los regresar a la vista del
"Designer" y mostrar una excepcin en la ventana de salida indicando
algo as: "Key is null in pie dataset". Esto es normal ya que la grfica no
puede generarse ya que no existen datos. Lo importante es que se haya
generado el archivo "reporteGrafica.jasper".
Ahora ejecutamos nuestra aplicacin, con lo que debe generarse nuestro
reporte en PDF y debemos ver, al final del reporte, la siguiente grfica:
Finalmente este es el codigo de la clase Main (omitiendo los imports):
public class Main
{
{
List listaJugadores = new ArrayList();
for (int i = 1; i <= 49; i++)
{
}
for(int i = 50; i <= 79; i++)
{
}
for(int i = 80; i <= 100; i++)
{
}
JasperReport reporte =
(JasperReport)JRLoader.loadObject("reporteGrafica.jasper");
JasperPrint jasperPrint =
JasperFillManager.fillReport(reporte, null, new
JRBeanCollectionDataSource(listaJugadores));
exporter.setParameter(JRExporterParameter.JASPER_PRINT,
jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE,
new File("reporte grafica.pdf"));
}
}
PARTE 5: Grupos y subgrupos
Ahora veremos cmo deben ser usados los grupos para, bueno, agrupar
un conjunto de datos relacionados y mostrar estos grupos de forma clara
en el reporte. Usaremos la misma idea del tutorial anterior, en la que se
mostraron las ventas de las consolas de ltima generacin (Wii, XBox 360,
y PS3). Solo que en este caso mostraremos por cada consola el nombre de
los jugadores que las han comprado, separados claramente de los que han
comprado las otras consolas.
Para comenzar creamos un nuevo proyecto en NetBeans (File -> New
Project... -> Java -> Java Application). Damos un nombre y una ubicacin a
nuestro proyecto y presionamos el botn "Finish" para que la clase Main
aparezca en nuestro editor.
Recuerden agregar al nodo "Libraries" del panel "Projects" la biblioteca
"JasperReports" que creamos en la primer parte del tutorial.
Usaremos la misma clase "Jugador" en en el tutorial anterior para
mantener los datos que sern mostrados en el reporte.
El cdigo que colocaremos en la clase Main es el mismo que en el tutorial
anterior. Solo que en este caso en vez de tener 100 jugadores,
modificaremos los ciclos for para tener solo 10. Por lo tanto quedan de la
siguiente forma:
for (int i = 1; i <= 4; i++)
{
}
for(int i = 5; i <= 7; i++)
{
}
for(int i = 8; i <= 10; i++)
{
}
Ahora abrimos iReport y creamos un nuevo reporte vacio (Archivo ->
New... -> Empty Report). En la ventana que se abre le damos un nombre al
reporte (reporteGrupo.jrxml) y lo guardamos en el directorio raz del
proyecto de NetBeans. Presionamos el botn "Finalizar" para que
aparezca la plantilla vacio de nuestro reporte.
Colocamos el ttulo del reporte en la banda "Title" usando un texto
esttico. Tambin agregamos los fields correspondientes para los datos de
los objetos Jugador (id, nombre, y consola). En esta ocasin en la banda
"Detail" solamente colocamos los fields id y nombre (ya que los grupos
sern formados en base al field consola). Y no colocamos nada en la banda
"Column Header":
Ahora crearemos el grupo correspondiente a las consolas. Para esto
hacemos click derecho en el nodo "report name" del panel "Report
Inspector". Y en el men contextual que aparece seleccionamos la opcin
"Add Report Group":
Con esto se abrir la ventana "New group wizard". En ella debemos
introducir el nombre del grupo, que en este caso ser "CONSOLAS" y el
campo sobre el cual se crearn los grupos que, como habiamos dicho, ser
el campo "consola":
Presionamos el botn "Siguiente >". En la pantalla siguiente dejamos
seleccionadas las dos opciones ("Add the group header" y "Add the group footer").
Presionamos en botn "Finalizar" con lo que veremos que en la plantilla de
nuestro reporte han aparecido dos nuevas bandas, "CONSOLAS Group Header" y
"CONSOLAS Group Footer", adems de una nueva variable, CONSOLAS_COUNT:
Agregar un cuadro negro ("Rectangle" de la paleta de elementos del reporte) en
la banda "CONSOLAS Group Header" para poder distinguirlo en el momento de
generar el reporte final. Adems arrastrar a esta banda el field $F{consola} que
creamos anteriormente. Al arrastrar este field se nos preguntar qu es lo que
queremos mostrar: el valor del campo ("The field value") o el resultado de una
funcin de agregacin ("The result of an aggregation fuction"). Como lo que
queremos mostrar es el valor del campo dejamos seleccionada la primera opcin
(si queremos mostrar el nmero de los elementos del grupo podemos volver a
arrastrar este field a la banda).
Si, al igual que yo, agregaron el
cuadro negro en la banda, ser
neccesario que cambien el
color de la letra del campo
(Forecolor) a blanco para
poder verlo.
El reporte final debe verse
ms o menos as:
Ahora cambiamos a la pestaa
"Preview" para que se compile
nuestro reporte y genere, en el
mismo directorio en el que
colocamos nuestro archivo
"reporteGrupo.jrxml", el archivo
"reporteGrupo.jasper".
Ahora regresamos al NetBeans y
ejecutamos nuestra aplicacin. Esto
generar un archivo PDF en el
mismo directorio que los archivos
.jrxml y .jasper. El contenido del
reporte el siguiente:
Como podemos ver, los tres grupos (uno por cada consola) se muestran de
forma independiente uno de otro. Adems en cada grupo se listan solo los
jugadores que tienen la consola del grupo.
El cdigo final de la clase Main es el siguiente:
public class Main
{
{
List listaJugadores = new ArrayList();
for (int i = 1; i <= 4; i++)
{
listaJugadores.add(new Jugador(i, "Jugador " + i, "Wii"));
}
for (int i = 5; i <= 7; i++)
{
listaJugadores.add(new Jugador(i, "Jugador " + i, "XBox"));
}
for (int i = 8; i <= 10; i++)
{
listaJugadores.add(new Jugador(i, "Jugador " + i, "PS3"));
}
JasperReport reporte = (JasperReport) JRLoader.loadObject("reporteGrupo.jasper");
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, new JRBeanCollectionDataSource(listaJugadores));
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new File("reporte grafica.pdf"));
}
}
PARTE 6: SUBREPORTES
Los subreportes son una caracterstica importante de una herramienta generadora de
reportes. Permiten crear reportes ms complejos y simplificar el trabajo de diseo.
Los subreportes son muy tiles cuando se crea un reporte maestro de detalles o
cuando la estructura de un solo reporte no es suficiente para describir la complejidad
del documento de salida deseado.
Un subreporte es solamente un reporte que ha sido incorporado a otro reporte. De
hecho podemos tener subreportes dentro de otros subreportes.
En esta ltima parte veremos cmo realizar subreportes .Veremos dos ejemplos, el
primero mostrar cmo hacer los subreportes mediante una conexin JDBC a la base
de datos. El segundo mostrar como hacerlo con un DataSource propio.
En ambos casos crearemos un reporte de alumnos de una escuela y subreportes de
cada uno de los alumnos con la lista de materias que tiene cada uno (aunque por
facilidad todos tendrn las mismas materias cuando hagamos el ejemplo con el
DataSource propio).
1 - SUBREPORTES CON CONEXIN A BASE DE DATOS
Lo primero que haremos es generar una base de datos de prueba. Yo hare uso de MySql 5.1,
pero pueden usar el manejador que ms les guste. Creamos una base de datos llamada
"pruebaReportes" y usamos el siguiente script para crear la tabla "alumnos":
CREATE TABLE alumnos (
ID bigint(21) NOT NULL,
NOMBRE`varchar(100) NOT NULL,
CLAVE varchar(100) NOT NULL,
PRIMARY KEY (ID)
) ENGINE=InnoDB DEFAULT CHARSET=latin1
despus este para las materias:
CREATE TABLE materias (
ID BIGINT(21) NOT NULL,
NOMBRE VARCHAR(100) NOT NULL,
PRIMARY KEY (ID)
) ENGINE=INNODB DEFAULT CHARSET=latin1
y finalmente esta ser la tabla intermedia, o tabla de unin de las dos anteriores
(ya que se generar una relacin N:M entra ambas):
CREATE TABLE alumnos_materias (
ALUMNO_ID BIGINT(21) NOT NULL,
MATERIA_ID BIGINT(21) NOT NULL,
PRIMARY KEY (ALUMNO_ID, MATERIA_ID),
FOREIGN KEY (ALUMNO_ID) REFERENCES alumnos(ID),
FOREIGN KEY (MATERIA_ID) REFERENCES materias (ID) ) ENGINE=INNODB
DEFAULT CHARSET=latin1
Ahora que tenemos las tablas usaremos el siguiente script para llenarlas:
INSERT INTO alumnos VALUES (1, 'Alumno 1', '00001');
INSERT INTO materias VALUES (1, 'Matematicas');
INSERT INTO materias VALUES (2, 'Fisica');
INSERT INTO materias VALUES (3, 'Quimica');
INSERT INTO materias VALUES (4, 'Biologia');
INSERT INTO materias VALUES (5, 'Historia');
INSERT INTO materias VALUES (6, 'Geografia');
INSERT INTO alumnos_materias VALUES (1, 1);
Ya con los datos listos procedemos a crear el proyecto en NetBeans ("File -> New
Project... -> Java -> Java Application"). Con lo que se crear una clase Main que
aparecer en nuestro editor.
Por el momento dejaremos as el proyecto de NetBeans y procederemos a crear
la plantilla de nuestro reporte desde iReport.
Como en esta ocasin tenemos una base de datos, usaremos el "Report
Wizard", por lo que vamos al men "Archivo -> New.. -> Report Wizard". Con
esto se abrir el wizard de 7 pasos que expliqu en la primera parte de este ppt.
El paso 2 (en el que empieza el wizard) nos pide dar un nombre al archivo del
reporte y una ubicacin. Denle el nombre que gusten (en mi caso
"reporteMaestro.jrxml") y gurdenlo en la carpeta raz del proyecto de
NetBeans que acabamos de crear.
Presionamos el botn "Siguiente >" para ir la paso 3. Aqu debenos seleccionar
el Data Source que se usar para generar el reporte. Si ya tienen creado el
datasource para la base de datos "pruebaReportes" pueden seleccionarla aqu.
Sino no se preocupen, este es el momento para crearlo.
Para crear el datasource que usaremos hacemos click en el botn "New":
Esto abrir una ventana en la que
tendremos que seleccionar el tipo de
Datasource que queremos usar. En
nuestro caso ser un "Database JDBC
connection" (la primer opcin).
Presionamos el botn
"Next >". En la siguiente
pantalla debemos darle un
nombre y algunos
parmetros al datasource,
como la direccin del
servidor y el nombre de la
base de datos.
Para probar que la
conexin puede
establecerse, hagan click
en el botn "Test" y, si
todo estpa bien, debe
aparecer un mensaje
como el siguiente:
Si obtuvieron el mensaje anterior hagan click en "Aceptar" y posteriormente en
el botn "Save" para guardar el datasource.
Veremos que en la ventana del paso 3 del "Report Wizard" ahora tenemos un
textarea que nos indica que debemos introducir un query. Pueden usar el query
designer si gustan (haciendo click en el botn "Design Query") para crear la
query que usaremos para obtener todos los datos de la tabla "alumnos" (solo de
esa tabla). Al final la query debe ser ms o menos as:
SELECT
alumnos.ÌD` AS alumnos_ID,
alumnos.`NOMBRE` AS alumnos_NOMBRE,
alumnos.`CLAVE` AS alumnos_CLAVE
FROM
àlumnos` alumnos
Hacemos click en el botn
"Siguiente >" para ir al paso
4. En este paso tendremos
que seleccionar los
campos, de los que
acabamos de seleccionar,
que queremos mostrar en
el reporte. En este caso
solo queremos mostrar el
nombre y la clave del
alumno (el id lo usaremos
como un elemento auxiliar
para obtener los datos del
subreporte, por lo que es
necesario que tambin lo
releccionemos). Por lo que
seleccionamos todos los
campos:
Presionamos el botn "Siguiente >". En el paso 5 podemos seleccionar un
campo sobre el que queramos crear un grupo. Nosotros no queremos crear
ninguno, por lo que dejamos todo como est y presionamos el botn "Siguiente
>" para ir al paso 6 en el que seleccionaremos el layout del reporte. La opcin
por defecto ("Columnar Layout") esta bien, por lo que la dejamos y hacemos
click en "Siguiente >" para ir al paso final en el que nos felicitarn por haber
creado exitosamente nuestro reporte
Ahora podemos hacer click en el botn "Finalizar" para ver aparecer la plantilla
de nuestro reporte, en la pestaa "Designer", el cual debe verse de la siguiente
forma:
Modificaremos los textos estticos para que concuerden un poco ms con el
tipo de reporte que queremos lograr. Tambin eliminaremos las etiqueta y el
texto que muestran el valor de id ya que, como dijimos hace un momento, no
nos interesa mostrarlo:
Si generamos la vista previa del reporte veremos lo siguiente:
Ahora procederemos a agregar el subreporte. Este subreporte mostrar las
materias a las que esta inscrito cada uno de los alumnos.
Para esto arrastramos el elemento "Subreport" desde los "Report Elements" y lo
colocamos en la banda details, justo debajo de los campos de texto:
Al hacer esto se abrir la ventana del "Subreport Wizard" que es la que nos
guiar en el proceso de la creacin del subreporte:
El primer paso consiste en indicar si nuestro subreporte ser un reporte nuevo,
uno existente, o si solo queremos crear el elemento subrepote. Nosotros
crearemos un nuevo reporte (que es el que mostrar las materias a las que est
inscrito cada alumno), as que dejamos seleccionada la primera opcin ("Create
a new report") y hacemos click en el botn "Siguiente >".
En el paso 2 se nos preguntara qu datasource usaremos para este reporte.
Nosotros usaremos el datasource creado hace unos momentos (que en mi caso
se llamaba "Prueba Reportes"). Seleccionamos este en el men desplegable, con
los que nos aparecer un textarea para que coloquemos una query. Pueden usar
el query designer si gustan para obtener una query que seleccione todos los
campos de las tablas "alumnos_materias" y "materias" y haga un join entre
estas (que obtenga las materias que tiene cada alumno). La query final queda de
la siguiente forma:
SELECT
alumnos_materias.ÀLUMNO_ID` AS alumnos_materias_ALUMNO_ID,
alumnos_materias.`MATERIA_ID` AS alumnos_materias_MATERIA_ID,
materias.ÌD` AS materias_ID,
materias.`NOMBRE` AS materias_NOMBRE
FROM
`materias` materias INNER JOIN àlumnos_materias` alumnos_materias ON
materias.ÌD` = alumnos_materias.`MATERIA_ID`
Presionamos el botn "Siguiente >" para ir al paso 3, en el que se nos
preguntar qu campos de los regresados por la consulta queremos mostrar en
el reporte (o en este caso en el subreporte). A nosotros solo nos interesa
mostrar los campos que tienen que ver con la materia, por lo que solo
seleccionamos los campos "materias_NOMBRE" y "materias_ID":
Presionamos en botn "Siguiente >" para ir al paso 4. En este paso podemos elegir si
queremos crear un grupo, como nosotros no queremos crear ninguno, simplemente
dejamos todo como est y volvemos a presionar el botn "Siguiente >".
En el paso 5 podemos elegir el layout del reporte. Puden seleccionar el que quieran.
En mi caso dejar la opcin por default ("Columnar Layout") y presionamos el botn
"Siguiente >".
En el paso 6 podemos darle un nombe y una ubicacin al subreporte. Yo le llamar
"subreporteMaterias.jrxml" y lo guardar en el mismo directorio que el
"reporteMaestro.jrxml" (en la carpeta raz del proyecto de NetBeans). Tambin
podemos ejegir si queremos guardar la ruta del subreporte (para que el reporte
maestro sepa donde buscarlo) como un parmetro llamado $P{SUBREPORT_DIR}, o
como una ruta absoluta esttica. Lo mejor es elegir est ultima ya que modificaremos
la ruta para que busque el subreporte en en el mismo directorio que el reporte
maestro. As si los movemos de un directorio a otro, solo tendremos que
preocuparnos de llevarnos los dos juntos.
Presionamos una vez ms el botn "Siguiente >" para ir al ultimo paso.
En el paso final (el paso 7) debemos seleccionar cmo le pasaremos el
datasource al subreporte desde el reporte maestro. Tenemos 5 opciones:
Usar la misma conexin que el reporte maestro
Usar otra conexin
Usar una expresin de un JRDataSource
Usar un datasource vaco
No usar conexin o datasource alguno
Nosotros seleccionamos la primera opcin ya que queremos que el subreporte
use la misma conexin que el reporte maestro:
presionamos el botn "Finalizar" para mostrar el subreporte:
Modificamos un poco el diseo del reporte para que se vea bien al mostrarlo
dentro del reporte maestro (cambiamos unos textos, eliminamos otros, y
eliminamos la banda "Page Footer", tambin agregamos una lnea en la banda
"Summary" para identificar en el reporte final cuando termine la lista de
materias):
Ahora agregamos un
nuevo parmetro al
subreporte (click
derecho en el nodo
"Parameters" del
panel "Report
Inspector" y
seleccionamos "Aadir
Parameter") llamado
alumnos_ID de tipo
java.lang.Long.
Lo siguiente que haremos es el primero de los dos trucos para generar subreportes
en base a una conexin con base de datos: hacemos click sobre la ventana del
designer, pero fuera del reporte para que en el panel de propiedades aparezcan las
propiedades del "subreporteMaterias". Una vez en este panel buscamos la
propiedad "Query Text" de la seccin "More...":
Hacemos click en el botn "..." para que se abra una ventana que contiene el texto
de la consulta que creamos al crear el subreporte. Agregamos el final de la consulta
lo siguiente:
AND alumnos_materias.ÀLUMNO_ID`= $P{alumnos_ID}
Con esto lograremos que el subreporte se genere solo con las materias que
correspondan al alumno con el id que le indiquemos (lo cual haremos en un
momento y que de hecho es el segundo secreto).
Presionamos el botn "OK" para guardar la consulta.
Para terminar guardamos el subreporte y cambiamos a la vista "Preview" para
compilar el reporte y generar el archivo "subreporteMaterias.jasper". El preview
debe verse ms o menos as:
Ahora podemos regresar al reporteMaestro, el cual debe verse as (despus de
ajustar el tamao y la posicin del componente subreporte):
Seleccionamos el elemento subreporte y en el panel de propiedades buscamos el
elemento "Subreport Expression" de la seccin "Subreport Properties". Eliminamos
la ruta absoluta y dejamos solo el nombre del reporte
("subreporteMaterias.jasper"):
Ahora viene el segundo de los secretos para le generacin de los subreportes
usando conexin a base de datos. Seleccionamos el componente del subreporte y
buscamos en panel de propiedades y buscamos la propiedad "Parameters" de la
seccin "Subreport Properties":
Hacemos click en el botn "..." con lo que se abrir una ventana que nos
permite agregar parmetros que sern pasados del reporte maestro al
subreporte.
Si recuerdan nosotros indicamos en el subreporte que queremos que
muestre las materias en las que est inscrito un alumno con un particular.
Pues bien es aqu en donde pasamos ese dato, el id del alumno del que se
estn mostrando los datos. Este parmetro nos permitir pasarle el valor al
parmetro "alumnos_ID" que agregamos en el subreporte.
Presionamos el botn "Add" y agregamos como nombre del parmetro
"alumnos_ID" y como valor "$F{alumnos_ID}":
Presionamos "OK" en
ambas ventanas y
listo, ya tenemos
nuestro reporte
maestro con
subreportes.
Ahora guardamos el
reporte y cambiamos
a la vista de
"Preview". Ahora
debemos ver algo
como lo siguiente:
Con esto terminamos la parte que corresponde a iReport y podemos
regresar al NetBeans.
Si lo recuerdan dejamos la clase Main vacia, ahora procederemos a llenarla
con el cdigo para generar el reporte.
Recuerden que lo primero que debemos hacer es agregar al nodo
"Libraries" del panel "Projects" la biblioteca "JasperReports" que creamos
en el primer tutorial de la serie, el jar "commons-logging-1.1.1.jar", y el jar
"mysql-connector-java-5.1.7-bin.jar" que es el driver de la base de datos.
Una vez que tenemos esto, escribimos el siguiente cdifo en el mtodo main de la clase
Main:
Class.forName("com.mysql.jdbc.Driver");
Connection conexion =
DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebareportes", "user",
"pass");
JasperReport reporte = (JasperReport) JRLoader.loadObject("reporteMaestro.jasper");
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, conexion);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new
java.io.File("reportePDF.pdf"));
Al ejecutarlo se crear el archivo "reportePDF.pdf" en el directorio raz del
proyecto. Si abrimos el archivo veremos ms o menos lo siguiente:
Con lo que comprobamos que el reporte, junto con su subreporte, se ha
generado correctamente . Ahora veremos cmo hacer esto mismo usando
un DataSource propio.
2 - Subreportes con datasources propios
Para hacer un subreporte con un datasource propio tambin es necesario
conocer un par de secretos, los cuales revelar un unos momentos.
Lo primero que haremos es crear un nuevo proyecto en NetBeans ("File ->
New Project... ->Java -> Java Application"). Con lo que se crear una clase
Main que aparecer en nuestro editor.
Recuerden que tambin debemos agregar al nodo "Libraries" del panel
"Projects" la biblioteca "JasperReports" que creamos en el primer tutorial
de la serie.
Crearemos las clases que mantendrn los datos que mostraremos en el reporte ("Alumno" y "Materia"). La clase "Alumno"
tendr solo los atributos "id", "clave" y "nombre" (con sus correspondientes setters y getters):
public class Alumno
{
private int id;
private String clave;
public Alumno()
{
}
public Alumno(int id, String clave, String nombre)
{
this.id = id;
this.clave = clave;
}
public String getClave()
{
return clave;
}
public void setClave(String clave)
{
this.clave = clave;
}
public int getId()
{
return id;
}
{
this.id = id;
}
{
return nombre;
}
{
}
}
La clase "Materia" tendr los atributos "id" y "nombre":
public class Materia
{
private int id;
public Materia()
{
}
public Materia(int id, String nombre)
{
this.id = id;
}
public int getId()
{
return id;
}
{
this.id = id;
}
{
return nombre;
}
{
}
}
An falta agregar algunas cosas a la clase "Alumno", pero dejaremos este
proyecto a un lado por el momento mientras creamos la plantilla de
nuestro reporte desde iReport.
Abrimos el iReport y creamos un nuevo reporte vaco (men Archivo ->
New... -> Empty report). Asignamos al reporte un nombre (que en mi caso
ser "reporteMaestroDS.jrxml") y lo guardamos en la raz del proyecto de
NetBeans. Hacemos click en el botn "Finalizar" con lo que veremos
aparecer la plantilla vacia dentro de la vista "Designer".
Agregamos un par de fields (clave y nombre), y unos textos estticos para
que este reporte maestro sea similar al anterior (elimin algunas bandas
para que el reporte se vea ms claro):
Agregamos un field adicional llamado "materiasDS" de tipo
"net.sf.jasperreports.engine.JRDataSource". Como este tipo no aparece en
el combo para seleccin de tipo del field debemos escribirlo en la ventana
que se abre al presionar el botn "..." junto a este combo box:
Este field ser el que dir a JasperReports que debe llamar al getter
correspondiente de la clase Alumno que crearemos ms adelante para
preguntar a cules materias est inscrito (quedar claro cuando
escribamos el cdigo Java).
Ahora agregamos arrastramos el elemento "Subreport" de los "Report
Elements" a la banda "Details":
Al hacer esto se abrir la ventana "Subreport wizard". Como ahora no
usaremos una conexin no necesitamos un query, entonces no todos los pasos
aplican.
En el primer paso seleccionamos si queremos crear un nuevo reporte que
servir de subreporte, usar un reporte existente, o solo crear un elemento
subreporte. Seleccionamos la primera opcion ("Create a new report") y
presionamos el botn "Siguiente >".
En el paso 2 debemos seleccionar un datasource. Nosotros seleccionaremos el
"Empty datasource". Presionamos el botn "Siguiente >" para ir al paso 3, en el
que debemos seleccionar los fields que queremos agregar al subreporte. Como
nosotros no estamos usando una conexin, no tenemos fields para seleccionar,
as que simplemente presionamos el botn "Siguiente >".
En el paso 4 podemos escoger crear un grupo, aqui pasa lo mismo que en el
paso 3 as que seguimos adelante.
En el paso 5 seleccionamos un layout
para el subreporte. Pueden
seleccionar el que quieran, yo usar
el "Columnar Layout". Presionamos
el botn "Siguiente >".
Vamos al paso 6. Aqu le damos una
ubicacin y un nombre al proyecto.
Le dar de nombre
"subreporteMateriasDS.jrxml". Lo
guardamos en el mismo directorio
que el "reporteMaestroDS.jrxml".
Adems indicamos que queremos
que la ruta del subreporte se
almacene en una referencia esttica
absoluta ("Use a static absolute path
reference"):
Pulsamos el botn "Siguiente >"
para ir al ltimo paso.
En el paso 7 debemos indicar
cmo queremos pasar los datos
del reporte maestro al
subreporte. En este caso
queremos usar una
"JRDatasource expression" (la
tercer opcin), seleccionamos
esta opcin y agregamos la
expresin creada anteriormente
("$F{materiasDS}"), que ser la
que nos permita conectar el
reporte con el subreporte:
Presionamos el botn
"Finalizar" con lo que
aprecer el subreporte
en la vista de diseo:
Agregamos dos fields:
uno para el identificador
de la materia (de tipo
java.lang.Integer), y uno
para el nombre de la
materia (de tipo
java.lang.String):
Ahora arreglamos un poco el diseo del subreporte para que se vea
mejor: eliminamos la pgina "Page Footer", agregamos los fields que
acabamos de crear a la banda "Detail", y arreglamos un poco el ttulo.
Tambin agregamos una lnea en la banda "Summary" para saber
cuando termina el subreporte:
Guardamos el reporte y cambiamos a la vista preview para compilar el
subreporte. En la vista de preview deberan ver algo as (recuerden
seleccionar que quieren usar el "Empty datasource"):
Ahora regresemos al reporteMaestro, el cual debe verse as (despus
de ajustar el tamao y la posicin del componente subreporte):
Seleccionamos el elemento subreporte y en el panel de propiedades
buscamos el elemento "Subreport Expression" de la seccin "Subreport
Properties". Eliminamos la ruta absoluta y dejamos solo el nombre del
reporte ("subreporteMateriasDS.jasper"):
Esto es todo lo que se necestita hacer para generar el reporte, as que
cambiaremos a la vista "Preview" para compilar el reporte. Deben ver
algo as:
Ahora regresamos al proyecto de NetBeans.
Hace unos momentos creamos dos clases: "Alumno" y "Materia" y
dijimos que an les faltaba algo: falta crear la relacin entre un objeto
alumno y las materias que tiene. Para esto agregaremos un atributo de
tipo java.util.List a la clase "Alumno" que mantendr la lista de materias
a las que est inscrito el alumno (con sus correspondientes getters y
setters). Adems agregaremos un mtodo auxiliar que nos permitir
agregar las materias de una forma ms simple:
private List materias = new ArrayList();
public List getMaterias()
{
return materias;
}
public void setMaterias(List materias)
{
this.materias = materias;
}
public void addMateria(Materia materia)
{
this.materias.add(materia);
}
Ahora viene el segundo secreto para crear subreportes con datasource
propios: si lo recuerdan, en el reporteMaestro agregamos un
parmetro llamado "materiasDS" de tipo
"net.sf.jasperreports.engine.JRDataSource". Es por medio de este
parmetro que el reporte maestro pregunta a cada uno de los alumnos
con cules materias est relacionado (a cules est inscrito) para poder
generar el subreporte.
Es el alumno el encargado de regresar esta informacin a JasperReports
por medio de un getter, que debe estr formado siguiente el patrn de
getters como si tuviera un atributo llamado "materiasDS" de tipo
"net.sf.jasperreports.engine.JRDataSource". Por lo que el mtodo ser
de la siguiente forma:
public JRDataSource getMateriasDS() {
{
return new JRBeanCollectionDataSource(materias);
El cdigo completo de la clase "Alumno" queda de la siguiente forma:
import java.util.ArrayList;
import java.util.List;
import net.sf.jasperreports.engine.JRDataSource;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
/**
* @author Alex
*/
public class Alumno
{
private int id;
private String clave;
private List materias = new ArrayList();
public Alumno()
{
}
public Alumno(int id, String clave, String nombre)
{
this.id = id;
this.clave = clave;
}
public String getClave()
{
return clave;
}
public void setClave(String clave)
{
this.clave = clave;
}
public int getId()
{
return id;
}
{
this.id = id;
}
{
return nombre;
}
{
}
public List getMaterias()
{
return materias;
}
public void setMaterias(List materias)
{
this.materias = materias;
}
public void addMateria(Materia materia)
{
this.materias.add(materia);
}
public JRDataSource getMateriasDS()
{
return new JRBeanCollectionDataSource(materias);
}
}
Este es todo el cambio que necesita la clase "Alumno" para que
nuestros subreportes se generen exitosamente.
Ahora regresaremos a la clase "Main". Aqu agregaremos 2 ciclos for,
uno que crear las instancias de "Alumno" y las agregar a la lista que
posteriormente pararemos como DataSource y JasperReports, y un
ciclo interno que crear instancias de "Materia" y las relacionar con
los alumnos (todos los alumnos tendrn las mismas tres materias en
este caso). Los cliclos quedn as (listaAlumnos es un objeto List que
mantendr los objetos Alumno):
for (int i = 1; i <= 5; i++)
{
Alumno alumno = new Alumno(i, "0000" + i, "Alumno " + i);
listaAlumnos.add(alumno);
for (int j = 1; j <= 3; j++)
{
alumno.addMateria(new Materia(j, "Materia " + j));
}
}
El cdigo completo de Main es el siguiente (omitiendo los imports):
public class Main
{
{
List listaAlumnos = new ArrayList();
for (int i = 1; i <= 5; i++)
{
Alumno alumno = new Alumno(i, "0000" + i, "Alumno " + i);
listaAlumnos.add(alumno);
for (int j = 1; j <= 3; j++)
{
alumno.addMateria(new Materia(j, "Materia " + j));
}
}
JasperReport reporte = (JasperReport) JRLoader.loadObject("reporteMaestroDS.jasper");
JRBeanCollectionDataSource(listaAlumnos));
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new File("reporteMaestroDS.pdf"));
}
}
Esto generar un
archivo llamado
"reporteMaestroDS.pdf
" en el directrio raz del
proyecto de NetBeans.
El archivo tendr el
siguiente contenido:

5 Confeccindeinformes 121101080558 Phpapp01 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

5 Confeccindeinformes 121101080558 Phpapp01 PDF

Uploaded by

Copyright:

Available Formats

Desarrollo de interfaces:

You might also like