noviembre 24, 2017

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
https://jossjack.wordpress.com/2014/06/15/
jasperreport-ireport-en-netbeans/
https://es.scribd.com/document/205441147/
Fechas-y-campos-calculados-iReport-pdf
http://www.javerosanonimos.com/2011/08/
campos-variables-y-parametros.html
http://www.javatutoriales.com/2009/03/creacion-de-reportes-con-
jasperrepots-y_30.html
http://chuwiki.chuidiang.org/index.php?title=Ejemplo_b
%C3%A1sico_con_Jasper_Report
http://fernando-bustos.blogspot.pe/2013/05/jasperviewer-sobre-
jdialog.html
https://www.programcreek.com/java-api-examples/index.php?
api=net.sf.jasperreports.view.JasperViewer
http://jasperreports.sourceforge.net/api/net/sf/jasperreports/view/
JasperViewer.html
https://www.lawebdelprogramador.com/foros/Java/479892-
JasperViewer.html
http://luigytelu.blogspot.pe/2013/03/ireport-jasperviewer.html
https://www.ecured.cu/IReport
https://www.codejobs.biz/es/blog/2014/01/13/que-es-jasperreports