universidad don bosco facultad de estudios … · creación de reportes en java con ireport...
TRANSCRIPT
UNIVERSIDAD DON BOSCO
FACULTAD DE ESTUDIOS TECNOLÓGICOS
CICLO I
GUIA DE LABORATORIO #12
Programación Orientada a Objetos
Creación de Reportes en Java con iReport
I.OBJETIVOS
Que el estudiante:
Genere reportes con parámetros y sin parámetros en aplicaciones web utilizando iReport.
Sea capaz de generar reportes en diferentes formatos (pdf, html, etc).
II. INTRODUCCIÓN
JasperReports es un framework para desarrollar reportes tanto web como desktop en Java.
Aunque el formato fuente de un reporte en JasperReports es un archivo XML, existe una
herramienta que permite crear un reporte de manera visual, su nombre esiReport.
La herramienta iReport es un constructor / diseñador de informes visual, poderoso, intuitivo y fácil
de usar para JasperReports escrito en Java. Este instrumento permite que los usuarios corrijan
visualmente informes complejos con imágenes, subinformes, etc. iReport está además integrado
con JFreeChart, una de la biblioteca gráficas OpenSource más difundida para Java. Los datos para
imprimir pueden ser recuperados por varios caminos incluso múltiples uniones JDBC, TableModels,
JavaBeans, XML, etc.
Características de iReport
La lista siguiente describe algunas de las características importantes de iReport:
100% escrito en Java, es Open Source y gratuito.
Maneja el 98% de las etiquetas de JasperReports.
Permite diseñar con sus propias herramientas: rectángulos, líneas, elipses, campos de los
textfields, cartas, subreports (subreportes).
Soporta internacionalización nativamente.
Navegador de la estructura del documento.
Recopilador y exportador integrados.
Soporta JDBC.
Soporta JavaBeans como orígenes de datos (éstos deben implementar la interface
JRDataSource).
Incluye Wizard’s (asistentes) para crear automáticamente informes.
Tiene asistentes para generar los subreportes.
Tiene asistentes para las plantillas.
Facilidad de instalación.
III. PROCEDIMIENTO
En esta guía se mostrara como generar reportes para una aplicación web hecha con Java Server
Pages, utilizando como gestor de base de datos a MySQL. Para empezar estableceremos nuestro
entorno de trabajo (se indica la versión mínima de cada herramienta con la que debe disponer):
Netbeans 8.
Tomcat 8.0 o Glassfish 3.0 que será nuestro servidor web.
Aplicación para leer PDF.
Mysql 5.0 (en cargado de alojar la base de datos).
iReport y JasperReports: el primero será el entorno gráfico que nos ayudará a crear el
reporte, mientras que del segundo utilizaremos las librerías que servirán para compilar y
ejecutar el reporte. Estas son las siguientes:
v
Nota: Estas serán proporcionadas por el docente, si las descarga por su cuenta verifique que
sean coincidentes y que jasperreports-X.X.X.jary quejasperreports-fonts-X.X.X.jarseanlas
mismas que incluye su diseñador iReports. Por otra parte, desde la carpeta de instalación de
iReports puede encontrar todas las librerías necesarias (Ejemplo:iReport-
5.6.0\ireport\modules\ext
Base de datos
Antes de iniciar el diseño y la creación del reporte es importante tener una base de datos lista para
crear el reporte, así que debe crear la base de datos llamada zoologico con las tablas “especies” y
“mascota”, se proporciona el query para las tablas.
create table especies(
cod_especie varchar(8) primary key,
especie varchar(30)
) ENGINE=InnoDB;
create table mascotas(
cod_mascota varchar(8) primary key,
nombre varchar(30),
propietario varchar(60),
cod_especie varchar(8),
sexo char(1),
nacimiento date,
fallecimiento date,
index(cod_especie),
Foreign key(cod_especie)references especies(cod_especie)
) ENGINE=InnoDB;
Las tablas deben quedar relacionadas de la siguiente manera:
A cada tabla deberá introducir valores los cuales quedaran de la siguiente manera.
especies mascotas
iReport El siguiente paso consiste en crear reportes a partir de la base de datos zoológico, para ello deberá
ejecutar el programa iReport proporcionado por el docente y con el cual se van a realizar los pasos
de esta guía.
1. Abrir la carpeta iReport-5.6.0 si está en una distribución GNU\Linux deberá correr el
archivo ireport para correrlo desde la consola le deberá preguntar a su docente, si está
utilizando un sistema operativo Windows deberá ejecutar el archivo ireport.exe que se
encuentra en “/iReport-5.6.0/bin”. Al correr la aplicación se tiene que ver la siguiente
pantalla:
Nota: si tiene problemas a la hora de abrir iReport, ingresar a la ruta de ireport en la carpeta
/etc y buscar el archivo “ireport”, editarlo para que apunte la versión 7 de la JDK.
Editar archivo de configuración.
Al terminar de cargar deberá aparecer una pantalla como la que se muestra a continuación:
2. Una vez estando en la ventana principal de iReport deberemos establecer una conexión con
la base de datos, para realizar este paso dar clic sobre el elemento que dice “Step 1”.
Aparecen las opciones de conexión y deberemos seleccionar “Database JDBC connection”
y luego damos click en Next.
Aparecerá la ventana en la cual deberán ser ingresada las opciones necesarias para la
conexión.
Para la ventana anterior deberá hacer llenar los parámetros de la siguiente manera:
Name:mysql
JDBC URL:jdbc:mysql://localhost/zoologico
Username: root
Password: [el password]
Ahora tendrá que probar que la conexión sea buena, para ello deberá dar click en Test,
aparecerá una ventana que pedirá el password del usuario de la base de datos (ingresarla si
es que se tiene o dejarla en blanco).
Si la conexión fue exitosa aparecerá el mensaje que se muestra a continuación:
Después que se prueba la conexión deberemos dar click en “Save” y cerramos las ventanas
que queden abierta sobre esta parte de conexión.
3. Ir al menú Archivo y seleccionar la opción New, otra forma de hacer esto sería dando click
en el ícono “Step 2” que se muestra en la imagen de la derecha:
Aparecerá una ventana como la siguiente, en la que deberá seleccionar la plantilla“Simple
Blue” y dar clic sobre el botón “Launch Report Wizard”.
Como siguiente paso deberá poner un nombre al reporte, colocar en el campo
correspondiente“Reporte1”, damos click en siguiente.
Seguiremos el asistente el cual nos llevará paso a paso para la generación del reporte,
deberemos de seleccionar la conexión a la base de datos generada previamente y agregar la
consulta de los datos que queremos que se muestren en el reporte, para ello daremos click en
la opción “Design query”.
Tiene que aparecer una ventana en la que se muestran las tablas en la parte inferior izquierda
y que deberemos seleccionar para que aparezcan en la parte derecha de manera gráfica y
mostrando la relación que existen entre ellas.
Como siguiente paso deberemos seleccionar cada uno de los campos que necesitemos
mostrar en nuestro reporte, hay que tener en cuenta que según el orden de selección es el
orden que se muestra en el reporte final.
El orden de selección para esta guía práctica es el siguiente.
nombre
propietario
especie
sexo
nacimiento
Damos clic en OK y seguimos el asistente.
Ahora seleccionaremos los campos a mostrar, los pasaremos todos al otro cuatro en el
mismo orden.
El siguiente paso consiste en seleccionar si los datos estarán agrupados, pero para nuestro
ejemplo no los agruparemos.
Como último paso damos clic en Terminar.
El resultado debe verse como el siguiente:
Buscar la opción “Preview”, esta opción compilará el archivo y creará en la misma
ubicación donde fue guardado el reporte un nuevo archivo llamado Reporte1.jasper el cual
será utilizado posteriormente para llamarlo desde nuestra aplicación, ver el resultado en la
imagen que se muestra a continuación:
Para esta parte como puede observar el reporte fue creado, pero las columnas no poseen valores
descriptivos. Volver a la pestaña Designer cambiar los nombres a las columnas y ponerlo un título
que haga referencia al resultado mostrando en el reporte.
Llamando al reporte desde una página JSP
Para esta parte deberemos crear un proyecto web llamado Guia12POO1.
1. Agregar las librerías necesarias proporcionadas por el docente (ver la siguiente figura):
2. En la página index.jsp digitar el siguiente código.
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Ejemplo iReport</title>
</head>
<body>
<h2>Mi Primer Reporte con iReport</h2>
<a href="GenerarReporte">Generar Reporte</a>
</body>
</html>
3. Crear un DataSource llamado jdbc/mysql (siga el respectivo procedimiento para Tomcat
o Glassfish).
4. Crear un servlet llamado “GenerarReporte” dentro de un paquete llamado “servlet” y
sustituir el método “processRequest” por el siguiente código:
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException{
Connection conexion = null;
try {
response.setContentType("application/pdf");
//Nombre del reporte
response.setHeader("Content-Disposition","attachment;
filename=\"ReporteMascotas.pdf\";");
//Devuelve un objeto de la clase ServletOutputStream que modela un flujo de salida que
permite la escritura de datos a nivel de bytes
ServletOutputStream out = response.getOutputStream();
String pathReporte;
//Conexion BD
Context init = new InitialContext();
Context context = (Context) init.lookup("java:comp/env");
DataSource dataSource =(DataSource)context.lookup("jdbc/mysql");
conexion = dataSource.getConnection();
//Ruta del archivo .jasper
pathReporte=getServletContext().getRealPath("/Mascotas.jasper");
//Pasar de parametro la ruta del .jasper
JasperReport reporte = (JasperReport) JRLoader.loadObjectFromFile(pathReporte);
//Se necesitan 3 parametros el reporte,los parametros si el sql los necesitara y la
conexion a la BD
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte,null, conexion);
JRPdfExporter exporter = new JRPdfExporter();
exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
exporter.setExporterOutput(new SimpleOutputStreamExporterOutput(out));
SimplePdfExporterConfiguration configuration = new
SimplePdfExporterConfiguration();
exporter.setConfiguration(configuration);
exporter.exportReport();
exporter.exportReport();
}
catch (NamingException | SQLException | JRException ex) {
Logger.getLogger(CallReport.class.getName()).log(Level.SEVERE, null, ex);
}finally{
try {
conexion.close();
} catch (SQLException ex) {
Logger.getLogger(CallReport.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
5. Aparecerán una serie de errores, pero esto se debe a que no se han importado los
paquetes correspondientes, Agregar los siguientes paquetes para que el servlet pueda
correr exitosamente.
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.export.JRPdfExporter;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.export.SimpleExporterInput;
import net.sf.jasperreports.export.SimpleOutputStreamExporterOutput;
import net.sf.jasperreports.export.SimplePdfExporterConfiguration;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
6. El archivo Reporte1.jasper deberá copiarlo al proyecto en la misma ubicación de la
página index.jsp.
7. Al dar clic en Generar reporte aparecerá la ventana para guardar o para ver el
documento generado, el ejemplo debe verse igual al que se obtuvo con iReport.
Reportes con parámetros
Para esta parte crearemos reportes enviándoles parámetros desde la JSP, de tal manera que podamos
seleccionar los datos que necesitamos ver en el reporte.
1. Para comenzar regresamos al reporte creado anteriormente, seleccionamos en el menú
Archivo la opción “Guardar como” y le colocamos el nombre “Reporte2.jrxml”.
Sobre este nuevo archivo crearemos un parámetro, para ello buscar el menú lateral
llamado“Report Inspector” dar click derecho y seleccionar Agregar Parameter (ver la
siguiente figura).
2. Agregue un nuevo parámetro, por defecto se llamará “parameter1”, para cambiar dicho
nombre, podemos presionarF2 sobre el parámetro o vamos a la ventana de propiedades
buscamos Name y lo nombramos“especie”.
3. Para que el reporte reconozca el parámetro deberemos de cambiar el query para ello
seleccionamos el reporte y dar clic derecho y luego dar clic sobre la opción Edit Query
(ver la siguiente figura).
4. Debemos de modificar el query para que reciba el parámetro, dejarlo de como se muestra
en la siguiente figura.
Parámetro
Ventana de Propiedades
5. Dar Preview de nuevo al reporte, al ejecutarlo aparecerá la ventana para poner un
parámetro previo y así poder obtener un resultado, esto compilara de nuevo el archivo y
creara un jasper nuevo con el nombre Reporte2.jasper, copiarlo en el proyecto de
NetBeans en la misma ubicación que el anterior.
6. Crear la página“escogerespecie.jsp” y digitar el siguiente código.
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>iReport con parametros</title>
</head>
<body>
<h2>Reporte con Parametros</h2>
<form action="GenerarReporte1" method="POST">
<select name="selCombo" >
<option value="ES02">Perro</option>
<option value="ES03">Gato</option>
<option value="ES04">Serpiente</option>
<option value="ES05">Tortuga</option>
<option value="ES06">Ave</option>
</select>
<input type="submit" value="Enviar">
</form>
</body>
</html>
7. Crear un nuevo Servlet llamado “GenerarReporte1” y sustituir el método
processRequest con el siguiente codigo:
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("application/pdf");
//Nombre del reporte
response.setHeader("Content-Disposition","attachment;
filename=\"ReporteMascotas.pdf\";");
Connection conexion = null;
String pathReporte = "";
Map parameters = new HashMap();
String parametro = "";
try {
//Devuelve un objeto de la clase ServletOutputStream que modela un flujo de salida que
permite la escritura de datos a nivel de bytes
ServletOutputStream out = response.getOutputStream();
/* TODO output your page here. You may use following sample code. */
//Conexion BD
Context init = new InitialContext();
Context context = (Context) init.lookup("java:comp/env");
DataSource dataSource =(DataSource)context.lookup("jdbc/mysql");
conexion = dataSource.getConnection();
parametro=request.getParameter("tipoespecie");
//Cargamos parametros del reporte (si tiene).
parameters.put("cod_especie", parametro);
pathReporte=getServletContext().getRealPath("/report2.jasper");
JasperReport reporte = (JasperReport) JRLoader.loadObjectFromFile(pathReporte);
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte,parameters, conexion);
JRPdfExporter exporter = new JRPdfExporter();
exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
exporter.setExporterOutput(new SimpleOutputStreamExporterOutput(out));
SimplePdfExporterConfiguration configuration = new SimplePdfExporterConfiguration();
exporter.setConfiguration(configuration);
exporter.exportReport();
exporter.exportReport();
}catch (NamingException | SQLException | JRException ex) {
Logger.getLogger(CallReport.class.getName()).log(Level.SEVERE, null, ex);
}finally{
try {
conexion.close();
} catch (SQLException ex) {
Logger.getLogger(CallReport.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
8. Aparecerán una serie de errores, pero esto se debe a que no se han importado los
paquetes correspondientes, Agregar los siguientes paquetes para que el servlet pueda
correr exitosamente.
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.export.JRPdfExporter;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.export.SimpleExporterInput;
import net.sf.jasperreports.export.SimpleOutputStreamExporterOutput;
import net.sf.jasperreports.export.SimplePdfExporterConfiguration;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
9. Corremos la página escogerespecie.jsp y ahora ya podremos pasar parámetros al reporte
creado.
10. El resultado si se ha seleccionado Perro deberá ser similar al mostrado a continuación.
Creación de reportes en distintos formatos
Para esta parte crearemos una página jsp que nos permita seleccionar el formato de exportación de
nuestro reporte para ello seguir los siguientes pasos:
1. Crear una página jsp llamada “TipoReporte.jsp” y agregar el siguiente código:
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Seleccionar el Tipo de Reporte</title>
</head>
<body>
<h2>TIPOS DE REPORTE </h2>
<form action="TipoReporte" method="POST">
<select name="selTipo" >
<option value="pdf">PDF</option>
<option value="html">HTML</option>
<option value="csv">CSV</option>
<option value="xml">XML</option>
</select>
<input type="submit" value="Enviar">
</form>
</body>
</html>
2. Ahora crearemos un nuevo servlet que se llame “TipoReporte, sustituir el método
processRequest por el siguiente codigo.
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException{
Connection conexion = null;
String tipo=request.getParameter("selTipo");
try {
//Devuelve un objeto de la clase ServletOutputStream que modela un flujo de salida que
permite la escritura de datos a nivel de bytes
ServletOutputStream out = response.getOutputStream();
String pathReporte;
//Conexion BD
Context init = new InitialContext();
Context context = (Context) init.lookup("java:comp/env");
DataSource dataSource =(DataSource)context.lookup("jdbc/mysql");
conexion = dataSource.getConnection();
//Ruta del archivo .jasper
pathReporte=getServletContext().getRealPath("/Mascotas.jasper");
//Pasar de parametro la ruta del .jasper
JasperReport reporte = (JasperReport) JRLoader.loadObjectFromFile(pathReporte);
//Se necesitan 3 parametros el reporte,los parametros si el sql los necesitara y la
conexion a la BD
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte,null, conexion);
if(tipo.equals("pdf")){
response.setContentType("application/pdf");
//Nombre del reporte
response.setHeader("Content-Disposition","attachment;
filename=\"ReporteMascotas.pdf\";");
JRPdfExporter exporter = new JRPdfExporter();
exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
exporter.setExporterOutput(new SimpleOutputStreamExporterOutput(out));
SimplePdfExporterConfiguration configuration = new
SimplePdfExporterConfiguration();
exporter.setConfiguration(configuration);
exporter.exportReport();
}else if (tipo.equals("html")) {
response.setContentType("text/html;charset=UTF-8");
//Nombre del reporte
response.setHeader("Content-Disposition","attachment;
filename=\"ReporteMascotas.html\";");
Exporter exporter = new HtmlExporter();
exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
exporter.setExporterOutput(new SimpleHtmlExporterOutput(out));
SimpleHtmlExporterConfiguration exporterConfig = new
SimpleHtmlExporterConfiguration();
exporterConfig.setBetweenPagesHtml("");
exporter.setConfiguration(exporterConfig);
exporter.exportReport();
}else if (tipo.equals("excel")) {
response.setContentType("application/xls");
response.setHeader("Content-Disposition","attachment;
filename=\"ReporteMascotas.xls\"");
JRXlsExporter exporter = new JRXlsExporter();
exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
exporter.setExporterOutput(new SimpleOutputStreamExporterOutput(out));
SimpleXlsReportConfiguration configuration = new SimpleXlsReportConfiguration();
configuration.setOnePagePerSheet(true);
configuration.setDetectCellType(true);
configuration.setCollapseRowSpan(false);
exporter.exportReport();
}
}
catch (NamingException | SQLException | JRException ex) {
Logger.getLogger(CallReport.class.getName()).log(Level.SEVERE, null, ex);
}finally{
try {
conexion.close();
} catch (SQLException ex) {
Logger.getLogger(CallReport.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
3. Aparecerán una serie de errores, pero esto se debe a que no se han importado los
paquetes correspondientes, Agregar los siguientes paquetes para que el servlet pueda
correr exitosamente.
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.export.JRPdfExporter;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.export.SimpleExporterInput;
import net.sf.jasperreports.export.SimpleOutputStreamExporterOutput;
import net.sf.jasperreports.export.SimplePdfExporterConfiguration;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
4. Ahora lo que resta es correr la página “TipoReporte.jsp” y ver el resultado obtenido.
Resultado
Html
Excel
IV. REFERENCIA BIBLIOGRÁFICA
http://www.javatutoriales.com/2009/02/creacion-de-reportes-con-jasperrepots-y.html
Última fecha de Visita: 11/06/2013
HOJA DE EVALUACIÓN
Actividad a evaluar Criterio a evaluar
Cumplió Puntaje
SI NO
Desarrollo
Realizó los ejemplos de guía de práctica (40%)
Presentó todos los problemas resueltos (20%)
Funcionan todos correctamente y sin errores (30%)
Envió la carpeta comprimida y organizada adecuadamente
en subcarpetas de acuerdo al tipo de recurso (10%)
PROMEDIO:
Investigación
complementaria
Entregó la investigación complementaria en la fecha
indicada (20%)
Resolvió todos los ejercicios planteados en la investigación
(40%)
Funcionaron correctamente y sin ningún mensaje de error a
nivel de consola o ejecución (40%)
PROMEDIO:
Hoja de cotejo.
Docente:
Máquina No:
GL:
a
Alumno: Carnet:
Docente: Fecha:
Título de la guía: No.: