viernes, 8 de diciembre de 2017

Reportes

JasperReports

1.  Contenido






Jasper Report es una librería para la generación de informes. Está escrita en java y es libre. El funcionamiento consiste en escribir un xml donde se recogen las particularidades del informe. Este XML lo tratan las clases del Jasper para obtener una salida que pueden ser un PDF, XML, HTML, CSV, XLS, RTF, TXT.
Para generar el XML, o el compilado. Jasper les recomiendo descargar la herramienta iReport que es un Entorno Gráfico que está implementado en java y se integra perfectamente con el Jasper Report.
Aunque JasperReports se utiliza principalmente para capacidades de reporte a las aplicaciones basadas en la Web a través de la API de Servlet, no tiene absolutamente ninguna dependencia de la API Servlet o cualquier otra biblioteca de Java EE. No hay nada que nos impida la creación de aplicaciones de escritorio Java para generar informes con JasperReports.

JasperReports nos permite separar los datos en secciones. Estas secciones incluyen:
·         El título del informe, que aparecerá una vez en la parte superior del informe.
·         Un encabezado de página, que aparecerá en la parte superior de cada página.
·         Una sección de detalle, que normalmente contiene los datos de los informes primarios.
·         A pie de página, que aparecerá en la parte inferior de cada página.
·         Una sección de resumen, que aparecerá al final del informe.


Instalación de iReport en NetBeans


Primer paso. Instalación del plugin iReport.

 Link para descargar el plugin: 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

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


Link de las librerías de JasperReport:


En este caso estamos trabajado con 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

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




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 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.


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”.


Creación de reportes usando Wizard, archivo jrxml



Crearemos nuestro primer reporte utilizando el Wizard de iReport para lo cual vamos al menú “File -> New” y en la parte inferior derecha damos clic en Launch Report Wizard.


A continuación, seguiremos una serie de pasos guiada por el Wizard:
·         Colocar el nombre y la ruta del archivo .jxrml de nuestro reporte.
·         Diseñamos el Query con los campos necesario para nuestro reporte Ejemplo: “SELECT * FROM estudiante” y damos clic en siguiente.
·         Seleccionamos todos los campos y damos clic en siguiente.
·         Por último agrupamos los campos de ser necesario sino damos clic en terminar.
Ahora tenemos creada nuestra plantilla solo falta realizar un diseño de acuerdo a nuestro gusto o el requerimiento del proyecto, yo la hare sencilla para el objetivo de esta prueba.


En la parte derecha encontramos la paleta y todos los elementos disponibles para nuestro diseño para este caso solo usare los elementos: Static Text y TextField. (En los TextField dar clic derecho en edit expression y escoger el campo adecuado a mostrar).



Una vez finalizado el diseño damos clic en preview esperamos que compile el .jrxml y se nos abrirá automáticamente el documento .pdf (cabe mencionar que también se puede exportar otros formatos de documentos).


Ahora crearemos 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”, luego colocamos el nombre del proyecto y seleccionamos el check Create Main Class y damos clic en finish.

Para utilizar JasperReport debemos de crear nuestra biblioteca con los .jar de jasper para esto vamos al menú “Tools -> Libraries” y seleccionamos los siguientes .jar
·         jasperreports-5.5.0.jar
·         jasperreports-5.5.0-javaflow.jar
·         jasperreports-fonts-5.5.0.jar
·         commons-beanutils-1.8.0.jar
·         commons-collections-2.1.1.jar
·         commons-digester-2.1.jar
·         commons-logging-1.1.1.jar
·         commons-javaflow-20060411.jar
·         groovy-all-2.0.1.jar
·         iText-2.1.7.jar
·         png-encoder-1.5.jar
·         poi-3.7-20101029.jar



Algunos de estos jars se encuentran en el directorio “dist” y otros en el directorio “lib” del archivo .zip de JasperRepots que descargamos. Luego al añadirlos todos damos clic en OK.
En la parte izquierda inferior del proyecto damos clic derecho en Libraries y seleccionamos “Add Library” y escogemos la librería que acabamos de crear en mi caso se llama JASPER damos clic en Add Library.
Cuando hicimos las primeras pruebas en iReport se generó un archivo, este archivo lo copiamos en el directorio raíz de nuestro proyecto de NetBeans.



Ahora creamos la conexión hacia la base de datos, no olviden agregar el .jar del driver de MySQL o también pueden agregar la librería que viene incluida en NetBeans.
1
2
3
4
public static void main(String[] args) throws Exception{
Class.forName("com.mysql.jdbc.Driver");
Connection conexion = DriverManager.getConnection("jdbc:mysql://192.168.1.6:3306/PRUEBA",
 "jossjack", "123456");
}
Al tratar de hacer la conexión es posible que ocurra un error, y se lance una excepción de tipo “java.sql.SQLException”. Para solucionar esto pueden hacer dos cosas. La primera es rodear estas líneas en una clausula try/catch. La segunda opción es agregar la cláusula throws Exception en el método main.
Ahora se cargará el archivo jasper para lo cual se necesitará de estas clases:
·         import net.sf.jasperreports.engine.JasperReport
·         import net.sf.jasperreports.engine.util.JRLoader

1
JasperReport reporte = (JasperReport) JRLoader.loadObject("jack.jasper");
Ahora el objeto “reporte” contiene la definición del reporte, ahora solo falta llenarlos con la información de la base de datos. Para esto usamos las clases:
·         import net.sf.jasperreports.engine.JasperFillManager
·         import net.sf.jasperreports.engine.JasperPrint;

JasperFillManager tiene un método estático, “fillReport”, que nos permite llenar el reporte con datos obtenidos de distintas fuentes de datos. En este caso la fuente de datos es la conexión directa a la base de datos que creamos anteriormente (el objeto conexion).
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:
·         import 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:
·         import net.sf.jasperreports.engine.JRExporter
El cual es una interface, y las clases que la implementan nos permiten generar el reporte en distintos formatos de una forma sencilla. Se pueden generar los reportes en los siguientes formatos:
·         PDF
·         HTML
·         CSV
·         RTF
·         TXT
·         XLS
·         XML
·         XLSX
·         DOCX
·         PPTX

Si queremos guardar el reporte en formato .pdf tenemos que crear un objeto net.sf.jasperreports.engine.export.JRPdfExporter y lo asignamos al objeto exporter.
1
2
3
4
JRExporter exporter = new JRPdfExporter();
exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new java.io.File("reporte_jackPDF.pdf"));
exporter.exportReport();
La segunda línea asigna a nuestro objeto “exporter” el “jasperPrint” ya con los datos. La tercera línea le dice al “exporter” cuál será el nombre del archivo generado. 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 “reporte_jackPDF.pdf”:
Asi quedaria el codigo de la clase Main:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.sql.Connection;
import java.sql.DriverManager;
import net.sf.jasperreports.engine.JRExporter;
import net.sf.jasperreports.engine.JRExporterParameter;
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;
public class Reporte_jack {
public static void main(String[] args) throws Exception {
Class.forName("com.mysql.jdbc.Driver");
Connection conexion = DriverManager.getConnection
("jdbc:mysql://192.168.1.6:3306/PRUEBA", "jossjack", "123456");
JasperReport reporte = (JasperReport) JRLoader.loadObject("jack.jasper");
JasperPrint 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("reporte_jackPDF.pdf"));
exporter.exportReport();
}
}

Para generar un reporte web crearemos un Servlet en este caso ReporteWeb, el cual puede recibir parametros ya sea mediante requerimientos GET, pasandole atributos en la sesion o en el request de manera que el reporte generado pueda ser más específico.
Primero crearemos una conexion hacia la base de datos que llamaremos
Connection conexion = C.getConn(); 
luego pasaremos como parametro al metodo JasperRunManagerToPdf los objetos jasperReport y la conexion
byte[] bytes = JasperRunManager.runReportToPdf(jasperReport, parametros, conexion);
que devolvera una cadena de bytes que seran enviada como streaming al cliente, mediante un ServletOutputStream.
Asi quedaria el codigo del Servlet:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import com.web.conexion.Conexion;
import java.io.File;
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.ServletContext;
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.JasperReport;
import net.sf.jasperreports.engine.JasperRunManager;
import net.sf.jasperreports.engine.util.JRLoader;

public class ReporteWeb extends HttpServlet {
    protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException, SQLException {
        ServletContext sc;
        Map parametros = new HashMap();
        sc = this.getServletContext();
        Connection conexion = null;
        Conexion C = null;
        try {
            C = new Conexion();
            C.conectar();
            conexion = C.getConn();
            File reportFile = new File(sc.getRealPath("/reportes/jack.jasper"));
            JasperReport jasperReport = (JasperReport)
JRLoader.loadObject(reportFile.getPath()); //se ejecuta el reporte
            byte[] bytes = JasperRunManager.runReportToPdf(jasperReport,
parametros, conexion);
            response.setContentType("application/pdf");
            response.setContentLength(bytes.length);
            ServletOutputStream ouputStream = response.getOutputStream();
            ouputStream.write(bytes, 0, bytes.length);
            ouputStream.flush();
            ouputStream.close();
        } catch (JRException e) {
            throw new ServletException(e);
        } catch (IOException e) {
            throw new ServletException(e);
        } finally {
            conexion.close();
        }
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        try {
            processRequest(request, response);
        } catch (SQLException ex) {
            Logger.getLogger(ReporteWeb.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Al llamar al Servlet mediante un requerimiento GET este mostraria el reporte en el navegador.








Campos calculados en iReport

Solo tenemos textos estáticos y "fields" para mostrar un reporte básico de los datos de ciertos participantes. Si lo recuerdan, la salida del reporte al generarlo desde nuestra aplicación Java, es la siguiente:
Ejemplo:




PARAMETROS
Ahora pasaremos a agregar "Parameters" a este reporte. Como dije en el tutorial anterior: los parámetros son valores que usualmente se pasan al reporte desde el programa que crea el "JasperPrint" del reporte (nuestra aplicación Java) haciendo uso de un         "java.util.Map".

En este caso pasaremos dos parámetros: el título del reporte, y el nombre del autor del       mismo.

Al igual que con los Fields, para poder hacer uso de un parámetro 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 opción "Add Parameter" (la única    habilitada).





Con esto se agregará un nuevo parámetro llamado "parameter1" de tipo "java.lang.String". Cambiamos en nombre del parámetro en la ventana de propiedades a "titulo" (recuerden que este nombre es el que deberemos usar desde nuestra aplicación Java para establecer el valor del parámetro).




Agregamos otro parámetro llamado "autor" de la misma forma que agregamos el de "titulo".




Ahora eliminamos el elemento que teníamos como título del reporte (el que contiene el texto estático "Reporte de Participantes") y lo reemplazamos por el parámetro "titulo" arrastrándolo desde la ventana del "Report Inspector" a la banda "Title".




Ajustamos este elemento para que tenga el mismo formato que el título que teníamos anteriormente.

Ahora agregamos el segundo parámetro ("autor") en la banda "Page Header", la cual se repite en la parte superior de cada una de las páginas (en la primera página aparece después del título), arrastrándolo a esta             banda.




Si dejamos esta expresión tal y como está ("$P{autor}") solo se mostrará en nombre del autor en la parte superior de cada una de las páginas (por ejemplo si el autor del reporte es "Juan", solo veremos la palabra "Juan" en la parte superior de los reportes). Esto podría no ser claro para quienes revisen este reporte, por lo que queremos indicar de forma explícita que a lo que se refiere el valor de este parámetro es el nombre del autor. Para hacer esto nos dirigimos a la ventana de propiedades de este parámetro (para lo cual debemos tenerlo seleccionado) y buscamos la categoría "Text field properties". Ahi se encuentra una propiedad llamada "Text Field Expression" cuyo valor es          "$P{autor}".





Lo que haremos es editar esta expresión para anteponer la palabra "Autor: ". Para hacer esto presionamos el botón "...", con lo que se abrirá una ventana que nos permitirá editar la expresión. En esta ventana modificamos la expresión "$P{autor}" para que quede "Autor: " + $P{autor}. Con esto lo que logramos es que a la cadena estática "Autor: " se le concatene el valor de la expresión dinámica "$P{autor}". Por lo que ahora el lo que aparecerá en la parte superior de cada página del reporte será la cadena "Autor:            Juan".




Ahora presionamos el botón "Compile Report" para que se genere el reporte compilado "reporte2.jasper".

Veamos una vista previa del reporte, para esto hacemos clic en la pestaña "Preview". Nos pedirá los valores de los dos parámetros. Si colocamos para el parámetro "titulo" el valor "Reporte" y para el parámetro "autor" el valor "Alex" el preview que veremos será el siguiente:





Ahora veremos cómo pasarle estos valores desde nuestra aplicación 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 línea en donde creamos nuestro objeto "JasperPrint":


 
JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, null, new JRBeanCollectionDataSource(listaPariticipantes));


Y antes de esta línea crearemos un objeto "java.util.Map" que contendrá nuestros parámetros. Colocaremos el nombre de los parámetros (en este caso "autor" y "titulo") como llave y sus respectivos valores, "Juan" para el autor y "Reporte Participantes" para el título, como             valores.


 
Map<String, String> parametros = new HashMap<String, String>();
parametros.put("autor", "Juan");
parametros.put("titulo", "Reporte Participantes");


Y pasamos este "Map" como el segundo parámetro del método "fillReport", al que hasta ahora le hemos pasado             "null":

JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, parametros, new JRBeanCollectionDataSource(listaPariticipantes));


El código de nuestro método "main" queda así:

 
public static void main(String[] args) throws Exception
{
    List<Participante> listaPariticipantes = new ArrayList<Participante>();
    
    for (int i = 1; i <= 10; i++)
    {
        Participante p = new Participante(i, "Particpante " + i, "Usuario " + i, "Pass " + i, "Comentarios para " + i);
        listaPariticipantes.add(p);
    }
 
    JasperReport reporte = (JasperReport) JRLoader.loadObject("reporte2.jasper");
 
    Map<String, String> parametros = new HashMap<String, String>();
    parametros.put("autor", "Juan");
    parametros.put("titulo", "Reporte Participantes");
 
    JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, parametros, new JRBeanCollectionDataSource(listaPariticipantes));
 
    JRExporter exporter = new JRPdfExporter();
    exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
    exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new java.io.File("reporte3PDF.pdf"));
    exporter.exportReport();
}


