Reportes

Carrera Profesional:

Ingeniería de Sistemas y Telemática

Tema:

Objeto Comand

Docente:

Marco Aurelio Porro Chulli.

Asignatura:

Laboratorio de Programación III

Integrantes:

Maldonado Idrogo Betzabeth Yameli
Pérez Saucedo Yordin Alberto

Utcubamba - Bagua Grande - 2017

I. Reportes

1. Contenido

Ø Instalación de iReport en NetBeans

Una de las mejores soluciones en Netbeans a la hora de crear informes es usar JasperReports pero antes de poder crearlos debemos tenerlo todo preparado y listo para usarlo, en esta ocasión explicaré la que a mi juicio es la mejor forma de tenerlo todo atado. Necesitaremos instalar el plugin iReport para Netbeans, que nos ayudará en el diseño del informe que tengamos que elaborar, además prepararemos las librerías esenciales para poder usar las clases necesarias en nuestros proyectos.

Primer paso. Instalación del plugin iReport.

Bajaremos la última versión que encontremos del plugin iReport de la web oficial de Netbeans.

http://plugins.netbeans.org/PluginPortal/

Una vez descargado lo descomprimiremos y tendremos la siguiente estructura de archivos:

${distro.zipfilename.extensions}.nbm
iReport-5.5.0.nbm
jasperreports-components-plugin-5.5.0.nbm
jasperserver-plugin-5.5.0.nbm

Ya en NetBeans deberemos instalar el plugin. Para ello en la barra de menús nos moveremos a Herramientas ->Plugins.

Se nos abrirá una nueva ventana donde añadiremos el plugin descargado. Nos moveremos a Descargados ->Agregar Plugins

Tras esto nos quedará buscar la ruta donde descomprimimos el plugin y agregar todos los plugins e iniciar la instalación pulsando el botón “Instalar”.

Después de seguir los simples pasos de la instalación tendremos el plugin instalado.

Segundo paso. Agregar las librerías de JasperReports

Mi recomendación es bajar las librerías directamente de la página oficial de JasperReports, pues JasperReports necesitas librerías adicionales que detallaremos a continuación.

https://sourceforge.net/projects/jasperreports/files/jasperreports/

En mi caso he bajado la versión 6.2.0 que trae todas las librerías necesarias.

Tras la descarga descomprimiremos el archivo y veremos la siguiente estructura de archivos. Nos centraremos en las carpetas dist y lib.

Lo siguiente que haremos es recopilar los siguientes archivos de esas dos carpetas.

De la carpeta lib:

commons-beanutils-x.jar
commons-collections-x.jar
commons-digester-x.jar
commons-javaflow-x.jar
commons-logging-x.jar
groovy-all-x.jar
itext-x.jar
log4j-x.jar
png-encoder-x.jar
xalan-x.jar

De la carpeta dist solo necesitaremos uno:

jasperreports-x.jar

Una vez recopilados todos estos archivos en una misma carpeta tendremos que agregar la librería a NetBeans moviéndonos a Herramientas-Libreries

Seguidamente deberemos crear una nueva librería, pincharemos en New Library… y le daremos nombre el nombre la librería “JasperReports” (sin comillas).

Solo nos quedará añadir todos los archivos recopilados anteriormente. Para ello pincharemos en Agregar archivo JAR/Carpeta y buscaremos la ruta donde los tengamos alojados.

Ø Configuración de DataSource

· Colocamos el driver jdbcsql.jar en la carpeta lib del GlassFish para poder realizar la conexión

· Iniciamos el GlassFish y nos vamos a la opción de "Recursos --> JDBC --> Pools de Conexiones de JDBC"

· Y presionamos el botón de nuevo para crear un nuevo Pool de Conexiones JDBC.

· Creamos el Pool de conexiones. Colocamos en nombre,tipo de recurso,y poveedor de la base de datos como se muestra en la siguiente figura

· Activamos el PING para verificar las conexiones con la base de datos.

· Configuramos todas las propiedades necesarias de conexión a la base de datos.

· De ahí debemos de ir a "Recursos --> Recursos JDBC" y presionamos Nuevo.

· Y ponemos el nombre JNDI que vamos a usar.

Y para obtener la conexión desde Java usamos las siguientes líneas:
Context ctx=new InitialContext();
DataSource ds=(DataSource) ctx.lookup("jdbc/SQL2008");
ds.getConnection();

Ø Creación de Reportes Usando Wizard, archivo jrxml

Creación de Reportes con JasperRepots y iReports

