Reportes

1. CONTENIDO
1.1. 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.
A continuación los pasos detallados.
Primer paso. Instalación del plugin iReport.
Bajaremos la última versión que encontremos del plugin iReport de la web oficial de Netbeans.

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.
1.2. 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 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".
1.3. Creación de reportes usando Wizard, archivo jrxml
Ahora 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 ultimo 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 encotramos 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 abrira automaticamente el documento .pdf (cabe mencionar que tambien 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.
1.4. Campos calculados en iReport.
Paso 1: Creamos un nuevo Reporte, Seleccionamos nuestra Base de Datos, las tablas o visitas; de las cuales queremos elaborar dicho reporte y nos mostrara la siguiente ventana.
Paso 2: Seleccionamos los campos que son necesarios para mi Reporte, y vamos arrastrando uno a uno hacia la fila que dice “Detalle”; automáticamente irán apareciendo los nombres del encabezado de cada columna de esta manera cómo podemos ver en la imagen.
Paso 3: Arrastramos el campo para el cual deseamos hacer un campo calculado en nuestro reporte y lo arrastramos hacia la fila de dice “Page Footer”, en este caso se realizará la suma total de todos los sueldos, de un empleado, como podemos visualizar en la imagen.
Paso 4: Como proceso final si podemos ver en esta visualización de nuestro reporte, en donde apunta la flecha del cursor, notamos que hay un campo calculado del Total de todos los sueldos. Observemos.
1.5. Ejecución de reportes, archivo jasper
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á al 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 esta 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..







1.6. Enlace de reporte con ventana JDialog. Uso de JasperViewer - Ejemplos
Los JDialog admiten un padre y pueden ser o no modales. ¿Para qué sirve ese padre? ¿Puedo hacer cualquier JDialog modal?
Otras veces queremos hacer una ventana de error, de aviso, para pedir un dato o confirmar algo. ¿Pongo JFrame o JDialog para esas ventanas? ¿Tengo que construirla?
Vamos a tratar en este tutorial de echar un vistazo a JFrame y JDialog, así como a JOptionPane y ver cuándo usamos una u otra. Trataremos de responder a todas estas preguntas.

 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 JDialog siempre 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.
Estos componentes hacen parte del paquete javax.swing, básicamente nos permiten crear Ventanas para nuestras aplicaciones y en ellas alojar otros componentes para darle cuerpo a la interfaz de usuario, en si tienen comportamientos similares y a simple vista pueden parecer iguales, pero son componentes distintos.

 Un JFrame permite crear una ventana con ciertas características, por ejemplo podemos visualizarla en nuestra barra de tareas, caso contrario de los JDialog, ya que estos últimos son Ventanas de Dialogo con un comportamiento diferente, no se puede ver la ventana en la barra de tareas ni posee los botones comunes de maximizar o minimizar....

 Los JDialog pueden ser hijos de JFrames o de otros JDialog mientras que los JFrame no (Como así Hijos?), es decir, si tenemos claros conceptos de programación Orientada a Objetos podemos relacionar esto de Hijos con el concepto de Herencia (Aunque no directamente, es mas a nivel conceptual), con estos componentes podemos hacer que una Ventana sea Padre de otra Ventana de tipo JDialog, asignándole algún tipo de comportamiento o dejando la ventana padre como Principal.

 Es recomendable cuando trabajemos con GUI's crear un único JFrame para toda la aplicación y el resto de ventanas podemos trabajarlas como JDialog ya que de esa manera evitamos que se creen varias ventanas independientes y en vez de eso otras dependientes de la principal.
Podemos encontrar muchas consideraciones sobre estos componentes pero lo anterior es básicamente lo que necesitamos saber en términos generales.
Uso de JasperViewer
Los reportes son otras de las utilidades más importantes en las aplicaciones ya que su función es dar al usuario información ordenada y limpia así como un formato adecuado para poder ser llevado a impresión o almacenarlo en algún tipo de fichero como .doc, .odt, pdf, etc.
Recuerdo que hace muchos post anteriores hablé sobre JasperReports, una herramienta Open Source para emitir reportes en Java. Pueden usarlo externamente descargándolo desde jasperforge, o instalar el complemento en netbeans como se explicó en el post mencionado (Instalación de JasperReports).
El siguiente paso es realizar el reporte, que no es nada complicado, basta con establecer la conexión a la base de datos que deseemos, arrastrar los campos de las tablas que necesitemos y ordenarlos, darle un formato decente y ya está, al guardarlo debe generarse un fichero .jrxml, al cual invocaremos desde nuestro código fuente.
Antes de continuar, debemos contar en el proyecto con la librería:
Si antes se instaló el JasperReports es posible que la librería ya lo tengamos en el ordenador, incluso el IDE de desarrollo lo tiene indexado, solo deberá ser añadido a proyecto.
Otras de la librerías que necesitaremos están comentados en el encabezado del código de Ejemplo.
El siguiente procedimiento va a recibir como parámetro la ubicación del reporte dentro del proyecto, para ello será necesario incluir los reportes en algún directorio dentro del proyecto en el que trabajamos
1.6.1. Ejemplos
JDialog
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);
 }

}