Si ejecutamos nuestro reporte obtendremos un archivo con el siguiente contenido:




Como podemos ver los parámetros "titulo" y "autor" han sido reemplazados por los valores "Reporte Participantes" y "Juan" respectivamente.

Gracias a los parámetros podemos pasar valores (como en este caso cadenas, pero podemos pasar prácticamente cualquier tipo de objeto) a nuestro reporte directamente desde nuestra aplicación Java. 

Ahora veremos el último tipo de expresión que JasperReports nos proporciona, las Variables.

Como dije en el post anterior: las variables son objetos usados para almacenar valores como los resultados de             cálculos.

En este caso usaremos dos variables. La primera será una de las variables internas que ya proporciona JasperReports: PAGE_NUMBER, que nos dice el número de la página actual. En este caso como el reporte solo tendrá una página solo aparecerá el número 1, pero pueden extender el ejemplo para que se generen más páginas.

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 método "main" agregamos, en el ciclo que crea los objetos "Participante", el siguiente código 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 aplicación Java debemos ver un reporte con el siguiente             contenido:




Campos calculados
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 opción "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 más adelante, otras opciones incluyen un contador, el promedio, el valor más alto, etc.).

Ahora indicaremos la suma de cuáles valores son los que queremos que se almacene en este variable. Para eso hacemos clic en el botón "..." de la propiedad "Variable Expression", con lo que se abrirá una nueva ventana. Es esta nueva ventana indicaremos de dónde se tomarán los valores para la suma. Podemos usar una expresión tan compleja como necesitemos. Como en este caso solo queremos realizar la suma de los puntos escribimos "F{puntos}". Y presionamos el botón "OK" para confirmar.




Al final las propiedades de nuestra variable deben quedar así:




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 estático y una línea 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 número de página 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 página.

Podría parecer un poco extraño que la banda "Summary" que se encuentra abajo de la banda "Page Footer" en el designer vaya a aparecer antes en el reporte final, pero confíen en mi, así será      ^_^.

Agregaré también un texto estático solo para indicar que el valor que estamos mostrando corresponde al número de página. Al final el reporte queda así:




Ahora guardamos y compilamos nuestro reporte y ejecutamos nuestra aplicación desde el NetBeans. El reporte generado debe verse             así:




Como podemos ver, la variable "sumaPuntos" contiene la suma de los puntos de todos los participantes             (55).

Nuestra clase "Participante" queda de la siguiente forma:


 
public class Participante
{
    private int id;
    private String nombre;
    private String username;
    private String password;
    private String comentarios;
    private int puntos;
    
 
    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)
    {
        this.nombre = 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;
    }
    
    public int getPuntos()
    {
        return puntos;
    }
 
    public void setPuntos(int puntos)
    {
        this.puntos = puntos;
    }
}


y nuestra clase "Main" de la siguiente forma (omitiendo los imports):


 
public class Main
{
    public static void main(String[] args) throws Exception
    {
        List<Participante> listaPariticipantes = new ArrayList<Participante>();
        for (int i = 1; i <= 10; i++)
        {
            Participante p = new Participante(i, "Particpante " + i, "Usuario " + i, "Pass " + i, "Comentarios para " + i);
            p.setPuntos(i);
            
            listaPariticipantes.add(p);
        }
 
        JasperReport reporte = (JasperReport) JRLoader.loadObject("reporte2.jasper");
 
        Map<String, String> parametros = new HashMap<String, String>();
        parametros.put("autor", "Juan");
        parametros.put("titulo", "Reporte Participantes");
 
        JasperPrint jasperPrint = JasperFillManager.fillReport(reporte, parametros, new JRBeanCollectionDataSource(listaPariticipantes));
 
        JRExporter exporter = new JRPdfExporter();
        exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
        exporter.setParameter(JRExporterParameter.OUTPUT_FILE, new java.io.File("reporte3PDF.pdf"));
        exporter.exportReport();
    }
}