Para estos ejemplos usaremos las últimas versiones de ambas herramientas (que en esta actualización son las 3.7.6)
Lo primero que haremos es bajar el JasperReports y iReport. Este último lo usaremos en su faceta de aplicación standalone y no como plugin para NetBeans. Esto por aquellos que nos les guste usar el NetBeans.

Como ya había dicho: La última versión de iReport está basada en la plataforma de NetBeans por lo que, como pueden observar en la imagen siguiente, las interfaces de ambos son muy parecidas.

En este primer post veremos cómo crear reportes haciendo uso de una conexión a la base de datos directamente desde nuestro reporte.Lo primero que haremos es crear una base de datos con tablas y datos de pruebas para poder tener algo interesante que ver en nuestros reportes. En este usaremos MySQL versión 5.1, el cual pueden descargar desde su página oficial. Usando el conector para Java versión 5.1.13 que pueden descargar desde la página de MySQL. Pero cualquier base de datos que les guste funcionará para nuestros ejemplos.
La base de datos que usaré se llama "pruebaReportes" y contiene la tabla "participantes". Este es el script para la creación de esta tabla:

CREATE TABLE 'participantes' (

'ID' bigint(21) NOT NULL,

'NOMBRE' varchar(100) NOT NULL,

'USERNAME' varchar(100) NOT NULL,

'PASSWORD' varchar(100) NOT NULL,

'COMENTARIOS' varchar(100) default NULL,

PRIMARY KEY ('ID')

) ENGINE=InnoDB DEFAULT CHARSET=latin1

Y este es el script para poblar la tabla anterior:

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (1,'Participante 1','par1user','part1pass','comentarios participante 1');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (2,'Participante 2','par2user','part2pass','comentarios participante 2');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (3,'Participante 3','par3user','part3pass','comentarios participante 3');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (4,'Participante 4','par4user','part4pass','comentarios respecto al participante 4');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (5,'Participante 5','par5user','part5pass','sin comentarios para el participante 5');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (6,'Participante 6','par6user','part6pass',NULL);

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (7,'Participante 7','par7user','part7pass','comentatios participante 7');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (8,'Participante 8','par8user','part8pass','comentarios participante 8');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (9,'Participante 9','par9user','part9pass','comentarios participante 9');

insert into 'participantes'('ID','NOMBRE','USERNAME','PASSWORD','COMENTARIOS') values (10,'Participante 10','par10user','part10pass',NULL);

Ahora que tenemos nuestros datos crearemos un "datasource" en iReport para poder acceder a nuestros datos y hacer pruebas directamente, sin necesidad de una aplicación Java (por el momento). Para crear este datasource hacemos clic en el ícono "Report DataSource" ubicado en la barra de herramientas de iReport:

Con lo que se abrirá la ventana de "Connections / Datasources" que en este momento debe contener solo un "Empty datasource" y la conexión a una base de datos de prueba en HSQLDB. Ahora hacemos clic en el botón "New" para crear nuestro nuevo datasource.

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

Antes de guardar esta configuración hagan clic en el botón "Test" para probar que todos los datos proporcionados son correctos. Si todo ha salido bien, al hacer clic en el botón "Save" la ventana actual debe cerrarse y nuestro datasource debe estar ahora en la ventana "Connections / Datasources".

Ahora pasaremos a crear nuestro nuevo reporte. Esta será la primer y única ocasión en la que haremos uso del "Report Wizard" para ayudarnos a generar el reporte. Para esto vamos al menú "File -> New...". Con esto se abrirá la ventana de "New File" en la que seleccionaremos el formato de nuestro reporte. En mi caso seleccionaré la plantilla "Wood" aunque pueden seleccionar la que ustedes deseen, y hacemos clic en el botón "Launch Report Wizard"

Este wizard nos ayudará a crear un reporte 100% funcional en 6 pasos (en realidad 5 ya que empezamos directamente en el paso 2) que podremos ver desde el mismo iReport sin necesidad de escribir una solo línea de código Java. Estos 7 pasos son:

⧭ Selección de la ubicación en la que se guardará nuestro reporte.

⧭ Selección del datasource e introducción del query para obtener los datos que nos interesan.

⧭ Selección de los datos que queremos mostrar en el reporte.

⧭ Creación de grupos para el reporte (se explicará en un post posterior).

⧭ Selección del layout o acomodo de los datos en el reporte.

⧭ Felicitación por determinar nuestro reporte.

Los pasos interesantes son el 3 y el 4, así que será en estos en los que nos enfocaremos más.

