006 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario referencial TipoApp.

Para crea un formulario que no sea principal recurriremos al “JDialog”, que es un tipo de formulario dependiente a diferencia del “JFrame”. Para ello hacemos clic derecho sobre el paquete en donde almacenaremos los formularios, en este caso “com.app”, clic en “Otros” y rellenamos los datos y selección como se indica en la imagen (JDialog 1). En la siguiente pantalla, le damos un nombre en este caso “TipoApp” para diferenciar de la clase persistente “Tipo”. Clic en “Terminar” y empezamos a diseñar.

(JDialog 1) Seguimos viendo el diseño del formulario y los componentes que incluyen.(img. 1)
(Img. 1) Componentes.

(1) JLabel que utilizamos para indicar con letras grandes y junto con un icono (se puede incluir iconos junto con el texto) una descripción del formulario.

(2) JPanel para agrupar los JLabels y JTextFields importantes para el usuario.

(3) JTextField para mostrar el id de la Clase Persistente “Tipo”, que ya se ha creado anteriormente. El usuario no requiere indicar un “id” ya que esta al crear la Clase “Tipo” le indicamos al Hibernate que es auto-numérico.

(4) JTextField para que el usuario indique una descripción para el tipo de articulo nuevo de desea crear. También según el caso el usuario podrá editar los datos de registros ya almacenados.

(5) JTable que nos permitirá visualizar los datos ya almacenados indicando por columnas “Código” y “Descripción”. “Código” corresponde al “Id” que en esencia son lo mismo. También la tabla permite seleccionar registros específicos para poder editarlos como veremos.

(6) JButtons que serían los botones de comando, las cuales como se ve en la imagen cumplen; cada una, un rol específico. Estos botones están dentro de un JPanel, ya que esta permite manejarlas como un grupo.

(7) “Fuente” y “Diseño”, las dos pestañas que nos permiten alternar entre “Vista de Diseño” y “Vista de Fuente”. En “Vista de Fuente” iremos agregando los métodos y funciones que utilizaremos.

Lo siguiente es ver la distribución y nombre de cada uno de los componentes dentro del diseño. (img. 2)

(Img. 2) Componentes.

(1) JDialog que sería como el objeto padre que almacena todas las demás y sobre la que diseñamos.

(2) JPanel la cual incluye todos los paneles y componentes que se agregan al formulario. Esto permite mover o copiar grupo de objetos de forma fácil.

(3) JPanel que agrupa los JLabels y JTextFields.

(4) jScrollPane para utilizar Scroll en la tabla, es automática. Al agregar la tabla se suele agregar también.

(5) JPanel que nos permite agrupar los botones de comando del formulario.

(6) JButtons dentro del JPanel.

Cambiar nombre de variables y textos visibles de objetos. (img. 3)

(Img. 3)

El menú se despliega haciendo clic derecho sobre el objeto específico.

(1) Editar Texto esto nos permite cambiar el texto visible, como se ve en la imagen el nombre para cada JButton.

(2) Cambiar nombre de variable… esta opción nos permite cambiar el nombre de variable de un objeto, la cual es la que utilizamos para llamarla desde cualquier método o función que creemos. Por tanto es importante elegir un nombre de variable que sea definitorio de la función del objeto. (img. 4)
(Img. 4)

Como se ve en la imagen, se indican los nombres de variable que utilizaremos para los objetos con las que estaremos trabajando desde los métodos que crearemos. Esto es importante para hacer los códigos más legibles.

Llamar métodos desde objetos específicos.

Para ello hacemos clic derecho sobre el objeto específico (JButton, JTextFields, etc), seleccionamos “Eventos”, y del menú desplegado la que estemos necesitando. Cada evento funciona de una manera específica. Solo explicaremos las que vayamos utilizando dentro del proyecto. (img. 5)

(Img. 5)

Al seleccionar un “Evento”, NetBeans nos crea un método relacionado al objeto y evento específico; dentro de la cual agregaremos nuestro código o llamaremos métodos para que se ejecuten. (img. 6)

(Img. 6)