JFrame
       
 import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

public class EjemploJFrame extends JFrame {

    private JPanel contentPane;

    // METODO PRINCIPAL QUE ARRANCA TODA LA APLICACIÓN
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    // crea el JFrame 
                    EjemploJFrame frame = new EjemploJFrame();
                    // lo hace visible
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // EL CONSTRUCTOR QUE SE USA CUANDO ARRANCA AQUÍ ARRIBA
    public EjemploJFrame() {
        // el titulo de la ventana
        setTitle("Swing: Jugando con las ventanas by jnj");
        // acción al cerrar el frame: sale del programa
        // en éste caso, terminando la ejecución
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // posición de las esquinas del formulario en tu escritorio
        setBounds(100, 100, 450, 433);
        // el panel que contiene todo
        contentPane = new JPanel();
        // borde del panel
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        // se pone el panel en la ventana
        setContentPane(contentPane);
        // se establece disposición de las capas a null
        // para poder posicionar por coordenadas los componentes
        // ésto se hace con un Absolute Layout que se llama
        // en el diseñador visual
        contentPane.setLayout(null);

        // el botón que abre ventanas de diálogo
        JButton btnAbrirUnaVentana = new JButton(
                "Abrir una ventana de diu00E1logo con el usuario");
        btnAbrirUnaVentana.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                EjemploJDialog dialogo = new EjemploJDialog();
                dialogo.setVisible(true);
            }
        });
        btnAbrirUnaVentana.setBounds(10, 11, 414, 23);
        contentPane.add(btnAbrirUnaVentana);

        // el botón que abre ventanas de diálogo
        // pero de manera MODAL
        JButton btnAbrirUnaVentana_1 = new JButton(
                "Abrir una ventana de diu00E1logo MODAL");
        btnAbrirUnaVentana_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                EjemploJDialog dialogo = new EjemploJDialog();
                dialogo.setModal(true);
                dialogo.setVisible(true);
            }
        });
        btnAbrirUnaVentana_1.setBounds(10, 70, 414, 23);
        contentPane.add(btnAbrirUnaVentana_1);

        JLabel lblSiLaAbrimos = new JLabel(
                "Si la abrimos modal, hasta no cerrarla no podemos tocar u00E9sta ventana.");
        lblSiLaAbrimos.setBounds(10, 45, 414, 14);
        contentPane.add(lblSiLaAbrimos);

        // el panel-escritorio donde veremos los JFrames internos 
        final JDesktopPane desktopPane = new JDesktopPane();
        desktopPane.setBounds(10, 138, 414, 246);
        contentPane.add(desktopPane);

        // botón para abrir las ventanas internas
        JButton btnAbrirUnJframe = new JButton(
                "Abrir un JFrame interno aquu00ED abajo");
        btnAbrirUnJframe.addActionListener(new ActionListener() {
            // variable para que cada nueva ventana interna
            // salga en diferente posición y se vean todas
            int posicioninicial = 0;

            public void actionPerformed(ActionEvent e) {
                EjemploJInternalFrame jif = new EjemploJInternalFrame();
                jif.setVisible(true);
                // posición de la nueva ventana
                jif.setLocation(posicioninicial, posicioninicial);
                // las siguiente posición será diferente así
                // veremos todas las ventanas internas
                posicioninicial += 10;
                desktopPane.add(jif);
            }
        });
        btnAbrirUnJframe.setBounds(10, 104, 414, 23);
        contentPane.add(btnAbrirUnJframe);
    }
}
JDialog
       
 import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.border.EmptyBorder;