El paso 1 se realiza de forma automática, así que no tenemos mucho que hacer en él. En el paso 2 (en donde comenzamos) seleccionamos el directorio en el que queremos guardar nuestro reporte y el nombre que tendrá.

Nota: La extensión de documentos de reportes generados por JasperReports es “. jrxml" que significa "jasper reports XML", y es un documento XML que contiene los datos para generar un archivo compilado (“. jasper") que es el que usaremos principalmente en nuestras aplicaciones Java (aunque también podríamos optar por compilar nuestro archivo “. jrxml" desde la misma aplicación Java y así generar el archivo “. jasper" correspondiente).

En este momento no importa mucho en donde guardemos el archivo que se generará, ya que posteriormente tendremos que moverlo para que nuestra aplicación java pueda encontrarlo. Por mi parte llamaré al archivo "reporte1".

Hacemos clic en el botón "Next" para continuar con el paso 3. En este paso debemos seleccionar el datasource desde el que los datos del reporte serán tomados. Por default está seleccionado el "Empty datasource". Así que nosotros seleccionamos el datasource "Conexion MySQL Pruebas" (el datasource que creamos anteriormente).

Al hacer el cambio del datasource veremos que aparece un textarea con el título "Query(SQL)" y en la parte inferior debemos tener un mensaje de error que dice "Invalid query".

Esto ocurre porque, efectivamente, en el textarea no tenemos una consulta válida (de hecho, no tenemos ninguna). Por lo que ahora corregiremos eso. Para esto tenemos 3 opciones:

💜💜 Escribir una consulta nosotros mismos de forma directa.

💜💜 Cargar una consulta que tengamos guardada en algún archivo .sql o .txt.

💜💜 Crear una consulta usando el "diseñador de consultas".

Nosotros haremos uso del diseñador de consultas. Hacemos clic en el botón "Design query" con lo que se abrirá una nueva ventana que está dividida en tres secciones.

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

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

Con esto ya tendremos nuestra consulta en el textarea correspondiente y podemos continuar con el paso 4, para lo que hacemos clic en el botón "Next".
En este paso solo tenemos que seleccionar cuáles campos del query generado en el paso anterior queremos que se muestren en el reporte. Como nosotros queremos que se muestren todos pasamos todos los campos del lado izquierdo al lado derecho y hacemos clic en el botón "Next".

Ahora en el paso 5 debemos seleccionar cómo queremos que los datos sean agrupados. Esto lo explicaré en algún otro post, pero por el momento dejemos todo en blanco y demos clic en el botón "Next".
El último paso es el solamente una felicitación por haber creado un nuevo reporte.

Ahora hacemos clic en el botón "Finish" y ya podremos ver la plantilla de nuestro reporte.

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

Al hacer clic en la pestaña 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 través del datasource anterior.

El reporte está preparado para mostrar los datos recuperados anteriormente.

Como veremos en los siguientes posts, podría ser que no todas estas condiciones se cumplan al mismo tiempo, por lo que tendremos problemas para ver los datos en el preview del reporte.

Algo importante que ocurre al hacer este preview es que el reporte se compila generando el archivo "reporte1.jasper" el cual es el archivo que usaremos desde la aplicación Java que crearemos en un momento.

Si queremos compilar nuestro reporte de forma manual podemos hacer clic en el botón "Compile Report" de la vista de diseño:

Haremos algunas modificaciones para que este reporte se vea un poco mejor: primero cambiaremos el título que dice "Wood Title" por "Reporte de Participantes", cambiamos el color de texto a negro, y eliminamos el fondo y el subtítulo que tiene.

Además, cambiamos el título de cada una de las columnas por algo más claro. Por ejemplo, podemos cambiar el título de la columna "participantes_USERNAME" a "Usuario", "participantes_NOMBRE" a "Nombre", etc.

Al final mi reporte queda de esta forma:

Con este preview:

Ahora que tenemos un reporte que nos agrada (o al menos que no se ve tan mal) veremos cómo generar este reporte desde una aplicación Java.Nota: Hay algunas notaciones usadas en la plantilla del reporte que tal vez-no-comprendan como $F{participantes_USERNAME} y$V{PAGE_NUMBER}.Esta es una sintaxis especial que usa JasperReports para definir campos de objetos y variables, respectivamente. Existe otro tipo de dato que se usa llamado propiedades ($P{propiedad}). Como todo esto fue colocado por el wizard no lo explicaré hasta el siguiente post, por ahora solo confíen en que deben estar ahí. Lo primero que haremos es crear un nuevo proyecto en NetBeans. Para esto vamos al menú "File -> new Project...". En la ventana de nuevos proyectos seleccionamos la categoría "Java" y de tipo de proyecto seleccionamos "Java Application" y hacemos clic en el botón "Next". En la siguiente ventana introducimos el nombre de nuestro proyecto y dejamos seleccionada la opción "Create Main Class" y "Set as Main Project".

