CRUD de una Tabla en MariaDB con Java

Un CRUD (Create, Read, Update, Delete) es el acrónimo en inglés que hace referencia a las cuatro funciones de la persistencia de datos las cuales son: Crear, leer, actualizar, eliminar. Conocido tambiém como mantenedor.

Utilizando la interfaz gráfica de usuario (asistente de diseño) para el desarrollo del formulario con la librería SWING en NetBeans. También he utilizado un nuevo componente adicional conocido como JDateChooser agregado dentro de la paleta de diseño.

A continuación una imagen del cómo quedó en JFrame: 

Anteriormente se realizó un artículo de conexión a MariaDB con Java, aquí te dejo el link clic aquí.

Como toda aplicación con conexión a base de datos lo primero que se debe hacer es crear la base de datos que se va utilizar, el nombre de la base de datos será tucafejava.

   -- El nombre de la base de datos será 'tucafejava'   
   CREATE DATABASE tucafejava;

Para poder guardar los datos se requiere contar con una tabla, por ello ahora se debe crear la estructura de la tabla la cual nombraremos persona y tendrá 6 campos.

   -- El nombre de la tabla será 'persona' que contendrá 6 campos.
   CREATE TABLE `persona` (
      `codigo` varchar(8) NOT NULL,
      `nombre` varchar(50) DEFAULT NULL,
      `apellido` varchar(80) DEFAULT NULL,
      `direccion` varchar(100) DEFAULT NULL,
      `telefono` varchar(10) DEFAULT NULL,
      `nacimiento` date NOT NULL,
      PRIMARY KEY (`codigo`)
   );

En el proyecto he creado tres paquetes para tener un poco de orden y gestionar mejor mis archivos. (cls, img, vs). Para el paquete "cls", agregaré la clase conexión y persona (como modelo de nuestro manejo de datos).

Clase Conexion.java

   package cls;
   import java.sql.*; //Librería SQL para el control de un gestor de base de datos
   public class Conexion {
      /** Atributos **/
      private Connection conexion; //Variable de conexión
      static String bd = "tucafejava"; //Nombre de la Base de Datos
      static String user = "root"; //Usuario del Gestor será root si no lo cambiaron
      static String password = ""; //Contraseña del Gestor si tiene
      static String server = "jdbc:mysql://localhost/" + bd; //Sentencia de Conexión
 
      /** Construtor(es) **/
      public Conexion() { }
    
      /** Métodos **/
      public void establecerConexion() {
         try{
            Class.forName("com.mysql.jdbc.Driver");
            conexion = DriverManager.getConnection(server, user, password);
         } catch(Exception e) {
            System.out.println(" Imposible realizar conexion con la Base de Datos ");
            conexion = null;
         }
      }
 
      public Connection getConexion() {
         return conexion;
      }
 
      public void cerrar(ResultSet rs) {
         if(rs != null) {
            try {
               rs.close();
            } catch(Exception e) {
               System.out.print(" No es posible cerrar la conexión ");
            }
         }
      }
 
      public void cerrar(java.sql.Statement stmt) {
         if(stmt != null) {
            try {
               stmt.close();
            } catch(Exception e) { }
         }
      }
 
      public void destruir() {
         if(conexion != null) {
            try{
               conexion.close();
            } catch(Exception e){ }
         }  
      }
   } 