Los parámetros son expresiones que nos permiten pasar valores, desde nuestra aplicación Java, a los reportes generador por JasperReports. Y las variables almacenan valores que son el resultado de cálculos de distinta naturaleza sobre los valores que recibimos en nuestro reporte.

Ejecución de reportes, archivo Jasper

Ejecutar un reporte desde Netbeans


Bien para ejecutar un reporte desde NetBeans hagan lo siguiente:
Den de alta un JFrame Form dentro de su proyecto, clic derecho sobre su package principal eligen New – JFrame Form, yo lo llamaré muestraReporte.







Dentro de nuestro JFrame, creamos un botón que es el que va a llamar a nuestro reporte, para esto del lado derecho tenemos el Swing Controls, clic sobre button y vuelves a dar clic sobre el form para que se inserte.



Después haz doble clic sobre el botón para que cree el evento actionPerformed, que es el evento que le indicará a nuestra aplicación que es lo que se hará si se oprime el botón.
Ahora ingresaremos el siguiente código y te lo explico abajo.


Primero si te das cuenta tenemos las librerías que vamos a ocupar y que antes ya importamos, si no lo has hecho checa este post, haz clic aqui.
Después damos de alta nuestro JDialog para indicar que desde una nueva ventana se abrirá nuestro reporte.

Enseguida se da de alta la conexión a la base de datos, yo lo llamo como conexion.conexion por que la primera conexion quiere decir que es mi Package y la segunda conexion quiere decir que es mi Clase, si tienes dudas, verifica este post, haz clic aquí.
Veamos el código que va dentro de nuestro botón.


Bien, la primera línea JasperReport, indica el reporte que quiero abrir, en este caso mi reporte se llama mireporte.jrxml,
La siguiente línea, le indicará al reporteador que va a imprimir, fijate que dentro de JasperFillManager.fillReport hay 3 parametros, te explico para que son, el primero está indicando que reporte vamos a abrir, el segundo será los parametros que vamos a pasar al reporte (por si la consulta (query) de tu reporte necesita valores adicionales para ejecutarse, esto lo veremos en otro post) y el último parámetro es la conexión a nuestra base de datos.
Las siguientes             líneas:
viewer.setSize(1000,700); .- Indicamos el ancho y largo de nuestra ventana que contendrá el reporte.
viewer.setLocationRelativeTo(null); .- Con este código centramos nuestra ventana en el monitor.
JRViewer jrv = new   JRViewer(jasperPrint);
viewer.getContentPane().add(jrv); .- Con estas líneas se prepara el reporte para la vista        previa.
viewer.setVisible(true);.- Con esta línea hacemos visible la ventana que tiene nuestro reporte
Ahora ejecuta tu JFrame, clic derecho a tu JFrame – Run File..









Enlace de reporte con ventana JDialog. Uso de JasperViewer - Ejemplos


JFrame, JDialog y otras ventanas

Cuando queremos hacer ventanitas en java nos encontramos con dos ventanas: El JFrame y el JDialog. ¿Cuándo se usa una u otra?, ¿Qué diferencias hay entre ellas?
JDialog.

Un JDialog se construye de la misma manera que un JFrame la única diferencia es que hereda de la Clase JDialog...... cómo se mencionó anteriormente básicamente son ventanas pero tienen ciertas diferencias, la más notoria es que no posee los botones básicos de las ventanas ni pueden ser visualizados en la barra de tareas.




2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class VentanaConfirmacion extends JDialog
{
 private Container contenedor;
  
 public VentanaConfirmacion(){
  contenedor=getContentPane();
  contenedor.setLayout(null);
  //Asigna un titulo a la barra de titulo
  setTitle("CoDejaVu : Titulo Del JDialog");
  //tamaño de la ventana
  setSize(300,200);
  //pone la ventana en el Centro de la pantalla
  setLocationRelativeTo(null);
 }
}

Igual que El anterior, este código crea una ventana de dialogo Vacía, se llaman de dialogo por las características mencionadas que la diferencian de una ventana normal.

Si ejecutamos las 2 clases veremos estas diferencias.