Hacemos clic en el botón "Finish" para que nuestro proyecto se genere. Lo que haremos a continuación es crear una biblioteca que contenga los archivos jars básicos necesarios de JasperReports. De esta forma no tendremos que agregar cada uno de los jars cada vez que necesitemos usar JasperReports en un proyecto. Además, si actualizamos la versión del API que usamos, solo debemos actualizar esta biblioteca. Para crear nuestra biblioteca vamos al menú "Tools -> Libraries":

Con esto se abrirá la ventana del "Library Manager". En esta ventana hacemos clic en el botón "New Library":

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

Al hacer clic en el botón "OK" regresaremos al "Library Manager" y tendremos nuestra nueva biblioteca creada. Pero aún nos hace falta agregar los archivos jars que conformarán esta biblioteca. Nos aseguramos que la pestaña "Classpath" esté seleccionada y hacemos clic en el botón "Add Jar/Folder" situado a la derecha. Se abrirá un cuadro de dialogo para que seleccionemos los jars que queremos agregar.

Navegamos hasta el directorio en el que tenemos los jars de JasperReports que bajamos anteriormente. Para que los ejemplos que haremos más adelante (en los siguientes posts) funcionen, debemos agregar a la biblioteca los siguientes jars:

· jasperreports-3.7.6.jar

· jasperreports-3.7.6-javaflow.jar

· jasperreports-fonts-3.7.6.jar

· commons-beanutils-1.8.0.jar

· commons-collections-2.1.1.jar

· commons-digester-1.7.jar

· commons-logging-1.0.4.jar

· commons-javaflow-20060411.jar

· groovy-all-1.7.5.jar

· iText-2.1.7.jar

· png-encoder-1.5.jar

· poi-3.6.jar

Algunos de estos jars se encuentran en el directorio "dist" y otros en el directorio "lib" del archivo .zip de JasperRepots que bajamos anteriormente.

Hacemos clic en el botón "Add Jar/Folder" y con esto tendremos lista nuestra biblioteca "JasperReports" para agregarla a nuestro proyecto.

Hacemos clic en el botón "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 opción "Add Library..."

En la ventana que se abre seleccionamos la biblioteca que creamos anteriormente ("JasperReports") y hacemos clic en el botón "Add Library". Al hacer esto veremos se agregar al nodo "Libraries" de nuestro proyecto todos los jars que tiene nuestra biblioteca.
Nota: Si no crearon la biblioteca como se indica en pasos anteriores pueden agregar cada uno de los jars manualmente seleccionando la opción "Add JAR/Folder..." del menú contextual.

¿Recuerdan que cuando vimos el preview del reporte que creamos en iReports se generó un archivo “reporte1? jasper"? Tomamos este archivo y lo colocamos en el directorio raíz del proyecto de NetBeans que acabamos de crear (la raíz del proyecto es el directorio en el que se encuentran los subdirectorios "nbproject", "src", entre otros).

Ahora veremos el código para generar el reporte en varios formatos.
Lo primero es crear una conexión a la base de datos que creamos anteriormente. Si no saben cómo crear una conexión JDBC desde Java, pueden ver este artículo. Si recuerdan nuestra base de datos se llama "pruebareportes". Por lo que el código para generar la conexión en el siguiente:

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

Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebareportes", "usuario", "password");

Nota: No olviden agregar el jar del driver de MySQL que bajamos anteriormente (mysql-connector-java-5.1.13-bin.jar) al proyecto al nodo "Libraries" de la ventana "Project" usando la opción "Add JAR/Folder" o también pueden agregar la biblioteca "MySQL JDBC Driver" que ya trae incluido el NetBeans, de la misma forma que agregamos la de JasperReports.

Seguramente en este momento el NetBeans les está marcando un error en estas dos líneas que hemos agregado. Esto es porque al tratar de hacer la conexión es posible que ocurra un error, y por lo tanto es posible que se lance una excepción de tipo "java.sql.SQLException". Para solucionar esto pueden hacer dos cosas. La primera es rodear estas líneas (y las siguientes que crearemos) en una clausula try/catch. La segunda opción (la que yo usaré) es agregar la cláusula throws Exception en el método main:

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

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

        Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebareportes", "root", "123");

}