// AQUÍ EMPIEZA LA CLASE
public class EjemploJDialog extends JDialog {

    private final JPanel contentPanel = new JPanel();

    /* ESTO LO GENERA ECLIPSE PARA PROBAR MIENTRAS CONSTRUIMOS
     * EL DIALOGO, LO PODEMOS DESCOMENTAR PARA
     * PROBAR EL DIÁLOGO SIN PROBAR TODA LA APLICACIÓN COMPLETA 
    public static void main(String[] args) {
        try {
            EjemploJDialog dialog = new EjemploJDialog();
            dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            dialog.setVisible(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }*/

    // CONSTRUCTOR DE LA CLASE
    // crea la ventana, con los bordes, botones,
    // y todos los componentes internos para hacer lo que
    // se pretenda con éste diálogo.
    public EjemploJDialog() {
        // evita cambio de tamaño
        setResizable(false);
        // título del diáolog
        setTitle("u00C9sto es una ventana de diu00E1logo");
        // dimensiones que ocupa en la pantalla
        setBounds(100, 100, 450, 229);
        // capa que contendrá todo
        getContentPane().setLayout(new BorderLayout());
        // borde de la ventan
        contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
        // pone el panel centrado
        getContentPane().add(contentPanel, BorderLayout.CENTER);
        // sin capas para poder posicionar los elementos por coordenadas 
        contentPanel.setLayout(null);
        {
            // aquí se pone el JTextArea dentro de un JScrollPane 
            // para que tenga barras de desplazamiento
            JScrollPane scrollPane = new JScrollPane();
            scrollPane.setBounds(10, 11, 424, 146);
            contentPanel.add(scrollPane);
            {
                JTextArea txtrstoEsUn = new JTextArea();
                txtrstoEsUn.setText("u00C9sto es un JTextArea, aquu00ED podemos poner un texto de varias lu00EDneas.rn1rn2rn3rn..rnrnObserva que no se ve en la barra de tareas que exista u00E9sta ventana.  Si fuera un JFrame su00ED que se veru00EDa en la barra de tareas con el texto  del tu00EDtulo de la ventana...rnrnEl componente JTextArea estu00E1 dentro de un JScrollPane para que se  visualizen las barras de scroll cuando sea necesario.rnrnLa ventana tiene el atributo 'resizable' a 'false' para evitar que se pueda cambiar el tamau00F1o.rnrnrnrnrnrnFin del texto.");
                txtrstoEsUn.setLineWrap(true);
                txtrstoEsUn.setAutoscrolls(true);
                scrollPane.setViewportView(txtrstoEsUn);
            }
        }
        {
            // a continuación tenemos los botones clásicos 'Vale' y 'Cancela'
            // éste código lo ha generado Eclipse...
            JPanel buttonPane = new JPanel();
            buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT));
            getContentPane().add(buttonPane, BorderLayout.SOUTH);
            {
                JButton okButton = new JButton("Vale");
                okButton.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent e) {
                        // aquí van las acciones al hacer click en Vale
                        // envía el diálogo al recolector de basura de Java
                        dispose();
                    }
                });
                okButton.setActionCommand("Vale");
                buttonPane.add(okButton);
                getRootPane().setDefaultButton(okButton);
            }
            {
                JButton cancelButton = new JButton("Cancelar");
                cancelButton.addActionListener(new ActionListener() {
                    public void actionPerformed(ActionEvent arg0) {
                        // aquí van las acciones al hacer click en Vale
                        // envía el diálogo al recolector de basura de Java
                        dispose();
                    }
                });
                cancelButton.setActionCommand("Cancelar");
                buttonPane.add(cancelButton);
            }
        }
    }
}
La clase tiene como nombre Modulo()

       
 public class Modulo {
    private final static Logger LOGGER = Logger.getLogger(Modulo.class.getName()); //Es muy importante el uso del LOGGER para poder mostrar mensajes y no el famoso System.out.print();
    String Driver="sun.jdbc.odbc.JdbcOdbcDriver";
    String URL="jdbc:odbc:Driver=Microsoft Access Driver (*.mdb);DBQ=C:/DataBase.mdb"; //Aquí deberían cambiar según el motor de base de datos que usan.
    String User="Administrador";
    String Password="pass";
    public Connection getConexionBD(){
        Connection cn = null;
        try {
            Class.forName(Driver).newInstance();
            cn=DriverManager.getConnection(URL,User,Password);            
            LOGGER.info("Se conecto!");
        } catch (Exception e) {
            LOGGER.warning(e.getMessage());
        }
        return cn; //Retorna la conexion
    }   
}
En esta clase tenemos un metodo llamado MostrarReporteViewer(), recibe como parametros la ruta donde esta nuestro reporte .jasper y los parametros del reporte.
?

       
 public class Reportes {
  Connection cn=null;
  public void MostrarReporteViewer(String Ruta,Map parametros){
        try {
            BasicConfigurator.configure();
            Modulo obj = new Modulo();
            cn=obj.getConexionBD();            
            JasperReport reporte = (JasperReport) JRLoader.loadObject(Ruta);
            ////////////////////////////////////
            parametros.put(JRParameter.REPORT_LOCALE, Locale.US);
            //Esta línea es muy importante si el formato de los números de tu país es “999,999.00”, 
            //el IReport te mostrara por default “999.999,00”, con esta simple línea podrás solucionar ese problema.
            ////////////////////////////////////
            JasperPrint jasperPrint = JasperFillManager.fillReport(reporte,parametros, cn);
            JasperViewer jviewer=new JasperViewer(jasperPrint,false);
            jviewer.setTitle("");
            jviewer.setVisible(true);
            cn.close();
        } catch (JRException ex) {
            JOptionPane.showMessageDialog(null,"Problemas al Diseñar el reporte");
        } catch (SQLException ex) {
            JOptionPane.showMessageDialog(null,"Problemas en la BD");
        }   
  }  
}
       

       
  public class Asistentes {
   
    private Integer id;
    private String nombre;
    private String apellidos;
    private String dni;

    public Asistentes(){       
    }   
  
    public Asistentes(int id, String nombre, String apellidos, String dni) {
        this.id = id;
        this.nombre = nombre;
        this.apellidos = apellidos;
        this.dni = dni;
    }

    public int getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }
  
    public String getDni() {
        return dni;
    }

    public void setDni(String dni) {
        this.dni = dni;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
   
}
2. RESUMEN
Jasper Report es una librería para la generación de informes. Está escrita en java y es libre. http://jasperforge.org/ 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 http://jasperforge.org/sf/projects/ireport.
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 informe 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.
En cuanto al Data Sourse Una de las configuraciones más habituales con las que nos encontraremos en una aplicación web es el acceso a una o varias bases de datos. La forma habitual de configurar un acceso a base de datos es creando en el servidor un Pool de conexiones que serán reutilizadas y gestionadas por el servidor, y publicarlo como un recurso JNDI. Una vez publicado como recursos JNDI cualquier aplicación desplegada en ese servidor tendrá acceso al pool de conexiones.
Para ello el objeto principal que utilizaremos para configurar el pool de conexiones y publicarlo como recurso JNDI será el javax.sql.DataSource.
La configuración de un pool de conexiones y publicación como recurso JNDI en un Tomcat, WebSphere, Jboss etc es diferente. La forma mas habitual es hacerlo con la interface de administración de cada uno de los contenedores (servidores) y una vez tenemos el nombre JNDI del recurso, la configuración de la aplicación es la misma para todos los servidores, ya que la aplicación hace uso del DataSource utilizando el nombre JNDI referenciado en el fichero de descripción de despliegue o web.xml (Deployment Description).
En este articulo vamos a centrarnos en la configuración de Oracle, la cual no es muy diferente a cualquier otra base de datos como MySql, MariaDB etc.
Para la Creación de reportes usando Wizard, Primero comensaremos creando  un nuevo proyecto Java standalone en NetBeans (File -> New Project... -> Java -> Java Application), le asignamos un nombre (que en mi caso será ReporteGrafica) y presionamos el botón "Finish" para que el nuevo proyecto se genere y veamos en el editor nuestra clase Main. Agregamos al nodo "Libraries" de nuestro proyecto la biblioteca "JasperReports" que creamos en la primer parte del tutorial y el jar "commons-logging-1.1.1.jar",como lo hemos venido haciendo hasta ahora.Adicionalmente debemos agregar dos jars más que nos permitirán generar las gráficas. Puesto que JasperReports hace uso de JFreeChart para generar las gráficas debemos agregar dos de sus jars: jfreechart.jar y jcommon.jar. Si bajaron JasperReports en el archivo .zip que contiene las bibliotecas de soporte entonces ya tienen estos jars (que se encuentran en el directorio lib del .zipanterior), solo deben agregarlos al nodo "Libraries" del proyecto.Ahora necesitamos, como en los casos anteriores, una clase cuyas instancias mantendrán los datos que mostraremos en el reporte. En este caso, como estamos hablando de consolas, creo que lo más adecuado es que esta sea una clase "Jugador". Así que agreguemos esta clase a nuestro proyecto.
Esta clase tendrá tan solo tres atributos: un id (que en este caso podría no ser necesario, pero es para no perder la costumbre, cuando veamos algo de Hibernate veremos que es mejor acostumbrarnos desde el prinicpio a poner este id), un nombre para distinguir al usuario, y el nombre de la consola que tiene (que es el dato que nos interesa para crear la gráfica).Los JDialog admiten un padre y pueden ser o no modales. ¿Para qué sirve ese padre? ¿Puedo hacer cualquier JDialog modal?
Otras veces queremos hacer una ventana de error, de aviso, para pedir un dato o confirmar algo. ¿Pongo JFrame o JDialog para esas ventanas? ¿Tengo que construirla?
Vamos a tratar en este tutorial de echar un vistazo a JFrame y JDialog, así como a JOptionPane y ver cuándo usamos una u otra. Trataremos de responder a todas estas preguntas.
Los reportes son otras de las utilidades más importantes en las aplicaciones ya que su función es dar al usuario información ordenada y limpia así como un formato adecuado para poder ser llevado a impresión o almacenarlo en algún tipo de fichero como .doc, .odt, pdf, etc.

