018 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para transacción Venta.

Para los que son transacciones se requiere de un formulario que servirá como base para lanzar los reportes, estos reportes pueden ser generales, especificando rangos de fechas (inicio –fin); o específicos, esto es indicando en este caso las ventas de un funcionario en cierto rango de fecha o compras de un cliente también tomando en cuenta rangos de fechas. Para esto debemos de crear un formulario utilizando un “jDialog”.
En primer lugar vemos el diseño del formulario, este formulario lanza dos reportes diferente, una de tipo general y otra tomando como variable un funcionario y los rangos de fechas inicio y fin. En el diseño se especifican los nombres de variable para los campos y botones (están en letra roja como etiqueta), esto es importante ya que a través de estas se llaman los objetos desde los métodos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. Para la introducción de fechas utilizamos “JFormattedTextField” o “Cuadro formateado” si el IDE está en español, en esta entrada del blog se trata sobre la utilización de un cuadro formateado ((Fecha y Hora con objeto Calendar). La “Lista desplegable” o “jComboBox” va almacenar los nombres de funcionarios.
Cuando se habla de transacciones se suelen utilizar varias tablas para obtener datos de referencia y trabajar con ellas. En este caso “VentaCab”, “VentaDet”, “Funcionario”, “Cliente” y “Articulo” respectivamente, para confeccionar una lista única con los datos que necesitamos debemos de crear una clase que servirá como plantilla para nuestros reportes. El nombre de la clase será “VentaR”, y tendrá los siguientes elementos. Tomar en cuenta que esta clase debe ir almacenada dentro del paquete que corresponde a informes.
Código Java
/**
*
* @author Ariel
*/

public class VentaR {
private int id;
private String funcionario;
private String cliente;
private String fecha;
private String articulo;
private int cantidad;
private long importe;

public VentaR(int id, String funcionario, String cliente, String fecha, String articulo, int cantidad, long importe) {
this.id = id;
this.funcionario = funcionario;
this.cliente = cliente;
this.fecha = fecha;
this.articulo = articulo;
this.cantidad = cantidad;
this.importe = importe;
}

public String getArticulo() {
return articulo;
}

public void setArticulo(String articulo) {
this.articulo = articulo;
}

public int getCantidad() {
return cantidad;
}

public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}

public String getCliente() {
return cliente;
}

public void setCliente(String cliente) {
this.cliente = cliente;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fecha) {
this.fecha = fecha;
}

public String getFuncionario() {
return funcionario;
}

public void setFuncionario(String funcionario) {
this.funcionario = funcionario;
}

public int getId() {
return id;
}

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

public long getImporte() {
return importe;
}

public void setImporte(long importe) {
this.importe = importe;
}

}
Continuamos viendo el diseño del primer reporte que será de tipo general, el nombre del archivo será “ReportVenta”. Se puede consultar este enlace del blog si hay dudas sobre algunos elementos (iReport. Introducción para crear informes). La configuración de la hoja es el A4 tipo vertical.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás.
Elementos del diseño del reporte: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas. 4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. 5) Una “Variable” para indicar la suma total de ventas, en la imagen se especifica los parámetros necesarios para que funcione correctamente. Es importante respetar los nombres de los “Fields” ya que deben de coincidir con las que le pasaremos desde la lista más arriba creada.
Ahora vemos el segundo reporte que será de tipo específico, utilizando como tercera variable el nombre de un funcionario para ver las ventas que le corresponden. El nombre del archivo será “ReportVentaDos”. La configuración de la hoja es también A4 tipo vertical. Los elementos del diseño son iguales que la anterior, la diferencia se ve en que ubicamos el nombre del funcionario en “Column Header” ya que será única para el reporte.
Completado el diseño debemos de compilar cada uno de los reportes y obtener los archivos necesarios que tienen la extensión “*.jasper” y “*.jrxml” respectivamente. Estos archivos de reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
El siguiente paso es crear un método que lance cada uno de los reportes creados y también los métodos que harán funcionar nuestro formulario. Más abajo tenemos los métodos creados, el nombre de cada una específica su función. Los comentarios explican que función cumple cada línea de código. Cada método de informe se llama desde su respectivo botón utilizando el evento “ActionPerformed”. Botón “verG” le corresponde el método “informeGeneral()” y el botón “verF” le corresponde el método “informeFuncionario()”.
Código Java
private void hibernateSession(){
//Método para abri una sesión hibernate.
st = HibernateUtil.getSessionFactory().openSession();
}
private void arranque(){
//Metodo para configurar los elementos de arranque
Calendar cal = Calendar.getInstance();
String fecha = retornarString(cal);
inicioG.setText(fecha);
finG.setText(fecha);
inicioF.setText(fecha);
finF.setText(fecha);
//Creamos una lista de funcionarios para llenar nuestro lista desplegable o comboBox.
List<Funcionario> listF = (List<Funcionario>)st.createQuery("From Funcionario").list();
//Otra forma de navegar por una lista a diferencia de Iterator.
for (int i = 0; i < listF.size(); i++) {
Funcionario f = listF.get(i);
listaF.addItem(f.getNombres());
}
}
//Métodos para trabajar con objeto Calendar.
public String retornarString(Calendar fecha){
//Método que retorna un String de fecha pasándole como argumento un objeto Calendar.
String retorno=null;
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
if (fecha != null) {
retorno = sdf.format(fecha.getTime());
}
return retorno;
}
public Calendar retornarCalendar(String fecha){
//Método que retorna un objeto Calendar pasando un String de fecha preformateado.
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
Calendar cal = Calendar.getInstance();
try {
cal.setTime(sdf.parse(fecha));
} catch (ParseException ex) {
JOptionPane.showMessageDialog(null, "Error; compruebe formato de fecha: " + ex);
}
return cal;
}
public void informeGeneral(){
//Método para nuestro informe general
//try - para controlar las excepciones.
try {
//Iniciamos una transacción
st.beginTransaction();
//Utilizamos un Lista para almacenar los datos combinados.
//Inicializamos nuestra lista como ArrayList().
List ventaList = new ArrayList();
//Creamos una Query utilizando nuestra sesión y HQL (Hibernate Query Language)
//Las condiciones son - fecha de inicio y fin.
Query query = (Query) st.createQuery("From VentaCab v Where v. fecha>=? and v. fecha<=?");
//A diferencia de SQL, las condiciones se pasan como parámetros.
query.setParameter(0, retornarCalendar(inicioG.getText()));
query.setParameter(1, retornarCalendar(finG.getText()));
//Obtenemos la lista de "VentaCab"
List<VentaCab> lista = query.list();
int id=0;
//Navegamos la lista utilizando Iterator.
for (Iterator<VentaCab> it = lista.iterator(); it.hasNext();) {
VentaCab ventaCab = it.next();
String funcionario = ventaCab.getFuncionario().getNombres();
String cliente = ventaCab.getCliente().getDes();
String fecha = retornarString(ventaCab.getFecha());
List<VentaDet> ventaDets = ventaCab.getVentaDets();
//Navegamos por la lista de detalles utilizando también iterator.
for (Iterator<VentaDet> it1 = ventaDets.iterator(); it1.hasNext();) {
id++;
VentaDet ventaDet = it1.next();
//Llenamos nuestro lista creada más arriba con los elementos necesarios.
ventaList.add(new VentaR(id, funcionario, cliente, fecha, ventaDet.getArticulo().getDes(), ventaDet.getCant(), ventaDet.getImporte()));
}
}
//Utilizamos el método siguiente para cargar el reporte "*.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportVenta.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(ventaList));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Ventas Generales.");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte." + e);
}
}
public void informeFuncionario(){
//Este método es similar al de más arriba, por tanto se saltan algunos comentarios.
//try - para controlar las excepciones.
try {
//Iniciamos una transacción
st.beginTransaction();
//Utilizamos un Lista para almacenar los datos.
List ventaList = new ArrayList();
Query query = (Query) st.createQuery("From VentaCab v Where v. fecha>=? and v. fecha<=?");
query.setParameter(0, retornarCalendar(inicioF.getText()));
query.setParameter(1, retornarCalendar(finF.getText()));
List<VentaCab> lista = query.list();
int id=0;
for (Iterator<VentaCab> it = lista.iterator(); it.hasNext();) {
VentaCab ventaCab = it.next();
String funcionario = ventaCab.getFuncionario().getNombres();
String cliente = ventaCab.getCliente().getDes();
String fecha = retornarString(ventaCab.getFecha());
List<VentaDet> ventaDets = ventaCab.getVentaDets();
for (Iterator<VentaDet> it1 = ventaDets.iterator(); it1.hasNext();) {
id++;
VentaDet ventaDet = it1.next();
//Una condición para filtrar la lista, obteniendo solo la de un funcionario en específico.
if( funcionario.equals(listaF.getSelectedItem().toString())){
ventaList.add(new VentaR(id, funcionario, cliente, fecha, ventaDet.getArticulo().getDes(), ventaDet.getCant(), ventaDet.getImporte()));
}
}
}
//Utilizamos el método siguiente para cargar el reporte "*.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportVentaDos.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(ventaList));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Lista de Ventas por Funcionarios.");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte.");
}
}
Obs.: Se anexa una imagen con elementos a tomar en cuenta al crear el formulario al igual que los códigos que corresponden a los eventos para los botones.