Pueden probar que la conexión se realiza correctamente presionando F6 o haciendo clic en el botón "Run Main Project". Si la conexión se realiza correctamente veremos el mensaje

run:

BUILD SUCCESSFUL (total time: 0 second)

En la ventana "Output". De lo contrario verán el error el en stacktrace de la excepción que se lanzó. Una vez que la conexión se realice exitosamente podremos proseguir con los pasos restantes.

Lo siguiente que debemos hacer es cargar el archivo ".jasper" generado anteriormente y colocarlo en un objeto "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("reporte1.jasper");

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

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

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

Pasamos "null" como segundo parámetro porque no estamos pasando ningún parámetro al reporte (esto también lo veremos después).

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

Si están haciendo una aplicación swing y quieren mostrar este reporte directamente en un componente pueden pasar el objeto "JasperPrint" que acabamos de crear como parámetro a un nuevo objeto "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 cómo generar los reportes en los siguientes formatos:

                                                   ·            PDF

                                                   ·            HTML

                                                   ·            CSV

                                                   ·            RTF

                                                   ·            TXT

                                                   ·            XLS

                                                   ·            XML

                                                   ·            XLSX

                                                   ·            DOCX

                                                   ·            PPTX

Entre muchos otros.

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 líneas son comunes no importando el formato en el que vaya a quedar nuestro reporte:

exporter.setParameter(JRExporterParameter.JASPER_PRINT,jasperPrint);

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

exporter.exportReport();

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

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

Si ahora ejecutamos nuestra aplicación veremos que en el directorio raíz del proyecto se ha creado un archivo llamado "reportePDF.pdf":

Con el siguiente contenido:

Por lo que nuestra prueba ha sido exitosa.

Ahora, para que nuestro reporte sea exportado a formato HTML cambiamos la línea:

JRExporter exporter = new JRPdfExporter(); por

JRExporter exporter = new JRHtmlExporter();

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

Con el siguiente contenido:

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

PDF: net.sf.jasperreports.engine.exportJRPdfExporter

HTML: net.sf.jasperreports.engine.exportJRHtmlExporter

CSV: net.sf.jasperreports.engine.exportJRCsvExporter

RTF: net.sf.jasperreports.engine.exportJRRtfExporter

XLS: net.sf.jasperreports.engine.exportJRXlsExporter

XML: net.sf.jasperreports.engine.exportJRXmlExporter

TXT: net.sf.jasperreports.engine.exportJRTextExporter

XLSX: net.sf.jasperreports.engine.export.ooxml.JRXlsxExporter

DOCX: net.sf.jasperreports.engine.export.ooxml.JRDocxExporter

PPTX: net.sf.jasperreports.engine.export.ooxml.JRPptxExporter

Para generar archivos .txt tendrán que agregar, además, estas dos líneas:

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

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

Este es el código de la clase "Main":

public class Main

{

    /**

     * @param args argumentos recibidos por la linea de comandos

     */

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

    {

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

        Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/pruebareportes", "usuario", "password");

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

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

        JRExporter exporter = new JRPdfExporter();

               exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);

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

        exporter.exportReport();

    }

}

Ø Campos Calculados en iReport.

Estos son los tipos de objetos que pueden almacenar valores. El modo de hacer referencia a cada tipo dentro de las expresiones es del siguiente modo:

                                                        ·            $V{variable}

                                                        ·            $F{campo}

                                                        ·            $P{parámetro}

Se pueden visualizar por medio del cuadro de dialogo View->Report Fields.

Fields.

La información de los reportes es siempre alimentada por campos, es importante no confundir estos con el elemento gráfico TextField, ya que estos son únicamente para desplegar información que puede provenir de una variable, parámetro o campo.

La data source que alimenta a nuestro reporte está compuesto por los campos que nosotros determinemos. Para agregar un nuevo Field debemos indicar el nombre del campo, el tipo y alternativamente una descripción.

Para el caso del reporte que estamos realizando la mayoría de los campos son numéricos, podríamos declararlos de tipo Float.

Para hacer referencia a nuestro campo debemos escribir: $F{miCampo}. Esto lo podemos hacer desde cualquier expresión que escribamos dentro de nuestro reporte. Por ejemplo podemos escribirlo como el valor de un TextField.

Parámetros.

Los parámetros pueden ser usados para condicionar el comportamiento del reporte en tiempo de generación o simplemente para mostrar el valor de un dato aislado en nuestro reporte, por ejemplo, la fecha de generación del reporte.

Para crear un parámetro debemos ingresar los siguientes datos:

Si el valor del parámetro no es pasado por el reporte, se tomará el valor declarado en ‘Default value expression’. Este valor por default como todas las demás expresiones que escribimos deben ser objetos, no se pueden utilizar tipos primitivos en las expresiones de Jasper.

Para hacer referencia a un parámetro que hayamos declarado usamos:

$P{miParametro}

Variables.

Las variables son usadas para almacenar resultados de cálculos, totales, etc. Veamos las propiedades que tenemos a la hora de crear una variable:

En este ejemplo estamos creando una variable de tipo Double que nos servirá para calcular una Sumatoria o Total. Nuestra variable se reiniciará cada vez que sea tiempo de generar el grupo llamado compania, de aquí se deduce que está variable calculará los totales por compania. Por medio de la propiedad ‘Initial value expression’ indicamos el valor que la variable tomará cada vez que esta se reinicie, en este caso en cero.

En pocas palabras esto permitirá llevar un acumulado para cada Agrupación, es decir que cada $F{ST_ADELANTADO} se acumule en nuestra variable que estamos declarando.

Para hacer referencia a una variable usamos:

                                                        ·            $V{ ST_ADELANTADO }

    Frame

Los frame son utilizados para agrupar varios elementos a un solo elemento, ya que de que de esta forma es más fácil la agrupación de datos y el manejo de los mismo, de esa forma nosotros podemos, modificar el color de fondo o la propiedad de los márgenes.

Ø Ejecución de reportes, archivo jasper

                       Reportes con JasperReport desde NetBeans

Configurar NetBeans para que podamos trabajar reportes desde una aplicación de escritorio.

Configurar Librerías

En el menú

Tools

seleccionar

Libraries

nos aperece el Library Manager

en este panel agregaremos, nuestras referencias a las librerías.

Necesitamos configurar algunas librerías en NetBeans.

Agregar la librería JasperReports

Dar clic en el botón New Library

Aparece el cuadro de diálogo New Library, le indicamos en el Library Name el nombre de la librería, y en Library Type Class Libraries, presionamos el botón OK.

Ahora tenemos que agregarle las librerías .jar que necesitamos.

En este caso, llame a la librería JasperReport, presionar el botón Add JAR/Folder, donde seleccionamos los archivos .jar que deseamos.

En el ejemplo podemos:

Agregar la librería iReport:

File:Ireportrecortada Avbravotutorialbasiconetbeansreports.png

Agregar JFreeChart:

File:JFreeChartrecortada Avbravotutorialbasiconetbeansreports.png

😜Configurar el ambiente de edición en NetBeans para que soporte JRXML.

😝Seleccionar el menú Tools

😝Luego Options

😝Dar clic en el botón Advanced Option

😜Seleccionar IDE Configuration

😝Luego System.

😝Luego Obect Types

😝Luego en las propiedades de edición seleccionamos Extension.

😝Damos clic en el botón

File:Boton Avbravotutorialbasiconetbeansreports.png

😜Ahora agregamos el nuevo tipo de archivos jrxml

😜Damos clic en el botón Add

Los reportes creados con JasperReport, tienen la extension .jrxml

😜Código para generar una vista previa del reporte:

    Map<String, Object> params = new HashMap<String, Object>();

    try {

JasperReport jasperReport =

           JasperCompileManager.compileReport(reportSource);

             JasperPrint jasperPrint =

                JasperFillManager.fillReport(

                jasperReport, params, sesion.con);

       JasperViewer.viewReport(jasperPrint, false);

    } catch (JRException ex) {

        ex.printStackTrace();

            }

Ejemplo de un reporte con gráficos

Ø Enlace de reporte con ventana JDialog. Uso de JasperViewer – Ejemplos

Todo está bien pero cuando llamamos al Reporte desde JDialog Hijo, lo llama al Reporte Exitosamente, pero se ubica detrás del JDialog Y no puedo acceder al Reporte Hasta que no cierre el JDialog Hijo.

Eso se llaman ventanas modales, en cualquier lenguaje y sistema operativo. Cuando una ventana se coloca adelante de las otras y las otras no responden hasta que se cierra la que está al frente, se le denomina una ventana modal. Pero no creo que sea la solución más bien he obtenido una ayuda y es que el reporte lo muestre en JDialog hijo, pero lo que no se es como llamar este reporte para que se muestre en un JDialog.

Realmente no entendí la pregunta inicial, me basé en el comportamiento de una ventana modal, porque lo que describiste es una ventana modal. Aunque sigo sin entender completamente que es lo que quieres hacer.