Recuerdo que hace muchos post anteriores hablé sobre JasperReports, una herramienta Open Source para emitir reportes en Java. Pueden usarlo externamente descargándolo desde jasperforge, o instalar el complemento en netbeans como se explicó en el post mencionado (Instalación de JasperReports).
3. SUMMARY
Jasper Report is a library for the generation of reports. It is written in java and is free. http://jasperforge.org/ The operation consists in 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 .jasper compiled, I recommend downloading the iReport tool, which is a Graphical Environment that is implemented in java and integrates perfectly with the Jasper Report http://jasperforge.org/sf/projects/ireport.
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.

Regarding Data Sourse One of the most common configurations that we will find in a web application is access to one or several databases. The usual way to configure a database access is to create in the server a pool of connections that will be reused and managed by the server, and publish it as a JNDI resource. Once published as JNDI resources, any application deployed on that server will have access to the connection pool.

For this the main object that we will use to configure the pool of connections and publish it as a JNDI resource will be the javax.sql.DataSource. The configuration of a pool of connections and publication as a JNDI resource in a Tomcat, WebSphere, Jboss etc is different. The most usual way is to do it with the administration interface of each of the containers (servers) and once we have the JNDI name of the resource, the configuration of the application is the same for all the servers, since the application makes use of the DataSource using the JNDI name referenced in the deployment description file or web.xml (Deployment Description). In this article we will focus on the configuration of Oracle, which is not very different from any other database such as MySql, MariaDB etc. For the Creation of reports using Wizard, First we will start creating a new Java standalone project in NetBeans (File -> New Project ... -> Java -> Java Application), assign a name (which in my case will be GraficaReport) and press the "Finish" button so that the new project is generated and we see in the editor our Main class. We added to the "Libraries" node of our project the library "JasperReports" that we created in the first part of the tutorial and the jar "commons-logging-1.1.1.jar", as we have been doing so far. In addition we must add two jars more that will allow us to generate the graphs. Since JasperReports makes use of JFreeChart to generate the graphs we must add two of its jars: jfreechart.jar and jcommon.jar. If they downloaded JasperReports in the .zip file that contains the support libraries then they already have these jars (which are in the lib directory of the .zipanterior), they should only add them to the "Libraries" node of the project. Now we need, as in the cases above, a class whose instances will maintain the data that we will show in the report. In this case, as we are talking about consoles, I think that it is most appropriate that this is a "Player" class. So let's add this class to our project.