Código Java
    private void verGActionPerformed(java.awt.event.ActionEvent evt) {                                     
//Condición agregada para ejecutar el informe.
if(!inicioG.getText().isEmpty() && !finG.getText().isEmpty()){
informeGeneral();
}
else{
JOptionPane.showMessageDialog(null, "Especifique una fecha correcta.");
}
}

private void verFActionPerformed(java.awt.event.ActionEvent evt) {
//Condición agregada para ejecutar el informe.
if(!inicioF.getText().isEmpty() && !finF.getText().isEmpty() && !listaF.getSelectedItem().toString().isEmpty()){
informeFuncionario();
}
else{
JOptionPane.showMessageDialog(null, "Especifique los datos necesarios. -Fecha- y -Funcionario-");
}
}
En caso de que el IDE indique error de sintaxis, verificar si tenemos todas las importaciones necesarias. A continuación la lista.
Código Java
import com.entidades.Funcionario;
import com.entidades.VentaCab;
import com.entidades.VentaDet;
import com.informes.VentaR;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;
import javax.swing.JOptionPane;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.hibernate.Query;
import org.hibernate.Session;
import util.HibernateUtil;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” indicando que sea “DOCUMENT_MODAL”.

Java + Swing 019. Modo diseño en NetBeans. Utilizando la clase Comparator con Collections.sort() para ordenar “List”.