Yo muestro de esta forma mis reportes en Jasper y no tengo ningún inconveniente con las ventanas modales, posiblemente y digo posiblemente porque no tengo ni idea que estás haciendo, te sea de alguna ayuda.

                                                      ·            Código Java:

public class JDialogReport01 extends javax.swing.JDialog {

   public JDialogReport01(java.awt.Frame parent, boolean modal) {

super(parent, modal);

initComponents();

setLocationRelativeTo(parent);

     DateFormat df = DateFormat.getDateInstance(DateFormat.MEDIUM);

jTextField1.setText(df.format(new Date()));

jTextField2.setText(df.format(new Date()));

}

   private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

try {

Reportes reportes = new Reportes();

  DateFormat df = DateFormat.getDateInstance();

JasperViewer.viewReport(reportes.Reporte03(

df.parse(jTextField1.getText()),

df.parse(jTextField2.getText())),

false);

} catch (Exception ex) {

  JOptionPane.showMessageDialog(this,

"Ha ocurrido un error al intentar imprimir el documento.\n" +

ex, getTitle(), JOptionPane.ERROR_MESSAGE);

}

}
Y esta es mi clase Reporte03:

                                                      ·            Código Java:

public JasperPrint Reporte03(java.util.Date p_fecini, java.util.Date p_fecfin) throws DataConnectionException, SQLException, JRException {

HashMap<String, java.util.Date> m = new HashMap<String, java.util.Date>();

m.put("p_fecini", p_fecini);

m.put("p_fecfin", p_fecfin);

JasperReport jasperReport = JasperCompileManager.compileReport(Main.getProperty("reportes_filepath") + "/jaspReport03.jrxml");

JasperPrint jasperPrinter = JasperFillManager.fillReport(jasperReport, m, new DataConnection().getConnection());

return jasperPrinter;

}

Y la forma de llamar el JDialog:

                                                      ·            Código Java:

if (Main.usuario.hasAccess(13)) {

new JDialogReport01(this, false).setVisible(true);

} else {

  JOptionPane.showMessageDialog(this,

"No tiene los permisos para ingresar a esta opción.\n",

getTitle(), JOptionPane.ERROR_MESSAGE);

}

1.    Resumen

iReport es una herramienta visual que sirve para generar ficheros XML (plantillas de informe) que se puedan utilizar con la herramienta de generación de informes JasperReports.

iReport inicialmente se ha desarrollado en J++ por lo que su entorno de ejecución se limita a plataformas Microsoft. En sus últimas versiones se ha publicado una versión 100% java con lo cual se limita la restricción existente.

iReport también es una herramienta práctica, visual y muy simple de utilizar para desarrollar reportes utilizando el API de Jasper Report.

Los datos que vamos a mostrar en nuestros reportes pueden provenir de distintos lugares tales como una base de datos o un archivo XML, estas formas diferentes de obtener datos son las llamadas fuentes de datos - Data Source.

Las fuentes de datos son representadas en Jasper Report por una interfaz llamada JRDataSource, el motor ya provee muchas implementaciones de esta interfaz para poder utilizar datos provenientes de Arreglos, Vectores, Collections, Modelos de Tablas, Consultas SQL, Cubos OLAP, Consultas JPA, Consultas Hibernate, Archivos CVS, Documentos XML, por nombrar algunos.

Características:

                                ·            Categoría: Bussines Intelligence.

                                ·            Soporte para TrueType.

                                ·            Manejo de múltiples fuentes de datos como: todas las bases de datos soportadas por JDBC, archivos XML, CSV, Hibernate entre otros.

                                ·            Soporta SQL, HQL, EJBQL, MDX y Xpath.

                                ·            Wizard para la creación de reportes y sub-reportes.

                                ·            Más de 30 elementos para formatear el reporte (líneas, elipses, TextFields, charts, código de barras, etc.).

                                ·            El núcleo de este es una biblioteca llamada JasperReports, la cual fue desarrollada por Teodor Danclu de JasperSoft Corporation.

                                ·            Los reportes generados se puede pre visualizar y/o exportar en PDF, HTML, RTF, XLS, CSV, TXT y más.

Estructura de los reportes

La estructura de los reportes se encuentra dividida por secciones horizontales llamadas "Bandas", las cuales son rellenadas con los datos que requerimos en una posición específica, es aquí donde se definen las reglas del reporte.

Está divida en 9 bandas, en las cuales se pueden removidas o agregadas en el reporte, por default se muestran:

                                ·            Titulo

                                ·            Header de pagina

                                ·            Header de columnas

                                ·            Detalle

                                ·            Pie de columna

                                ·            Pie de pagina

                                ·            Ultimo pie de pagina

                                ·            Sumario