This class will have only three attributes: an id (which in this case might not be necessary, but it is to not lose the habit, when we see something of Hibernate we will see that it is better to get used from the beginning to put this id), a name for distinguish the user, and the name of the console that has (which is the data that interests us to create the graph). JDialog admit a parent and may or may not be manners. What is that father for? Can I do any modal JDialog?

Other times we want to make a window of error, of warning, to request a data or to confirm something. Do I put JFrame or JDialog for those windows? Do I have to build it?

We will try in this tutorial to take a look at JFrame and JDialog, as well as JOptionPane and see when we use one or the other. We will try to answer all these questions.

The reports are other of the most important utilities in the applications since their function is to give the user neat and clean information as well as an adequate format to be able to be printed or stored in some type of file such as .doc, .odt, pdf , etc.
I remember many previous posts I talked about JasperReports, an Open Source tool to issue reports in Java. You can use it externally by downloading it from jasperforge, or install the add-on in netbeans as explained in the mentioned post (Installation of JasperReports).
4. RECOMENDACIÓN
  1. Se recomienda tener una gran  capacidad de entendimiento, bastante interés de investigar para el desarrollo de iReport en NetBeans.
  2. Tener una investigación más vasta de este contenido porque el reporte es un punto inexcusable al momento de desarrollar nuestro software permitiéndonos conocer ciertos aspectos del cliente Empresa.
  3. Ser precavidos al momento de instalar el iReport en NetBeans porque una proterva instalación traerá ramificaciones como no poder abrir su netBeans entre otros, les recomendamos seguir cada paso planteado en este block al momento de instalar su iReport.
  4. Según el software que el desarrollador programe será la profundidad de su reporte, si un programador desarrolla programas extremadamente avanzados recomendamos utilizar los framework que existen, ya que estos nos facilitan el trabajo y tendremos una mejor reputación de nuestros clientes por ende estaremos cumpliendo con los requerimientos planteados de ella, de lo contrario también puede utilizar framework pero eso es opcional.