Ejercicio: Realizar una pequeña aplicación que permita ordenar una lista de elementos utilizando la clase Comparator.
Diseñamos el formulario utilizando un JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el diseño y los nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable correspondiente para referenciar al objeto en específico. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. Para el “jComboBox” debemos de modificar la propiedad “model” agregando (Masculino, Femenino), que serán los datos desplegados.
Se puede descargar el formulario en el siguiente enlace:--> Archivos: *.FORM y *.JAVA
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. En este caso particular llamamos al método “arranque()” desde el constructor del jFrame, (comprobar imagen más abajo) es de vital importancia ya que configura los campos y especifica valores para cada una de las tablas. Las variables de clase se pueden llamar desde cualquier método, por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.

Lista de importaciones necesarias.
Código Java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
Antes de crear los métodos que utilizaremos, debemos de crear la clase “PersonaC”. Esta clase servirá para trabajar con “List” y poder realizar los procesos de ordenamiento. Si utilizamos paquetes, esta clase debe ir en la misma que nuestro jFrame. Esta quedará de la siguiente forma.
Código Java
/**
*
* @author Ariel
*/

public class PersonaC {
private int id;
private String nomApe;
private String ciudad;
private int edad;
private String sexo;

public PersonaC(int id, String nomApe, String ciudad, int edad, String sexo) {
this.id = id;
this.nomApe = nomApe;
this.ciudad = ciudad;
this.edad = edad;
this.sexo = sexo;
}

public String getCiudad() {
return ciudad;
}

public void setCiudad(String ciudad) {
this.ciudad = ciudad;
}

public int getEdad() {
return edad;
}

public void setEdad(int edad) {
this.edad = edad;
}

public int getId() {
return id;
}

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

public String getNomApe() {
return nomApe;
}

public void setNomApe(String nomApe) {
this.nomApe = nomApe;
}

public String getSexo() {
return sexo;
}

public void setSexo(String sexo) {
this.sexo = sexo;
}

}
Creamos los métodos siguientes en el apartado “Fuente”. Normalmente estos métodos los podemos agregar debajo del constructor del jFrame o al final de la declaración de variables. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se agregan comentarios para tratar de facilitar el entendimiento del funcionamiento de cada código.
Código Java
private void modelTable1(){
//Configuramos la primera tabla utilizando el DefaultTableModel,
//La tabla posee cinco columnas, el índice inicia de "0" cero.
jTableUno.getColumnModel().getColumn(0).setPreferredWidth(10);
jTableUno.getColumnModel().getColumn(1).setPreferredWidth(200);
jTableUno.getColumnModel().getColumn(2).setPreferredWidth(100);
jTableUno.getColumnModel().getColumn(3).setPreferredWidth(40);
jTableUno.getColumnModel().getColumn(4).setPreferredWidth(60);
//La variable "modelT1" es de tipo "DefaultTableModel", declarado más arriba
modelT1 = (DefaultTableModel)jTableUno.getModel();
//setNumRows(0) indica el número de filas que tendra la tabla de inicio.
modelT1.setNumRows(0);
}
private void modelTable2(){
//Configuramos la segunda tabla, el procedimiento es igual a la anterior.
jTableDos.getColumnModel().getColumn(0).setPreferredWidth(10);
jTableDos.getColumnModel().getColumn(1).setPreferredWidth(200);
jTableDos.getColumnModel().getColumn(2).setPreferredWidth(100);
jTableDos.getColumnModel().getColumn(3).setPreferredWidth(40);
jTableDos.getColumnModel().getColumn(4).setPreferredWidth(60);
//En este caso la variable es "modelT2"
modelT2 = (DefaultTableModel)jTableDos.getModel();
modelT2.setNumRows(0);
}
private void arranque(){
//Limpiamos campos y llamamos a los dos métodos creados más arriba para configurar las tablas.
modelTable1();
modelTable2();
nom.setText(null);
ciudad.setText(null);
edad.setText(null);
sexo.setSelectedIndex(-1);
}
private void limpiarCampos(){
//Utilizado para limpiar campos después de agregar datos a la tabla uno.
nom.setText(null);
ciudad.setText(null);
edad.setText(null);
sexo.setSelectedIndex(-1);
}
private void agregar(){
//Antes de agregar datos a la table comprobamos que los campos no esten vacios. Si almenos una de ellas esta vacia, dara una mensaje al usuario.
if(nom.getText().isEmpty() || ciudad.getText().isEmpty() || edad.getText().isEmpty() || sexo.getSelectedIndex() == -1){
JOptionPane.showMessageDialog(null, "Es necesario rellenar todos los campos.");
}
else{
//Si los campos estan correctos, se agrega el dato a la tabla uno utilizando la variable "modelT1".
int id = jTableUno.getRowCount() + 1;
modelT1.addRow(new Object[]{
id,nom.getText(),ciudad.getText(),edad.getText(),sexo.getSelectedItem().toString()
});
}
}
private void eliminar(){
//Método para eliminar datos de la tabla.
if(jTableUno.getRowCount() > 0){
try {
int sel = jTableUno.getSelectedRow();
modelT1.removeRow(sel);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Seleccione una fila.");
}
}

}
private void cargarLista(){
//Método para llenar la variable "lista" tipo List que creamos más arriba.
//La lista se llenará con los datos de la tabla uno utilizando la clase "PersonaC" que creamos.
if(jTableUno.getRowCount() > 0){
//Inicializamos la variable como ArrayList(), esto es esencial.
lista = new ArrayList();
//Utilizamos "try" para controlar la excepciones.
//La misma se puede dar si no se llena de forma correcta cada campo.
try {
//Recorremos cada fila de la tabla utilizando "for"
for (int i = 0; i < jTableUno.getRowCount(); i++) {
int d = Integer.parseInt(modelT1.getValueAt(i, 0).toString());
int ed = Integer.parseInt(modelT1.getValueAt(i, 3).toString());
//Utilizamos "add" y la clase "PersonaC" para llenar la lista.
lista.add(new PersonaC(d, modelT1.getValueAt(i, 1).toString(), modelT1.getValueAt(i, 2).toString(), ed, modelT1.getValueAt(i, 4).toString()));
}
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error llenando lista, verificar tipo de datos.");
}
}
}
private void ordenarNombre(){
//Método que nos permitirá llamar a nuestra lista y ordenarla según ciertos parámetros especificados.
//Utilizamos "Comparator" para ordenar la lista.
//Hay que castear como "PersonaC" para poder aplicarla a la lista que creamos más arriba.
Comparator<PersonaC> ordenarNombre = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
//Para dato String se utiliza "compareTo", compara el mismo campos de dos instancias de la misma clase.
return pc1.getNomApe().compareTo(pc2.getNomApe());
}
};
//Llenamos nuestra lista.
cargarLista();
//Solo ejecutamos el método Collections.sort si la lista no esta vacía.
if(!lista.isEmpty()){
//Los parámetros que le pasamos son la lista en si y la clase Comparator que creamos más arriba.
Collections.sort(lista, ordenarNombre);
modelT2.setNumRows(0);
//Utilizamos un "for" para recorrer la lista y llenar la segunda tabla con los datos ya ordenados.
//Para lista los mejor es utlizar Iterator.
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
private void ordenarCiudad(){
//El procedimiento para este método es igual a la anterior.
//La diferencia es que utilizamos el campo "ciudad" de la clase "PersonaC" para ordenar la lista.
Comparator<PersonaC> ordenar = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
return pc1.getCiudad().compareTo(pc2.getCiudad());
}
};
cargarLista();
if(!lista.isEmpty()){
Collections.sort(lista, ordenar);
modelT2.setNumRows(0);
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
private void ordenarEdad(){
//Este método se diferencia de las anteriores en que utilizamos un campos con dato "int" para ordenar los datos de la lista.
//Específicamente ordenará por edad.
Comparator<PersonaC> ordenar = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
//El procedimiento no utiliza el compareTo, solo el signo "-" menos.
return pc1.getEdad()- pc2.getEdad();
}
};
cargarLista();
if(!lista.isEmpty()){
Collections.sort(lista, ordenar);
modelT2.setNumRows(0);
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
private void ordenarSexo(){
//Este método también ordena la lista utilizando un campo "String".
Comparator<PersonaC> ordenar = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
return pc1.getSexo().compareTo(pc2.getSexo());
}
};
cargarLista();
if(!lista.isEmpty()){
Collections.sort(lista, ordenar);
modelT2.setNumRows(0);
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
Código Java
    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
agregar();
limpiarCampos();
}