Como vemos lo principal en estos momentos es que la ventana que hereda de JFrame tiene los botones básicos de toda ventana, además permite su visualización en la barra de tareas, mientras que la ventana que hereda de JDialog no posee estas características.  JFrame y JDialog

Los dos tipos de ventanas principales que tenemos en java son JFrame y JDialog. Hay varias diferencias entre ellas y en función de estas diferencias vamos a ver para qué sirven
  • Si instanciamos un JFrame, en la barra de abajo de windows (creo que se llama "barra de herramientas") nos aparece un nuevo "botoncito" correspondiente a nuestra aplicación. Si instanciamos un JDialog, no aparece nada.
  • Un JFrame tiene un método setIconImage() para cambiar el icono por defecto de la taza de café. JDialog no tiene este método.
  • Un JDialog admite otra ventana (JFrame o JDialog) como padre en el constructor. JFrame no admite padres.
  • Un JDialog puede ser modal, un JFrame no.
Todo esto nos indica lo siguiente:
  • Un JFrame debe ser la ventana principal de nuestra aplicación y sólo debe haber una.
  • Las ventanas secundarias de nuestra aplicación deben ser JDialog.

Los motivos de esto son los siguientes.
Al mostrar el JFrame un botón en la barra de herramientas de windows y tener método para cambiar el icono, es la ventana ideal como ventana principal de nuestra aplicación y sólo debe haber una. Nos permite cambiar el icono y sólo debe haber un botón en la barra de herramientas de windows para nuestra aplicación.
Si usamos un JDialog como ventana principal, no tenemos botón en la barra de herramientas y no hay forma fácil de cambiarle el icono.
Los JDialog son ideales para ventanas secundarias porque admiten una ventana padre. Si la VentanaA es padre del JDialogB, entonces el JDialogB siempre estará por delante de VentanaA, nunca quedará por detrás. Lo ideal es que hagamos nuestras ventanas secundarias como JDialog cuyo padre sea el JFrame principal. De esta forma los JDialogsiempre serán visibles por encima del JFrame y no se irán detrás ni quedarán ocultos por el JFrame.
Otra ventaja de admitir un padre es que heredan el icono de él. Si hemos cambiado el icono del JFrame con el método setIconImage(), entonces todos los JDialog que hagamos como hijos de este JFrame heredarán el icono. Todas las ventanas de nuestra aplicación tendrán el mismo icono en lugar de la taza de café por defecto.

Jerarquía de padres y ventanas modales

Un JDialog puede ser modal, pasándole un true en el constructor en el sitio adecuado o haciéndolo modal con el método setModal(). Si hacemos un JDialog modal, todas las demás ventanas se deshabilitarán hasta que el usuario de nuestro programa cierre el JDialog. Esto está estupendo para pedir un dato al usuario y evitar que toque otras cosas hasta que haya introducido el dato. Sin embargo, tiene un peligro.
Supongamos un JDialog que lo hacemos modal para pedir unos datos al usuario. Este JDialog tiene un botón de "Aceptar" para que el usuario lo pulse cuando haya terminado de introducir los datos. Supongamos que en el código de ese botón "Aceptar" comprobamos los datos que ha metido el usuario y vemos que son incorrectos. Le sacamos un segundo JDialog modal para indicarle el error y no cerramos el primero.
¿Quién debe ser el padre de ese segundo JDialog modal?. Si hacemos que el padre sea el JFrame tendremos dos JDialog modales hijos del JFrame, es decir, dos JDialogmodales hermanos. Esto nos dará problemas, como que ambas ventanas queden deshabilitadas, que al cerrar una de ellas se nos oculten todas, que parte de la ventana quede deshabilitada mientras que otra parte no, etc.
Entonces, ¿cómo hacemos? Para que java no haga cosas raras, el padre del segundo JDialog modal debe ser el primer JDialog modal. De esta forma, el segundo tiene "prioridad" sobre el primero. Todo queda deshabilitado excepto este segundo JDialog. Cuando lo cerremos, será el primero el que mande.
Resumiendo, si queremos varias ventanas modales simultáneamente en pantalla, cada ventana que se muestre debe ser padre de la siguiente, de forma que las cadenas de ventanas modales sean padres, hijo, nieto, etc. Tener dos ventanas modales simultaneas que sean hermanas o primas o cualquier otra relación que no sea directa, nos dará problemas.