También podremos ver los “Eventos” relacionado a un objeto específico, haciendo clic derecho sobre el objeto y en “Propiedades” y pestaña “Eventos”. Desde este lugar podremos eliminar también los eventos que hayamos creado, seleccionado y “Suprimir”. Desde “Vista de Fuentes” no se pueden eliminar “Eventos”. (img. 7)

(Img. 7)

Importaciones necesarias.

La lista.

---

import com.entidades.Tipo;
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.Session;
import util.HibernateUtil;

---

Esquema del código fuente a tomar en cuenta. (img. 8).

(Img. 8)

Los método que se muestran, las iremos creando, esto es para ver su desde que lugar de Código Fuente tendremos que llamarlos.

(1) Lista de importaciones necesaria, se ubican en la zona de forma automática. Normalmente debe ir debajo del package.

(2) (sessionHibernate();) Un método que llamamos dentro del “Método Constructor” del JDialog para que se ejecute al crearse el objeto “JDialog”. Este método no permite crear lo que llamamos el “SessionFactory()” del Hibernate.

(3) (arranque();) Al igual que la anterior se ejecuta al crease el objeto. Ya explicaremos su función.

(4) (setLocationRelativeTo(null);) Método llamado también en el “Constructor”. Es un método que permite ubicar el JDialog en la pantalla, al pasarle “null”, la deja centrado.

(5) (private Session st;) Creamos una variable de clase tipo “Session” que nos permitirá guardar nuestra sesión del Hibernate y utilizarla en cualquiera de los métodos que creemos.

(6) (private DefaultTableModel model;) Variable de clase tipo “DefaultTableModel”, que ya explicaremos su función.

(7) Zona en la que se ubican todos los “Eventos” que vayamos implementando.

(8) (nuevo();) Ejemplo de cómo llamamos un “Método” desde un “Evento”.

La consideración importante es que cualquier método que queramos que se ejecute al crearse el formulario debemos de llamarlos desde el “Método Constructor”. Pero siempre después del método “initComponents();” por regla.

Otras zonas de la “Vista de fuentes” importantes de mencionar. (img. 9)

(Img. 9)

(1) Zona donde se declaran las variables de los objetos que creemos en el formulario. No se pueden modificar desde “Vista de Fuentes” solo desde “Vista de Diseño”.

(2) Zona en la que de preferencia personal suelo ubicar los métodos que creo. Según tengo entendido con que sea fuera del “Método Constructor” se considera método de clase. En un formulario nuevo, debemos desplazar la llave “}“ de cierre y empezar a escribir nuestro método que podremos utilizar en cualquier parte del código. Creando Método y utilizando Eventos.

Método “sessionHibernate()”. (Recuerden que el nombre del método es relativo, con que sea un nombre definitorio, para diferenciar de otras.)

---

public void sessionHibernate(){
    st = HibernateUtil.getSessionFactory().openSession();
}

---

Este método asigna a la variable “st” una “SessionFactory”, la cual utilizaremos para guardar, actualizar, recuperar y eliminar registros. Este método debemos llamar desde el “Método Constructor” del JDialog.

Método “arranque()”.

---

public void arranque(){
    this.id.setEnabled(false);
    this.id.setText(null);
    this.des.setEnabled(false);
    this.des.setText(null);
    this.guardar.setEnabled(false);
    this.editar.setEnabled(false);
    this.eliminar.setEnabled(false);
    this.informe.setEnabled(true);
    this.nuevo.setEnabled(true);
    this.guardar.setText("Guardar");
    this.jTable1.setEnabled(true);
    defaultTableModel();
    cargarTabla();
}

---

Este método nos permite establecer que objeto del “Formulario” estarán habilitadas para su uso y que valores tendrán por defecto. Este método se llama desde el “Método Constructor” y desde el “Botón Cancelar” utilizando el “Evento” “ActionPerformed” (img. 10). Un punto importante es que para los objetos JButton normalmente se utilizar el “Evento” “ActionPerformed”. Para nuestro proyecto se sigue este esquema para todos los “JButton”. Más arriba explicamos como llamar métodos desde objetos específicos. Este método también incluye los métodos “defaultTableModel()” y “cargarTabla()” que ya crearemos y explicaremos su función.

(Img. 10)
Método “defaultTableModel()”

---