private void eliminarActionPerformed(java.awt.event.ActionEvent evt) {
eliminar();
}

private void ordNombreActionPerformed(java.awt.event.ActionEvent evt) {
ordenarNombre();
}

private void ordCiudadActionPerformed(java.awt.event.ActionEvent evt) {
ordenarCiudad();
}

private void ordEdadActionPerformed(java.awt.event.ActionEvent evt) {
ordenarEdad();
}

private void ordSexoActionPerformed(java.awt.event.ActionEvent evt) {
ordenarSexo();
}

private void limpiarActionPerformed(java.awt.event.ActionEvent evt) {
arranque();
}
Por último tenemos el formulario en ejecución.

017 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para referencial Funcionario.

Como en todas las anteriores iniciamos la creación del reporte para “Funcionario” creando un nuevo archivo, el nombre del archivo será “FuncionarioReport”. Para entender más sobre el proceso de creación de informes se puede consultar iReport. Introducción para crear informes. La configuración de la hoja normal es el A4.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás.
Elementos del diseño del reporte: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas. 4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En ”iReport. Introducción para crear informes” vimos cómo trabajar con cada elemento. Un detalle importante a tener en cuenta es el nombre para cada “Field” ya que serán iguales a las que le pasaremos desde Java con nuestra lista creada. Estos campos son "id", "nombres" "apellidos", "dir" y "cargo".
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “FuncionarioReport.jasper” y “FuncionarioReport.jrxml” respectivamente. Estos archivos de reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
El siguiente paso es crear un método para ejecutar el reporte. Abajo el método “informe()” para ejecutar el reporte. Los comentarios explican que función cumple cada línea de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “FuncionarioApp” utilizando el evento “ActionPerformed”.
Código Java
public void informe(){
//try - para controlar las excepciones.
try {
//Iniciamos una transacción
st.beginTransaction();
//Obtenemos una lista de funcionario
List<Funcionario> lista = (List<Funcionario>)st.createQuery("From Funcionario").list();
//Utilizamos el método siguiente para cargar el reporte "FuncionarioReport.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/FuncionarioReport.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
//La lista posee los siguiente campos: "id" "nombres" "apellidos" "dir" "cargo" en coincidencia con los de nuestro archivo de reporte.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(lista));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Lista de Funcionarios");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte.");
}
}
En caso de que el IDE indique error de sintaxis, verificar si tenemos todas las importaciones necesarias. A continuación la lista.
Código Java
import com.entidades.Funcionario;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.hibernate.Session;
import util.HibernateUtil;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” indicando que sea “DOCUMENT_MODAL”.