5. CONCLUSIONES

Tras un escudriñamiento extenso concluimos los siguiente:
Como resultado de la investigación concluimos que la herramienta iReport es una herramienta visual que sirve para generar ficheros XML utilizando la herramienta de generación de informes JasperReport. El jasperReport es software libre que nos permite crear informes, donde los ficheros se definen en un xml para posteriormente ser compilado por las librerías JasperReports (.jasper), es competencia de Crystal reports en los usuarios windows.

Del mismo modo existe muchas herramientas, librerías, framework que nos permiten crear reportes en netbeens pero es necesario conocer las características de cada una de ellas.

También existen fuentes de datos quienes intervienen en el proceso de la creación de reportes como el DATASOURSE representa todo lo relativo a una fuente de datos configurada por el usuario para conectarse a una Base de datos. Es decir, por cada conexión que el usuario quiera establecer con algún(os) fabricante(s), tiene que especificar una serie de información que permitan al Controlador o Driver saber con qué fabricante(s) se tiene que conectar y la cadena de conexión que tiene que enviarle a dicho fabricante(s) para establecer la conexión con la fuente de datos ODBC accedida por el proveedor en cuestión.
Este wizard por otra parte es un asistente que permite la creación de reporte personalizado, mediante una interfaz paso a paso que ayuda al usuario en este propósito: nos ayudará a crear un reporte 100% funcional.