Una vez comprobada si nuestra aplicación realiza la conexión correctamente agregamos un nuevo archivo java llamado Persona.java:

   
package cls;
   // PAQUETES
   import java.sql.Types;
   import java.sql.*;
   public class Persona {
      // ATRIBUTOS
      // Objeto de la clase conexión
      private Conexion objConexion = new Conexion();
      // campo codPersona
      private String codPersona = null;
      // campo nombrePersona
      private String nombrePersona = null;
      // campo apellidoPersona
      private String apellidoPersona = null;
      // campo direcciónPersona
      private String direccionPersona = null;
      // campo telefonoPersona
      private String telefonoPersona = null; 
      // campo nacimientoPersona   
      private String nacimientoPersona = null;
      // atributos para la conexión
      private Statement stmt = null;
      private PreparedStatement pstmt = null;
      private CallableStatement cstmt = null;
      private ResultSet rs = null;
    
      // CONSTRUCTORES
      public Persona() {} //Constructor sin argumentos

      public Persona(String codPersona, String nombrePersona, String apellidoPersona, String direccionPersona, String telefonoPersona, String nacimientoPersona) { //Constructor con argumentos
         this.codPersona = codPersona;
         this.nombrePersona = nombrePersona;
         this.apellidoPersona = apellidoPersona;
         this.direccionPersona = direccionPersona;
         this.telefonoPersona = telefonoPersona;
         this.nacimientoPersona = nacimientoPersona;
      }
    
      // MÉTODOS GETTER Y SETTER
      public String getCodigo() { return codPersona; }
      public String getNombre() { return nombrePersona; }
      public String getApellido() { return apellidoPersona; }
      public String getDireccion() { return direccionPersona; }
      public String getTelefono() { return telefonoPersona; }
      public String getNacimiento() { return nacimientoPersona; }
      public void setCodigo(String codPersona) { this.codPersona = codPersona; }
      public void setNombre(String nombrePersona) { this.nombrePersona = nombrePersona; }
      public void setApellido(String apellidoPersona) { this.apellidoPersona = apellidoPersona; }
      public void setDireccion(String direccionPersona) { this.direccionPersona = direccionPersona; }
      public void setTelefono(String telefonoPersona) { this.telefonoPersona = telefonoPersona; }
      public void setNacimiento(String nacimientoPersona) { this.nacimientoPersona = nacimientoPersona; }
    
      // MÉTODOS DEFINIDOS POR EL USUARIO
      public String crearPersona() {
         String mensaje = "";
         try {
            //Se carga el driver de conexión
            objConexion.establecerConexion();
            cstmt = objConexion.getConexion().prepareCall("{call crearPersona(?,?,?,?,?,?)}");
            cstmt.setString(1, codPersona); // campo codPersona
            cstmt.setString(2, nombrePersona); // campo nombrePersona
            cstmt.setString(3, apellidoPersona); // campo apellidoPersona
            cstmt.setString(4, direccionPersona); // campo direccionPersona
            cstmt.setString(5, telefonoPersona); // campo telefonoPersona
            cstmt.setString(6, nacimientoPersona); // campo nacimientoPersona
            // Ejecutamos el procedimiento almacenado
            if(cstmt.executeUpdate() == 1) {
               mensaje = "La persona se creó con éxito.";
            } else {
               mensaje = "Error al crear la persona.";
            }
            objConexion.destruir();
         } catch (Exception error) {
            error.printStackTrace();
         }
         return mensaje;
      }

      public String editarPersona() {
         String mensaje = "";
         try {
            //Se carga el driver de conexión
            objConexion.establecerConexion();
            cstmt = objConexion.getConexion().prepareCall("{call editarPersona(?,?,?,?,?,?)}");
            cstmt.setString(1, codPersona); // campo codPersona
            cstmt.setString(2, nombrePersona); // campo nombrePersona
            cstmt.setString(3, apellidoPersona); // campo apellidoPersona
            cstmt.setString(4, direccionPersona); // campo direccionPersona
            cstmt.setString(5, telefonoPersona); // campo telefonoPersona
            cstmt.setString(6, nacimientoPersona); // campo nacimientoPersona
            // Ejecutamos el procedimiento almacenado
            if(cstmt.executeUpdate() == 1) {
               mensaje = "La persona se editó con éxito.";
            } else {
               mensaje = "Error al editar la persona.";
            }
            objConexion.destruir();
         } catch (Exception error) {
            error.printStackTrace();
         }
         return mensaje;
      }
    
      public String borrarPersona() {
         String mensaje = "";
         try {
            //Se carga el driver de conexión
            objConexion.establecerConexion();
            cstmt = objConexion.getConexion().prepareCall("{call borrarPersona(?)}");
            cstmt.setString(1, codPersona); // campo codPersona
            // Ejecutamos el procedimiento almacenado
            if(cstmt.executeUpdate() == 1) {
               mensaje = "La persona se borró con éxito.";
            } else {
               mensaje = "Error al borrar la persona.";
            }
            objConexion.destruir();
         } catch (Exception error) {
            error.printStackTrace();
         }
         return mensaje;
      }
    
      public ResultSet leerPersona(String texto) {
         try {
            //Se carga el driver de conexión
            objConexion.establecerConexion();
            cstmt = objConexion.getConexion().prepareCall("{call buscarPersona(?)}");
            cstmt.setString(1, texto); // campo codPersona
            // Ejecutamos el procedimiento almacenado
            return cstmt.executeQuery();
         } catch (Exception error) {
            error.printStackTrace();
         }
         return null;
      }

   }