016 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para referencial Cliente.

Iniciamos la creación del reporte para “Cliente” creando un nuevo archivo, el nombre del archivo será “ClienteReport”. Para entender más sobre el proceso de creación de informes se puede consultar iReport. Introducción para crear informes. La configuración de la hoja normal es el A4.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás.
Elementos del diseño del reporte: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas. 4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En ”iReport. Introducción para crear informes” vimos cómo trabajar con cada elemento. Un detalle importante a tener en cuenta es el nombre para cada “Field” ya que serán iguales a las que le pasaremos desde Java con nuestra lista creada. Estos campos son "id", "des" "dir", "tel" y "ruc".
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “ClienteReport.jasper” y “ClienteReport.jrxml” respectivamente. Estos archivos de reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
El siguiente paso es crear un método para ejecutar el reporte. Abajo el método “informe()” para ejecutar el reporte. Los comentarios explican que función cumple cada línea de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “ClienteApp” utilizando el evento “ActionPerformed”.
Código Java
public void informe(){
//try - para controlar las excepciones.
try {
//Creamos una lista de los datos de la tabla "Cliente" utilizando "List".
st.beginTransaction();
List<Cliente> lista = (List<Cliente>)st.createQuery("From Cliente").list();
//Utilizamos el método siguiente para cargar el reporte "ClienteReport.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ClienteReport.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
//La lista posee dos campos por registro: "id", "des" "dir", "tel" y "ruc", los nombres se corresponden con las agregadas en el reporte diseñado.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(lista));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Lista de Clientes.");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte.");
}
}
En caso de que el IDE indique error de sintaxis, verificar si tenemos todas las importaciones necesarias. A continuación la lista.
Código Java
import com.entidades.Cliente;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.hibernate.Session;
import util.HibernateUtil;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” indicando que sea “DOCUMENT_MODAL”.