Podemos tambien concluir que el archivo jasper son archivos contienen el contenido de un informe guardado en un formato binario y compilado a partir de un archivo jrxml cuando hablamos de la ventanas que es la ventana jframe y jDialog los JDialog admiten un padre y pueden ser o no modales.

 Por lo tanto la creación de reportes dentro de nuestro software es indispensable ya que es parte fundamental del programa.

6. APRECIACIÓN DEL EQUIPO
Tras desarrolla el contenido de este tema aprendimos mucho acerca de los reportes en netbeens más aun cuando desarrollamos puntos claves como Instalación de iReport en NetBeans, Configuración de DataSource, Creación de reportes usando Wizard, archivo jrxml, Campos calculados en iReport., Ejecución de reportes, archivo jasper, Enlace de reporte con ventana JDialog, Uso de JasperViewer y multiples ejemplos.
Todos estos temas tratados nos ayudaron a conocer mucho sobre los reportes en netbeens comenzando desde la instalación hasta la ejecución de ellas.
Para nosotros fue muy substancial hurgar este contenido porque es indispensable al momento de desarrollar un software para una empresa ya que es parte de los requerimientos de los clientes.
Por otra parte, tuvimos una investigación más desarrollada y aclaramos algunas incertidumbres que apaleábamos con respecto a las librerías y framework que se utiliza al momento de crear reportes, pero gracias a algunos libros y paginas web correspondientes a este tema aclaramos nuestras oscilaciones, para estar seguros de nuestras erudiciones que adquirido lo llevamos a la práctica y no tuvimos ningún inconveniente software 10% funcional.
El reporte es parte del desarrollo de software, en su mayoría en mundo del negocio es de gran ayuda para los clientes al momento de realizar consultas o reportes, etc. Eso desde el punto de vista del cliente. Es por eso que nosotros los desarrolladores de software debemos tener bastante cuidado al momento de crear nuestros reportes.
Tener una investigación más profunda sobre los reportes ya que es un tema demasiado amplio.
7. GLOSARIO DE TÉRMINOS
REPORTES: Ni menos en los reportes. JasperReports es un framework bastante completo 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: iReport.

NETBEANS: es un entorno de desarrollo integrado libre, hecho principalmente para el lenguaje de programación Java. Existe además un número importante de módulos para extenderlo. NetBeans IDE​ es un producto libre y gratuito sin restricciones de uso.

JAVA: es un lenguaje de programación y una plataforma informática comercializada por primera vez en 1995 por Sun Microsystems. Hay muchas aplicaciones y sitios web que no funcionarán a menos que tenga Java instalado y cada día se crean más.

CHECKBOX: es un elemento de interacción de la interfaz gráfica de usuario (widget) del Sistema Operativo con el usuario, que permite a éste hacer selecciones múltiples de un conjunto de opciones.

TEXTAREA : El elemento textarea  representa un campo para la entrada de texto

MULTILÍNEA. El control asociado a este campo es una caja de texto que permite a los usuarios editar múltiples líneas de texto regular.

QUERY :  string o, en español, cadena de consulta es un término informático que se utiliza para hacer referencia a una interacción con una base de datos.

NSA: National Security Agency. Agencia Nacional de Seguridad. Organismo americano para la seguridad, entre otras cosas, informática. 