public void defaultTableModel(){
    this.jTable1.getColumnModel().getColumn(0).setPreferredWidth(20);
    this.jTable1.getColumnModel().getColumn(1).setPreferredWidth(350);
    model = (DefaultTableModel) this.jTable1.getModel();
    model.setNumRows(0);    
}

---

Este método nos permite configurar el “DefaultTableModel”, la cual nos da la posibilidad de introducir y recuperar datos de la tabla. Se llama desde el método “arranque()”.

Método “nuevo()”.

---

public void nuevo(){
    this.nuevo.setEnabled(false);
    this.guardar.setEnabled(true);
    this.des.setEnabled(true);
    this.id.setText("Auto");
}

---

Es un método que llamamos desde el botón “Nuevo”, la cual nos habilita los campos necesarios para cargar datos. Recuerden que para botones siempre utilizamos el “Evento” “ActionPerformed”.

Método cargarTabla();

---

public void cargarTabla(){
    st.beginTransaction();
    List<Tipo> lista = (List<Tipo>)st.createQuery("From Tipo").list();
    for (Iterator<Tipo> it = lista.iterator(); it.hasNext();) {
        Tipo tipo = it.next();
        model.addRow(new Object[]{
            tipo.getId(),tipo.getDes()
        });
        
    }

---

En este método utilizamos el “st.beginTransaction()”, la cual nos posibilita iniciar una transacción para almacenar o recuperar datos del MySQL. En la siguiente línea vemos el procedimiento que se utiliza normalmente para recuperar datos de una tabla, utilizando “List”. Con un “for” accedemos a esos datos y con la variable “model” del “DefaultTableModel” utilizando el método “addRow” agregamos registros en la tabla. Se llama desde el método “arranque()”.

Método “guardar()”.

---

public void guardar(){
    if(this.des.getText().isEmpty()){
        JOptionPane.showMessageDialog(null, "Imposible guardar campo vacio.");
    }
    else{
        if(this.guardar.getText().equals("Guardar")){
            st.beginTransaction();
            Tipo t = new Tipo();
            t.setDes(this.des.getText());
            st.save(t);
            st.getTransaction().commit();
            JOptionPane.showMessageDialog(null, "Registro guardado.");
            arranque();
        }
        else{
            st.beginTransaction();
            int selectedRow = this.jTable1.getSelectedRow();
            Object valueAt = model.getValueAt(selectedRow, 0);
            int idTipo = Integer.parseInt(valueAt.toString());
            Tipo t = (Tipo) st.load(Tipo.class, idTipo);
            t.setDes(this.des.getText());
            st.update(t);
            st.getTransaction().commit();
            JOptionPane.showMessageDialog(null, "Registro actualizado.");
            arranque();
        }
    }
}

---

Hacemos una captura para poder explicar a mayor detalle, ya que este método es la que nos permitirá almacenar y actualizar datos dentro del MySQL. (img. 11)

(Img. 11)

(1) Comprobamos que el “JTextFields” cuyo nombre de variable es “des”, no este vacía.

(2) Comprobamos que el “caption” del botón guardar sea “Guardar”, pues esta puede tomar dos valores, “Actualizar” y “Guardar” según el caso.

(3) Iniciamos una transacción.

(4) Creamos un objeto de la clase Tipo. “Tipo” es un clase persistente, al crear una instancia y asignarle valor a sus variables estamos creando un registro en MySQL.

(5) Asignamos valor a la variable “des” de la clase persistente “Tipo” con el “método setter” de la misma.

(6) Usamos el método “save()” de la Sesión pasando como argumento la clase Tipo que instanciamos.

(7) Hacemos un “st.getTransaction().commit();” para confirmar la transacción. Como vieron el procedimiento es totalmente orientado a objetos. No recurrimos al SQL, pues el Hibernate se encarga de negociar con la Base de Datos.

(8) Le decimos al usuario que los datos fueron guardados.

(9) Llamamos al “método arranque()” para restablecer el formulario y poder iniciar el proceso nuevamente.

(10) Utilizamos el “else” en caso que no se den las condiciones del “if”.

(11) Las siguientes líneas nos permiten recuperar el “id”, pues como indicamos arriba, en caso que de que el “caption” del botón guardar no sea “Guardar” querrá decir que es “Actualizar”. Como sabemos solamente los registros que ya estén guardados se pueden actualizar.

(12) Para recuperar un registro normalmente utilizamos el método “load”, pasándole como argumente la clase y el “id” de la misma, que recuperamos más arriba.

(13) Asignamos valor nuevo a la variable “des” de la clase persistente “Tipo” con el “método setter” de la misma.

(14) Utilizamos un “update” a diferencia de la anterior.

(15) Confirmamos la transacción.

(16) Indicamos al usuario que el proceso fue exitoso.

El método “guardar” se llama desde el botón “Guardar” con el “Evento” “ActionPerformed”.

Método “obtenerTabla()”.

---

public void obtenerTabla(){
   int selectedRow = this.jTable1.getSelectedRow();//Obtenemos la fila seleccionada...
   Object valueAt = model.getValueAt(selectedRow, 0);//Obtenemos el valor de esa fila...
   int idTipo = Integer.parseInt(valueAt.toString());//Convertimos el valor en entero...
   Tipo t = (Tipo) st.load(Tipo.class, idTipo);//Hacemos un load pasando como argumento la clase Tipo y  el Id del mismo...
   this.id.setText(String.valueOf(t.getId()));//Asignamos valor al JTextField id. 
   this.des.setText(t.getDes());//Asignamos valor al JTextField des.
   this.editar.setEnabled(true);//Activamos el botón editar...
   this.eliminar.setEnabled(true);//Activamos el botón eliminar...
   this.nuevo.setEnabled(false);//Desactivamos el botón nuevo...
   this.guardar.setText("Actualizar");//Cambiamos el de guardar...
}

---

Este método la llamamos desde el “Evento Mouse” – “MouseClicked” del JTable1. Con esto cada vez que el usuario haga clic sobre una de las fila de la tabla se pueda recuperar el valor y pasarlos a los “JTextFields” correspondientes. Las explicaciones desde ahora, dentro de código fuente de forma comentada.

Método “editar()”.

---

public void editar(){
    this.guardar.setEnabled(true);//Activamos botón gurdar...
    this.des.setEnabled(true);//Activamos JTextField des...
    this.eliminar.setEnabled(false);//Desactivamos botón eliminar
    this.jTable1.setEnabled(false);//Desactivamos el JTable
}

---

El método “guardar” se llama desde el botón “Editar” con el “Evento” “ActionPerformed”.

Método “eliminar()”.

---

public void eliminar(){
    int seleccion = JOptionPane.showConfirmDialog(null,"Desea eliminar el Registro.", "Eliminación de Registro.", JOptionPane.YES_NO_OPTION);//Obtnemos la selección del usuario
    if(seleccion == 1){//Comparamos la selección del usuario igual a 1 no eliminamos, si es diferente se elimina.
        JOptionPane.showMessageDialog(null, "Registro no Eliminado...");
        arranque();//Si no se elimina se llama al metodo arranque() para limpiar campos
    }
    else{//Opción eliminar seleccionada
        st.beginTransaction();//Iniciamos transacción
        int selectedRow = this.jTable1.getSelectedRow();//Obtenemos selección
        Object valueAt = model.getValueAt(selectedRow, 0);//Recuperamos valor
        int idTipo = Integer.parseInt(valueAt.toString());//Convertimos valor en entero
        Tipo t = (Tipo) st.load(Tipo.class, idTipo);//Hacemos un load pasando como argumento la clase Tipo y  el Id del mismo...
        st.delete(t);//Utilizamos delete pasando como argumento el objeto Tipo que cargamos con load...
        st.getTransaction().commit();//Confirmamos la transacción...
        JOptionPane.showMessageDialog(null, "Registro Eliminado...");//Indicamos al usuario que el proceso fue exitoso...
        arranque();//Limpiamos campos con el metodo arranque()...
    }
}

---

El método “eliminar” se llama desde el botón “Eliminar” con el “Evento” “ActionPerformed”.

Observación: El método para informe, lo dejamos para lo último del proyecto, ya que requiere utilizar el iReport.

En esta última imagen vemos el formulario en ejecución y funcionando. (Img. 12)

(Img. 12)

Obs.: Resulta difícil explicar todo el proceso y función de cada línea de código por tanto pueden realizar un comentario con sus dudas.