Podrás darte cuenta que dentro de cada uno de los botones que llaman a los métodos de la clase Persona.java tienen un procedimiento almacenado enlazado para realizar los procesos CRUD, a continuación te proporciono el código de estos procedimientos almacenados:

   
   -- PARA CREAR LA PERSONA
   DELIMITER $$
   DROP PROCEDURE IF EXISTS `crearPersona` $$
   CREATE PROCEDURE `crearPersona`(IN xcodigo VARCHAR(8), IN xnombre VARCHAR(50), IN xapellido VARCHAR(80), IN xdireccion VARCHAR(100), IN xtelefono VARCHAR(10), IN xnacimiento DATE)
   BEGIN
      INSERT INTO persona(codigo, nombre, apellido, direccion, telefono, nacimiento) VALUES(xcodigo, xnombre, xapellido, xdireccion, xtelefono, xnacimiento);
   END $$ 
   DELIMITER ;

   -- PARA EDITAR LA PERSONA
   DELIMITER $$
   DROP PROCEDURE IF EXISTS `editarPersona` $$
   CREATE PROCEDURE `editarPersona`(IN xcodigo VARCHAR(8), IN xnombre VARCHAR(50), IN xapellido VARCHAR(80), IN xdireccion VARCHAR(100), IN xtelefono VARCHAR(10), IN xnacimiento DATE)
   BEGIN
      UPDATE persona SET nombre=xnombre, apellido=xapellido, direccion=xdireccion, telefono=xtelefono, nacimiento=xnacimiento WHERE codigo = xcodigo;
   END $$
   DELIMITER ;

   -- PARA BORRAR LA PERSONA
   DELIMITER $$
   DROP PROCEDURE IF EXISTS `borrarPersona` $$
   CREATE PROCEDURE `borrarPersona`(IN xcodigo VARCHAR(8))
   BEGIN
      DELETE FROM persona WHERE codigo = xcodigo;
   END $$
   DELIMITER ;

   -- PARA BUSCAR LA PERSONA
   DELIMITER $$ 
   DROP PROCEDURE IF EXISTS `buscarPersona` $$
   CREATE PROCEDURE `buscarPersona`(IN texto TEXT)
   BEGIN
      SELECT * FROM persona WHERE codigo LIKE CONCAT('%', texto , '%') OR nombre LIKE CONCAT('%', texto , '%') OR apellido LIKE CONCAT('%', texto , '%') OR direccion LIKE CONCAT('%', texto , '%') OR telefono LIKE CONCAT('%', texto , '%') ;
   END $$ 
   DELIMITER ;

Con los procedimientos almacenados creados se debe pensar en cómo listar, limpiar o borrar los registros dentro del JTable, empezaré por listar los registros, para ello utilizaré el método leerPersona de la clase Persona.java, a continuación te dejo el código para listar los registros dentro del jTblPersona:

   
   public void listarTabla(String consulta) {
      try {
         vaciarTabla();
         rs = objPersona.leerPersona(consulta);
         Object[] fila = new Object[5];
         while(rs.next()){
            fila[0] = rs.getString("codigo");
            fila[1] = rs.getString("nombre");
            fila[2] = rs.getString("apellido");
            Date nacimiento = format_date.parse(rs.getString("nacimiento"));
            fila[3] = format_show.format(nacimiento);
            fila[4] = rs.getString("telefono");

            lista = (DefaultTableModel) jTblPersona.getModel();
            lista.addRow(fila);
         }
      } catch (Exception e) {
         JOptionPane.showMessageDialog(null, e.getStackTrace());
      }
   }

Como argumento envío una variable del tipo String llamada consulta la cual me permite enviar el valor que se emparejará con el LIKE dentro del procedimiento almacenado leerPersona, con ello devuelve todo un registro del tipo ResultSet. Este método fue creado con la intención de ser reutilizada para cada uno de los eventos de los botones. Estas acciones hará que la tabla siga llenándose de datos duplicados, para evitar esto ahora crearé un método para limpiar estos registros el cual llamaré vaciarTabla.

   public void vaciarTabla(){
      lista = (DefaultTableModel) jTblPersona.getModel(); //Creamos el objeto DefaultTableModel para obtener las propiedades de las filas en el JTable
      for(int i = jTblPersona.getRowCount() - 1; i>=0;i--){
         lista.removeRow(i);}
      }
   }

Las variables globales que utilizaremos son la DefaultTableModel para la tabla, la clase Persona para el uso de sus métodos, el ResultSet para obtener el resultado de la consulta (todos los registros según sea el requerimiento), la clase Date y SimpleDateFormat para el manejo de fechas, a continuación te dejo el código:

   
   public DefaultTableModel lista;
   Persona objPersona = new Persona();
   private ResultSet rs = null;
   private Date d = new Date();
   private SimpleDateFormat format_date = new SimpleDateFormat("yyyy-MM-dd");  //Formato de la fecha para guardar
   private SimpleDateFormat format_show = new SimpleDateFormat("dd/MM/yyyy");  //Formato de la fecha para mostrar