Ejemplos con el uso de JasperViewer
Ya teníamos un JFrame form donde abrimos un reporte con una consulta SQL sencilla, ahora vamos a pasar el valor que tenga un JTextField.
Para esto agreguemos a nuestro proyecto un campo de texto JTextField, seleccionando nuestro JTextField, dale clic en Properties y elimina el contenido de text, para que nuestro campo quede en blanco.




Después volvemos a dar clic sobre el botón para ir al código que ejecuta el botón.
Observa el nuevo código que marco y te lo explico.
Primero, observa que al proyecto se agregaron 2 librerías:
import            java.util.HashMap;
import java.util.Map;


Después verifica que



La Interface Map en Java, nos permite representar una estructura de datos para almacenar pares “clave/valor”; de tal manera que para una clave solamente tenemos un valor., entonces primero damos de alta una variable de tipo Map que se llama parámetros, y luego con put, agregamos una clave/valor, en este caso mi clave que va a identificar el valor de mi JTextField es usuarioLog y este mismo nombre ocuparemos para dar de alta un parametro en mi reporte y el valor que va a tener esa clave obviamente es el contenido de mi JTextField, que recogemos con getText();
Después, para mandar los parámetros lo vamos hacer desde la línea JasperFillManager.fillReport, fíjate que ahora pasamos como parámetro la variable de tipo Map que se llama parámetros y ya no esta el null.
De aqui es todo, ahora,  para ocupar el valor que estamos mandando al reporte, nos vamos a nuestro reporte en IReports, clic derecho al nombre de nuestro reporte y elegimos Edit Query…


Ahora vamos a dar de alta el parámetro que recibirá el valor que enviamos de nuestro proyecto, para esto haz clic en el botón New Parameter…


Aparecerá una ventana que te pide el nombre del parámetro que vas a crear, el nombre del parámetro será el nombre de la clave que elegiste para guardar tu valor, para el caso del ejemplo es usuarioLog…, haz clic en ok.



Ya tenemos nuestro nuevo parámetro que recibirá el valor que estamos enviando desde nuestro proyecto JAVA.



Vamos hacer nuestra consulta un poco mas compleja, vamos a pedir a los usuarios que su campo usuario contenga “VEN”, la consulta quedaría así, observa como queda la consulta…



Bien, atiende a lo siguiente: estoy usando el operador like en mi consulta, que indica que dentro de lo que haya en los signos de porcentaje (‘%%’) buscará coincidencia en el campo usuario, observa que dentro de los porcentajes metí el parámetro que creamos, esto lo hice arrastrándolo dentro de los porcentajes, nota también que entre la P y el paréntesis de apertura hay un símbolo de exclamación (!), ese no lo pone el sistema, lo tienes que poner tu manualmente, si no, el parámetro no funciona.
Guarda los cambios y a probar lo que hemos hecho, corre form de muestraReporte, clic derecho sobre el JFrame form elige run file…




Ahora en el campo de texto pongo una parte del texto que quiero buscar para que mi consulta que está en mi reporte llene el mismo.







Ya tenemos un reporte dinámico.
2.  Resumen
Jasper Report es una librería para la generación de informes. Está escrita en java y es libre. El funcionamiento consiste en escribir un xml donde se recogen las particularidades del informe. Este XML lo tratan las clases del Jasper para obtener una salida que pueden ser un PDF, XML, HTML, CSV, XLS, RTF, TXT.
Para generar el XML, o el compilado. Jasper les recomiendo descargar la herramienta iReport que es un Entorno Gráfico que está implementado en java y se integra perfectamente con el Jasper Report.

Aunque JasperReports se utiliza principalmente para capacidades de reporte a las aplicaciones basadas en la Web a través de la API de Servlet, no tiene absolutamente ninguna dependencia de la API Servlet o cualquier otra biblioteca de Java EE. No hay nada que nos impida la creación de aplicaciones de escritorio Java para generar informes con JasperReports.
JasperReports nos permite separar los datos en secciones. Estas secciones incluyen:
·         El título del informe, que aparecerá una vez en la parte superior del informe.
·         Un encabezado de página, que aparecerá en la parte superior de cada página.
·         Una sección de detalle, que normalmente contiene los datos de los informes primarios.
·         A pie de página, que aparecerá en la parte inferior de cada página.
·         Una sección de resumen, que aparecerá al final del informe.

3.  Summary
Jasper Report is a library for the generation of reports. It is written in java and is free. The operation consists of writing an xml where the particularities of the report are collected. This XML is treated by the Jasper classes to obtain an output that can be PDF, XML, HTML, CSV, XLS, RTF, TXT.
To generate the XML, or the compiled one. Jasper, I recommend you download the iReport tool, which is a Graphical Environment that is implemented in java and integrates perfectly with the Jasper Report.

