Cómo llenar un JTable con una tabla MySQL

¡Comparte nuestro contenido!

Ahora que ya sabemos cómo manejar ArrayList, cómo conectar una aplicación Java con MySQL, y cómo insertar datos, ha llegado el tiempo de que aprendamos a llenar un JTable con datos de MySQL para nuestras aplicaciones, algo muy fácil si ya hemos hecho lo anterior. Así que, en lugar de partir de cero, trabajaremos justo donde nos quedamos en el artículo sobre insertar datos, así que si todavía no has hecho eso, te recomendamos leerlo primero. Con eso aclarado ¡Manos a la obra!

Colocando un JTable en nuestra aplicación

Partiendo de la aplicación que ya teníamos comenzada, lo primero será hacer un poco de espacio para colocar el JTable.

Lo siguiente, consiste en ir al Palette y tomar el último de los Swing Controls llamado Table. Hecho esto, lo arrastramos al espacio que hemos librado en nuestro JFrame.

Una vez hecho esto, lo acomodamos y ajustamos según nuestra conveniencia.

Después, seleccionamos el objeto y en la pestaña Properties, presionamos el botón … de la propiedad model.

En la ventana de diálogo, presionamos el botón Reset to Default y luego el botón OK.

Para finalizar, presionamos el botón derecho del ratón sobre el JTable y seleccionamos la opción Change Variable Name.

En la ventana Rename, cambiamos el New Name a tblDatos y presionamos el botón OK.

Modificando el controlador para llenar un ArrayList

Necesitamos modificar nuestro archivo ControlDatos.java, este esta caso, añadiremos un método que llamaremos llenarDatos el cual, regresará un ArrayList de tipo ModeloDatos, recordemos que estos archivos los creamos en el artículo sobre inserción de datos.

public ArrayList<ModeloDatos> llenarDatos(){
        
}

Por supuesto, no nos olvidemos de colocar el import correspondiente.

Antes de continuar, necesitaremos añadir un import más a nuestra lista, en este caso se trata de:

import java.sql.ResultSet;

Un ResultSet nos permitirá trabajar con los datos obtenidos desde la tabla. Regresando ahora a nuestro método llenarDatos, lo primero es declarar las variables que necesitamos. Una instancia para nuestro modelo, un ResultSet, un PreparedStatement, un ArrayList basado en el modelo y por supuesto una cadena SQL con la consulta general de los datos.

ModeloDatos datos;
ResultSet rs;
PreparedStatement ps;
ArrayList<ModeloDatos> lista = new ArrayList<>();
String sql = "select id, nombre, edad, sexo from datos";

Lo siguiente, es crear un try – catch para atrapar todas las excepciones de tipo SQLException.

try{

}catch(SQLException e){
            JOptionPane.showMessageDialog(null, "Error de conexión: " + e.getMessage());
}

Dentro de ese try – catch, trabajaremos lo que sigue. Iniciando con la conexión.

con = conectar.getConexion();

Luego, preparamos la sentencia con el SQL que necesitamos.

ps = con.prepareStatement(sql);

Después, ejecutamos la sentencia SQL y guardamos lo que obtuvimos en el ResultSet.

rs = ps.executeQuery();

Con un while, recorremos los registros uno por uno con el método next.

while(rs.next()){

}

Dentro de ese while, instanciamos el objeto de tipo ModeloDatos, utilizamos los setter de cada variable de nuestro modelo (setId, setNombre, etc.), para obtener los datos del ResultSet, tenemos los métodos getInt para números enteros y getString para cadenas de texto. dichos métodos reciben como parámetro el nombre del campo correspondiente dentro de la base de datos.

datos = new ModeloDatos();
datos.setId(rs.getInt("id"));
datos.setNombre(rs.getString("nombre"));
datos.setEdad(rs.getInt("edad"));
datos.setSexo(rs.getString("sexo"));

una vez obtenidos todos los campos, añadimos el modelo que ya llenamos a nuestro ArrayList de tipo ModeloDatos, esto lo logramos con el método add.

lista.add(datos);

Fuera del while, cerramos el ResultSet, luego el PreparedStatement y por último la conexión. Es importante cerrarlos en el orden correcto.

rs.close();
ps.close();
con.close();

Por último, al final del try – catch, regresamos la lista que ya debe estar llena con toda la tabla.