2.    Sumary

IReport is a visual tool that serves to generate XML files (templates report) that you can use with the reporting tool JasperReports. iReport was initially developed in J++ so that its execution environment is limited to Microsoft platforms. In their latest versions has been published a version 100% Java with which has limited existing restriction.

IReport is also a practical tool, visual and very simple to use to develop reports using the API of Jasper Report. The data that we are going to show in our reports may come from different places such as a database or an XML file, these different ways of obtaining data are calls data sources - Data Source.

The data sources are represented in Jasper Report by an interface called JRDataSource, the engine already provides many implementations of this interface to be able to use data from Arrays, Vectors, Collections, Tables Models, SQL Queries, OLAP Cubes, JPA Queries, Queries Hibernate, CVS Files, XML Documents, to name a few.

Characteristics:

Ø Category: Business Intelligence.

Ø Support for TrueType.

Ø Handling of multiple data sources such as: all databases supported by JDBC, XML files, CSV, Hibernate and others.

Ø Supports SQL, HQL, EJBQL, MDX and Xpath.

Ø Wizard for creating reports and sub-reports.

Ø More than 30 elements to format the report (lines, ellipses, TextFields, charts, barcode, etc.).

Ø The core of this is a library called JasperReports, which was developed by Teodor Danclu of JasperSoft Corporation.

Ø Generated reports can be previewed and / or exported in PDF, HTML, RTF, XLS, CSV, TXT and more.

Structure of the reports The structure of the reports is divided by horizontal sections called "Bands", which are filled with the data that we require in a specific position, it is here where the rules of the report are defined.

It is divided into 9 bands, in which they can be removed or added to the report, by default they are shown:

Ø Title

Ø Page Header

Ø Column Header

Ø Detail

Ø Column foot

Ø Footer

Ø Last Footer

Ø Summary

3.    Recomendaciones

                           ·            Considero que hay tres malas prácticas que se deben evitar cuando queremos usar un método que lanza una excepción manejada.

                           ·            Antes de continuar con este apunte, vamos a repasar lo que es una excepción.

                           ·            Las excepciones son caminos alternos que puede tener un programa. Es mal llamado "error", ya que un programa solo hace lo que le indican. El que tiene el error es el usuario o el programador.

4.    Conclusiones

                           ·            Que nos permiten pasar valores, desde nuestra aplicación Java, a los reportes generados por JasperReports ya sean valores de cálculo, cadenas de caracteres, indentificadores, etc.

                           ·            iReport nos sirve para poder conectarnos a diferentes bases de datos, eso sí con la limitación de tener que utilizar un informe por cada consulta. Esto no es problema ya que podemos incluir tantos subinformes como queramos obteniendo finalmente el resultado que esperábamos.

5.    Apreciaciones Equipo

Este instrumento permite que los usuarios corrijan visualmente informes complejos con cartas, imágenes, subinformes, etc. iReport está además integrado conJFreeChart, 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.

6.    Glosario

JDBC: Es un conjunto de componentes del software que pueden ser usados por los programadores para acceder a datos y a servicios de datos.

System.Data.OleDb: Clases del proveedor de datos de OleDB, permiten el acceso a proveedores .NET que trabajan directamente contra controladores basados en los ActiveX de Microsoft.

System.Data.SqlTypes: Definición de los tipos de datos de SQL Server, proporciona la encapsulación en clases de todos los tipos de datos nativos de SQL Server y sus funciones de manejo de errores, ajuste y conversión de tipos, etc.

7.    Linkografia

https://jossjack.wordpress.com/2014/06/15/jasperreport-ireport-en-netbeans/

https://prezi.com/oqmqvuzqp_sf/crear-reportes-con-ireport-y-java/

https://prezi.com/oqmqvuzqp_sf/crear-reportes-con-ireport-y-java/

http://www.javatutoriales.com/2009/02/creacion-de-reportes-con-jasperrepots-y.html

https://www.youtube.com/watch?v=e-uPYpGeUHk

http://www.javapuntes.com/informes-instalacion-de-jasperreports-y-plugin-ireport-en-netbeans/

8. Diapositivas
https://es.slideshare.net/YameliMaldonadoIdrog/reportes-84041410

Buscar este blog

Laboratorio de Programación III

Reportes

Utcubamba - Bagua Grande - 2017

Comentarios

Publicar un comentario

Entradas populares de este blog

Aplicaciones N - Capas en Visual Net

Objeto SqlCommand