015 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para referencial Artículo.

Iniciamos la creación del reporte para “Articulo” creando un nuevo archivo, el nombre del archivo será “ArticuloReport”. Para entender más sobre el proceso de creación de informes se puede consultar iReport. Introducción para crear informes. La configuración de la hoja normal es el A4.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás.
El reporte en si contiene estos elementos: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas. 4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En ”iReport. Introducción para crear informes” vimos cómo trabajar con cada elemento. Un detalle importante a tener en cuenta es el nombre para cada “Field” ya que serán iguales a las que le pasaremos desde Java con nuestra lista creada. Estos campos son "id", "des" "tipo", "pve" y "can".
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “ArticuloReport.jasper” y “ArticuloReport.jrxml” respectivamente. Estos archivos de reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
En algunos casos se da que debemos obtener datos de dos o más tablas, como por ejemplo “Articulo” y “Tipo”, pues debemos de obtener la lista de artículos al igual que el tipo correspondiente. Esto lo podemos hacer utilizando una clase de soporte que nos permitirá combinar ambas tabla en una sola lista. El nombre de la clase para este informe es “ArticuloR” y la tendremos que guardar en la carpeta de “informes” al igual que los dos archivos de obtenidos del iReport. A continuación la clase “ArticuloR”.
Código Java
package com.informes;