Although JasperReports is primarily used for reporting capabilities to Web-based applications through the Servlet API, it has absolutely no dependency on the Servlet API or any other Java EE library. There is nothing stopping us from creating Java desktop applications to generate reports with JasperReports.

JasperReports allows us to separate the data into sections. These sections include:
• The title of the report, which will appear once at the top of the report.
• A page header, which will appear at the top of each page.
• A detail section, which normally contains the data of the primary reports.
• Footnote, which will appear at the bottom of each page.
• A summary section, which will appear at the end of the report.

4.  Conclusiones
ü  Poco a poco vamos viendo nuevas funcionalidades de jasperReport/iReport, que los hacen unas herramientas muy potentes a la hora la generación de informes dinámicos. Con cada nueva release se hacen cada vez más dinámicos y más fáciles de manejar.
ü  Es muy util para general reportes. Para conyevar a un mejor manejo de propuestas de negocios y nos permite tener un orden especifico.
5.  Apreciación del Equipo
Ø   Es importante conocer jasperReport/iReport ya que nos permite crear reportes de diversos tipos.
Ø  Nos ayuda a conocer la informacion almacenada en una base de datos mucho mas ordenado.
Ø  Cuando creamos nuestros sistemas en diferentes lenguajes de programacion necesitamos y requerimos ver los reportes de los movimientos que se generan en el sistema es por ello que gracias a la libreria  JasperReport se nos hace mas facil generar reportes en varios tipos de formato como pdf,txt,html entre otras con pocas lineas de codigo de tal manera que mostremos nuestra informacion requerida de forma ordenada y especifica.
Ø   este tema de jasperreport fue muy importante para nosotros ya que nos ayudo a crear reportes para nuestro proyecto final de una manera no muy complicada y entendible e incluso tambien pudimos realizar campos calculados como una suma,etc.fue de muy buena utilidad.

6.  Glosario de Términos
Xml: (Extensible Markup Language) es un lenguaje de etiquetas, es decir, cada paquete de información está delimitado por dos etiquetas como se hace también en el lenguaje HTML, pero XML separa el contenido de la presentación.
HTML: Es el lenguaje que se emplea para el desarrollo de páginas de internet. Está compuesto por una serie de etiquetas que el navegador interpreta y da forma en la pantalla
Plugin: En informática, un complemento o plug-in es una aplicación que se relaciona con otra para agregarle una función nueva y generalmente muy específica.
Datasources: Tienen un conjunto de propiedades que identifica y describe el origen de datos que representa. Estas propiedades incluyen información como la ubicación del servidor de la base de datos, el nombre de la base, y el protocolo de red para comunicarse
Archivo jrxml: Estos archivos se conocen como JasperReports Layout archivos que contienen definiciones de diseños de informes guardados en XML formato.
JDBC: Java Database Connectivity, más conocida por sus siglas JDBC, ​​ es una API que permite la ejecución de operaciones sobre bases de datos desde el lenguaje de programación Java.

7.   Linkografías

Øhttps://www.google.com.pe/search?q=instalar+plugin+ireport+netbeans&sa=X&ved=0ahUKEwihlb2gsvHXAhWFYd8KHaEeDKcQ1QIIZigC&biw=1366&bih=662
Øhttp://www.javapuntes.com/informes-instalacion-de-jasperreports-y-plugin-ireport-en-netbeans/
Ø  https://jossjack.wordpress.com/2014/06/15/jasperreport-ireport-en-netbeans/
Ø  http://plugins.netbeans.org/plugin/4425/ireport
Ø  https://www.adictosaltrabajo.com/tutoriales/odbc-ireport/
Ø  https://www.adictosaltrabajo.com/tutoriales/datasources-jasper-reports/
Ø  https://www.adictosaltrabajo.com/tutoriales/java-bean-datasource/
Ø  http://www.javatutoriales.com/2009/04/creacion-de-reportes-con-jasperrepots-y_18.html
Ø  http://www.javatutoriales.com/2009/03/creacion-de-reportes-con-jasperrepots-y_30.html
Ø  http://www.elprogramador.com.mx/ejecutar-un-reporte-desde-netbeans/
Ø  http://www.chuidiang.org/java/novatos/JFrame_JDialog.php
Ø  http://codejavu.blogspot.pe/2013/08/jframe-y-jdialog.html

 LINK DE LA DIAPOSITIVA : 

https://es.slideshare.net/VicenteAlberca/jasreport








Publicado por en

No hay comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)