Packet internet Groper (PING) (Búsqueda de Direcciones de Internet: Programa que se utiliza para comprobar si un destino está disponible

PAP: Password Authentication Protocol. Protocolo de Autentificación por Password. Protocolo que permite al sistema verificar la identidad del otro punto de la conexión mediante password 

PEM: Private Enhanced Mail. Correo Privado Mejorado. Sistema de correo con encriptación 

PGP: Pretty Good Privacity. Paquete de encriptación basado en clave pública escrito por Phil Zimmerman.

POP: Protocolo de Oficina de Correos (Post Office Protocol) Programa cliente que se comunica con el servidor, identifica la presencia de nuevos mensajes, solicita la entre de los mismos. 

PPP: Protocolo Punto a Punto (Point to Point Protocol). Implementación de TCP/IP por líneas seriales (como en el caso del módem). Es mas reciente y complejo que SLIP 

Intranet: Una red privada dentro de una compañía u organización que utiliza el mismo software que se encuentra en Internet, pero que es solo para uso interno. 

DATA SOURCE : Podemos usar esta anotación en una clase de componente de aplicación, como un cliente de aplicación, servlet o EJB (Enterprise Java Bean). Esta anotación define un objeto DataSource y lo registra con JNDI.

JDIALOG : En una aplicación java con ventanas debería haber un único JFrame, correspondiente a la ventana principal de la aplicación. El resto de ventanas secundarias deberían ser JDialog.

COMPILA : Reunir en un solo texto extractos o fragmentos de otras obras ya publicadas: compilarán todos sus relatos en un solo tomo. inform. Traducir un lenguaje de alto nivel a código absoluto o lenguaje binario.

CLASS : es una construcción que le permite crear sus propios tipos personalizados agrupando las variables de otros tipos, métodos y eventos. Una clase es como un plano. Define los datos y el comportamiento de un tipo.

 SQLEXCEPTION : La clase SQLException y sus subtipos proporcionan información acerca de los errores y avisos que se producen mientras se está accediendo a un origen de datos.
8. LINKOGRAFÍA

Comentarios

Publicar un comentario

Entradas populares de este blog

RESULTSET

Imagen
1. CONTENIDO 1.1. Definición Es la representación en memoria de las tablas de la base de datos en disco, se puede entender como una tabla virtual, recordar que generalmente todos los procesos que se realizen con la tabla (insertar registros, eliminar registros, etc) se realizaran realmente contra un resulset y no provocaran ningun cambio en la tabla fisica en disco, resulset tiene un conjunto de metodos muy utiles y muy usados para el proceso de los renglones de la tabla virtual. Puede utilizar un objeto ResultSet para ejecutar una consulta y examinar los resultados de la consulta. Cuando crea consultas por medio del objeto QueryDef, debe crear un objeto ResultSet correspondiente para ejecutar la consulta y obtener los resultados. Cada objeto ResultSet se personaliza para la consulta que se ejecuta. El objeto ResultSet contiene estructuras de datos que organizan los datos de la consulta en filas y columnas, donde cada fila representa un único registro de datos y cada columna r...
Leer más

CONTROL JTABLE CON BASE DE DATOS

Imagen
1. CONTENIDO 1.1. Definición Jtable es una clase que me permite organizar una determinada información en tabla, esta difiere de una base de datos normal porque al utilizar Jtable tu puedes visualizar esta tabla, brindándole a el usuario organización de información, oportunidades de editar y cambiar el tamaño de las columnas entre otras. Como programadores, sabemos muy bien que la presentación de datos tabulados es una de las tareas más comunes que se presentan al momento de crear interfaces gráficas; desde la simple tabla que permite únicamente mostrar el resultado de una consulta, hasta las que permiten editar directamente el contenido de cada celda, ordenar las columnas, personalizar su apariencia, etc. Todas las tareas antes descritas, y muchas otras, son posibles de realizar utilizando la clase JTable; por supuesto, mientras más complejo sea el requerimiento a cubrir, se requerirá en igual medida utilizar más métodos o recursos de la clase. Los modelos de tabla son objetos...
Leer más