Del mismo modo las librerías que utilicé son las siguientes:

   
   import cls.*;
   import java.sql.*;
   import java.awt.*;
   import java.util.Date;
   import java.text.*;
   import javax.swing.*;
   import javax.swing.table.*;

Cada uno de los botones realiza una acción específica (Crear, Editar, Borrar, Cerrar y Buscar). Al iniciar la ventana podrás notar que solo tres botones están activos (Crear, Cerrar y Buscar) y otros inactivos (Editar y Borrar). Para el botón Crear agregarás el siguiente codigo:

   
   if(jBtnCrear.getText().equals("Crear")) { //Comprueba si el botón lleva el texto "Crear"
      jBtnCrear.setText("Guardar"); //Cambiar el texto a Guardar
      jBtnCerrarCancelar.setText("Cancelar"); //Cambiar el texto a Cancelar
      jBtnCrear.setIcon(new ImageIcon(getClass().getResource("/img/save.png"))); //Cambiar el ícono del botón Crear
      jBtnCerrarCancelar.setIcon(new ImageIcon(getClass().getResource("/img/canc.png"))); //Cambiar el ícono del botón Cerrar
      jTxtCodigo.setText(codigo(8)); //Genera el código de 8 caracteres
      entradaEstado(true); //Cuando es true activa las cajas de texto para poder ingresar datos
   } else { //En caso de que el botón no tenga el texto "Crear"
      objPersona.setCodigo(jTxtCodigo.getText());
      objPersona.setNombre(jTxtNombres.getText());
      objPersona.setApellido(jTxtApellidos.getText()); 
      objPersona.setDireccion(jTxtDireccion.getText());   
      objPersona.setTelefono(jTxtTelefono.getText());
      objPersona.setNacimiento(format_date.format(jTxtFechaNacimiento.getDate()));
      JOptionPane.showMessageDialog(null, objPersona.crearPersona()); //Crear la persona
      listarTabla(""); //Una vez creado vuelve a listar los registros
      entradaLimpiar(); //Limpiar las cajas de texto
      entradaEstado(false); //Cuando es false desactiva las cajas de texto para no poder ingresar datos
      controlEstado(); //Volver al estado inicial los botones
   }

Para el botón Editar y Borrar previamente se debe hacer doble clic sobre el registro dentro de la tabla que deseamos para que las cajas de texto automáticamente se llenen con los datos de dicho registro, para ello activamos el evento MouseClicked de la tabla. A continuación te dejo el código:

   
   if(evt.getClickCount() >= 2) {
      capturarFila();
      jBtnCrear.setEnabled(false);
      jBtnEditar.setEnabled(true);
      jBtnBorrar.setEnabled(true);
      jBtnCerrarCancelar.setText("Cancelar");
      jBtnCerrarCancelar.setIcon(new ImageIcon(getClass().getResource("/img/canc.png")));
   }

Para el botón Editar, se debe bloquear los botones Crear y Borrar, a continuación te dejo el código:

   
   if(jBtnEditar.getText().equals("Editar")) { //Comprueba si el botón lleva el texto "Editar"
      jBtnEditar.setText("Guardar"); //Cambiar el texto a Guardar
      jBtnBorrar.setEnabled(false); //Desactivar el botón Borrar
      jBtnCerrarCancelar.setText("Cancelar"); //Cambiar el texto a Cancelar
      jBtnEditar.setIcon(new ImageIcon(getClass().getResource("/img/saveedit.png"))); //Cambiar el ícono del botón Editar
      jBtnCerrarCancelar.setIcon(new ImageIcon(getClass().getResource("/img/canc.png"))); //Cambiar el ícono del botón Cerrar
      entradaEstado(true);
   } else {
      objPersona.setCodigo(jTxtCodigo.getText());
      objPersona.setNombre(jTxtNombres.getText());
      objPersona.setApellido(jTxtApellidos.getText()); 
      objPersona.setDireccion(jTxtDireccion.getText());   
      objPersona.setTelefono(jTxtTelefono.getText());
      objPersona.setNacimiento(format_date.format(jTxtFechaNacimiento.getDate()));
      JOptionPane.showMessageDialog(null, objPersona.editarPersona()); //Editar la persona
      listarTabla(""); //Una vez creado vuelve a listar los registros
      entradaLimpiar(); //Limpiar las cajas de texto
      entradaEstado(false); //Cuando es false desactiva las cajas de texto para no poder ingresar datos
      controlEstado(); //Volver al estado inicial los botones
   }