return lista;

Para evitar confusiones, así debe quedar el método llenarDatos.

Llenando el JTable con nuestro ArrayList

Ahora que ya terminamos con el controlador, regresaremos a nuestro VistaDatos.java para trabajar con el ArrayList que hemos obtenido y pasarlo a nuestro JTable. En algún espacio libre del JFrame, presionamos el botón derecho del ratón, elegimos Events, luego Window y por último windowActivated.

El evento windowActivated, ocurre siempre que el JFrame es la ventana activa, por lo que es perfecto para precargar nuestro JTable. Una vez lleguemos al código, escribiremos el nombre del método que vamos a utilizar, le llamaremos llenarTabla.

llenarTabla();

Por supuesto, este método no existe, así que presionando Alt + Enter, le pedimos a Netbeans que lo haga por nosotros.

El método típicamente se creará al final de nuestro archivo, y por lo general tiene un código extra que no nos sirve.

Así que, borremos ese código extra para que podamos trabajar.

Necesitamos un objeto DefaultTableModel, pues al principio nosotros le pedimos al JTable que reseteará su modelo a los valores default.

DefaultTableModel tabla =  new DefaultTableModel();

Por supuesto, no olvidemos presionar Alt + Enter sobre ese línea para añadir el import necesario.

También, necesitamos una instancia del controlador de los datos.

ControlDatos control = new ControlDatos();

Nos hará falta, un ArrayList de tipo ModeloDatos para recibir la lista que viene del controlador.

ArrayList<ModeloDatos> datos ;

No olvidemos presionar Alt + Enter sobre esa línea para añadir el import necesario.

La última variable necesaria será un Array de 4 posiciones de String para recibir cada fila de datos, ya que nuestra tabla tiene 4 campos.

String[] fila = new String[4];

Nuestro DefaultTableModel, necesita definir las etiquetas para los nombres de cada campo, así que con el método addColumn le decimos como será cada etiqueta.

tabla.addColumn("ID");
tabla.addColumn("Nombre");
tabla.addColumn("Edad");
tabla.addColumn("Sexo");

Llenamos nuestro ArrayList con aquel que viene del método llenarDatos de nuestro controlador.

datos = control.llenarDatos();

Con un ciclo for, nos aseguramos de recorrer todo el ArrayList hasta su último elemento, esto lo logramos con el método size que nos dice cuantos elementos son.

for(int f = 0; f < datos.size(); f++){

}

Dentro de ese ciclo for, haremos que el primer elemento de la fila (el índice 0) contenga id, para obtener un dato, utilizaremos el método get de ArrayList que lleva como parámetro el índice de la tabla – en nuestro caso, eso nos los dice la variable f – Como es un ArrayList basado en ModeloDatos, podemos utilizar el correspondiente método get (getId, getNombre, etc.) y si es un valor numérico, lo convertimos con toString(). Hacemos esto mismo para los otros 3 campos.

fila[0] = datos.get(f).getId().toString();
fila[1] = datos.get(f).getNombre();
fila[2] = datos.get(f).getEdad().toString();
fila[3] = datos.get(f).getSexo();

Ya que tenemos la fila llena con un registro, lo añadimos al DefaultTableModel con el método addRow.

tabla.addRow(fila);

Fuera del ciclo for, nos aseguramos de que nuestro JTable utilice como modelo nuestro DefaultTableModel con el método setModel.

tblDatos.setModel(tabla);

Para evitar confusiones, el método llenarTabla debe quedar como sigue:

Por último, necesitamos hacer la llamada a nuestro método llenarTabla cada que insertamos un registro nuevo, o el JTable no se actualizará. Para lograr esto, invocamos el método dentro del botón guardar, btnGuardarActionPerformed, específicamente, después de resetear los objetos. Tal como lo muestra la imagen.

Probando los resultados

Si todo salió bien, estos deben ser los resultados, observe el vídeo.

DESCARGA CÓDIGO FUENTE

¿Te ha resultado? Déjanos saber en los comentarios aquí abajo, en nuestra cuenta de twitter @cablenaranja7 o en nuestra página de facebook.

Xamus Dyson

Docente, IT Manager, Blogger & Developer. Escribo por diversión, educo por pasión. | Grandstanding is not my thing.

www.cablenaranja.com

¡Comparte nuestro contenido!