/**
*
* @author Ariel
*/

public class ArticuloR {
private int id;
private String des;
private String tipo;
private int pve;
private int can;

public ArticuloR(int id, String des, String tipo, int pve, int can) {
this.id = id;
this.des = des;
this.tipo = tipo;
this.pve = pve;
this.can = can;
}

public int getCan() {
return can;
}

public void setCan(int can) {
this.can = can;
}

public String getDes() {
return des;
}

public void setDes(String des) {
this.des = des;
}

public int getId() {
return id;
}

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

public int getPve() {
return pve;
}

public void setPve(int pve) {
this.pve = pve;
}

public String getTipo() {
return tipo;
}

public void setTipo(String tipo) {
this.tipo = tipo;
}

}
El siguiente paso es crear un método para ejecutar el reporte. Abajo el método “informe()” para ejecutar el reporte. Los comentarios explican que función cumple cada línea de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “ArticuloApp” utilizando el evento “ActionPerformed”.
Código Java
public void informe(){
//try - para controlar las excepciones.
try {
//Iniciamos una transacción
st.beginTransaction();
//Utilizamos un Lista para almacenar los datos combinados de Articulo y Tipo.
List articuloList = new ArrayList();
//Obtenemos una lista de artículos
List<Articulo> lista = (List<Articulo>)st.createQuery("From Articulo").list();
//utilizamos Iterator para acceder a los datos
for (Iterator<Articulo> it = lista.iterator(); it.hasNext();) {
Articulo articulo = it.next();
//Llenamos nuestro "articuloList", la diferencia con la lista original es que obtenemos las descripción del tipo con "articulo.getTipo().getDes()"
//de otra forma no traería un objeto "Tipo" no un String con el nombre específico que necesitamos.
articuloList.add( new ArticuloR(articulo.getId(), articulo.getDes(), articulo.getTipo().getDes(), articulo.getPve(), articulo.getCan()));
}
//Utilizamos el método siguiente para cargar el reporte "ArticuloReport.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ArticuloReport.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
//La lista posee los siguiente campos: "id" "des" "tipo" "pve" "can" en coincidencia con los de nuestro archivo de reporte.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(articuloList));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Lista de Artículos.");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte.");
}
}
En caso de que el IDE indique error de sintaxis, verificar si tenemos todas las importaciones necesarias. A continuación la lista.
Código Java
import com.entidades.Articulo;
import com.entidades.Tipo;
import com.informes.ArticuloR;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.hibernate.Query;
import org.hibernate.Session;
import util.HibernateUtil;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” indicando que sea “DOCUMENT_MODAL”.