DEFINICIÓN
Al igual que los arboles las tablas son importantes y poderosas. Jtable es una clase que me permite organizar una determinada información en tabla, esta difiere de una base de datos normal porque al utilizar Jtable tu puedes visualizar esta tabla, brindándole a el usuario organización de información, oportunidades de editar y cambiar el tamaño de las columna entre otras.
SUS INICIOS (LOS DE JTABLE)
SUS INICIOS (LOS DE JTABLE)
En principio se creo la clase Jtable para constituir un interfaz ligado a bases de datos a través de "Java Database Connectivity" (JDBC), y así evita la complejidad que existía par el manejo de datos, dando así al programador mucha mas facilidad a la hora de trabajar con este tipo de información.
Jtable le da al programador muchas facilidades, pues este posee varias características que permiten hacer desde tablas con información compleja y muy estructurada hasta tablas con información sencilla y "básica".
TABLE MODEL
La clase Jtable controla como se presentan los datos, siendo el TableModel quien controla los datos sí mismos. para crear una Jtable habrá pues que crear un TableModel antes, normalmente. TableModel lo que hace es predeterminar ciertas características para el Jtable es decir que tu puedes poner ciertos parámetros dentro de un TableModel y así no tener que determinarlos siempre. TableModel es un programa que guarda los datos de la tabla para si mismo, es decir, puede tener la información de la tabla pero estos datos son los visualizados por el computador, es decir, para visualizar una tabla el TABLEMODEL puede tener la información pero sin el Jtable no se puede visualizar para el usuario.
EDITABLE O NO?
Jtable tiene una característica muy llamativa, este permite que el programador pueda decirdir que se edita y que no, sin embargo si el programador dentro de su programa o de su TABLEMODEL no tiene determinado este aspecto, Jtable automáticamente hace editable las celdas dentro de la tabla. Existen varias maneras de hacer editable o no las celdas dentro de la tabla, para ver estos comandos tu te puedes dirigir a Dentro de las celdas encontradas en una tabla se puede permitir al usuario editar o no editar según lo desee el programador, esta propiedad se puede arreglar desde el table model o directamente y/o desde el programa. Jtable tiene la propiedad de dejar editable las celdas si no encuentra nada que hable de esto.
..."Con la llegada de Swing, como parte de la JFC(Java Foundation Classes), la construcción de Interfaces Gráficas de Usuario(GUI) recibió un excelente conjunto de componentes (aproximadamente 40)que la mejoraron: desde el siempre utilizado JButton, hasta el flexible JEditorPane o el JDesktopPane, pasando por los JTree y los JTable; sin dejar de mencionar a los JFilechooser y los JDialog, todos ellos, y los componentes restantes, permiten la creación de aplicaciones con interfaces gráficas más intuitivas y completas.
Swing es el resultado de la unión de esfuerzos entre Netscape, con su Internet Foundation Classes, y SUN. Swing es sólo una parte de la JFC, muchos cometemos el error de creer que Swing y JFC son lo mismo. La JFC contiene también otros elementos, estos son algunos de ellos:
Cortar y Pegar
Elementos de Accesibilidad
Java 2D
Impresión
De todos los componentes que forman Swing, quizá los JTree y las JTable, sean los componentes con APIs más extensas (la clase JTable tiene más de 100 métodos), y quiza también los más complejos.
Afortunadamente esa complejidad les permite ser también de los componentes Swing más personalizables y potentes; al igual que en la mayoría de las otras clases Swing no es necesario conocer todos sus métodos para comenzar a utilizarlos y darles una utilidad práctica.
Como programadores, sabemos muy bien que la presentacion de datos tabulados es una de las tareas más comunes que se presentan al momento de crear interfaces gráficas; desde la simple tabla que permite únicamente mostrar el resultado de una consulta, hasta las que permiten editar directamente el contenido de cada celda, ordenar las columnas, personalizar su apariencia, etc.Todas las tareas antes descritas, y muchas otras, son posibles de realizar utilizando la clase JTable; por supuesto, mientras más complejo sea el requerimiento a cubrir, se requerirá en igual medida utilizar más métodos o recursos de la clase.
Este primer artículo:
Muestra como crear una JTable sencilla para la visualizacion de datos.
Explica que es un modelo de tabla
Muestra como crear una JTable con DefaultTableModel como modelo de tabla
Muestra como crear una JTable con AbstractTableModel como modelo de tabla
Describe la API JTable
Describe la API DefaultTableModel
Describe la API AbstractTableModel
Un Ejemplo Sencillo
El título de este artículo es: JTable con ejemplos; asi que comenzaremos creando una tabla sencilla. Esta tabla únicamente mostrará un conjunto de datos definidos desde su constructor, para ello primero daremos una vistazo rápido a los constructores que proporciona esta clase; puedes ver al final del artículo con detalle más información.
JTable()
JTable(int numRows, int numColumns)
JTable(Object[][] rowData, Object[] columnNames)
JTable(TableModel dm)
JTable(TableModel dm, TableColumnModel cm)
JTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm)
JTable(Vector rowData, Vector columnNames)
Para este primer ejemplo utilizaremos el 3er. constructor de la lista anterior. El cual nos permite construir una tabla a partir de dos parámetros; el primero de ellos: rowData es un array bidimencional de objetos que representa el contenido de la tabla, y el segundo: columnNames representa los nombres de cada columna, contenidos también en un array que por lo general es un array de String's. Nuestro primer ejemplo tendra las siguientes columnas: String[] columnNames =
{"Nombre", "Apellido", "Pasatiempo", "Años de Practica", "Soltero(a)"};
Y utilizaremos el siguiente array para su contenido: Object[][] data = {
{"Mary", "Campione", "Esquiar", new Integer(5), new Boolean(false)},
{"Lhucas", "Huml", "Patinar", new Integer(3), new Boolean(true)},
{"Kathya", "Walrath", "Escalar", new Integer(2), new Boolean(false)},
{"Marcus", "Andrews", "Correr", new Integer(7), new Boolean(true)},
{"Angela", "Lalth", "Nadar", new Integer(4), new Boolean(false)}
};
El constructor, entonces queda asi: JTable table = new JTable(data, columnNames);
El código completo de nuestro primer ejemplo es el siguiente:
Ejemplo 1. SimpleTable1.javaimport javax.swing.JTable;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.*;
import java.awt.event.*;
public class SimpleTable1 extends JFrame {
public SimpleTable1() {
super("Ejemplo 1");
//array bidimencional de objetos con los datos de la tabla
Object[][] data = {
{"Mary", "Campione", "Esquiar", new Integer(5), new Boolean(false)},
{"Lhucas", "Huml", "Patinar", new Integer(3), new Boolean(true)},
{"Kathya", "Walrath", "Escalar", new Integer(2), new Boolean(false)},
{"Marcus", "Andrews", "Correr", new Integer(7), new Boolean(true)},
{"Angela", "Lalth", "Nadar", new Integer(4), new Boolean(false)}
};
//array de String's con los títulos de las columnas
String[] columnNames = {"Nombre", "Apellido", "Pasatiempo",
"Años de Practica", "Soltero(a)"};
//se crea la Tabla
final JTable table = new JTable(data, columnNames);
table.setPreferredScrollableViewportSize(new Dimension(500, 70));
//Creamos un JscrollPane y le agregamos la JTable
JScrollPane scrollPane = new JScrollPane(table);
//Agregamos el JScrollPane al contenedor
getContentPane().add(scrollPane, BorderLayout.CENTER);
//manejamos la salida
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String[] args) {
SimpleTable1 frame = new SimpleTable1();
frame.pack();
frame.setVisible(true);
}
}"
Swing es el resultado de la unión de esfuerzos entre Netscape, con su Internet Foundation Classes, y SUN. Swing es sólo una parte de la JFC, muchos cometemos el error de creer que Swing y JFC son lo mismo. La JFC contiene también otros elementos, estos son algunos de ellos:
Cortar y Pegar
Elementos de Accesibilidad
Java 2D
Impresión
De todos los componentes que forman Swing, quizá los JTree y las JTable, sean los componentes con APIs más extensas (la clase JTable tiene más de 100 métodos), y quiza también los más complejos.
Afortunadamente esa complejidad les permite ser también de los componentes Swing más personalizables y potentes; al igual que en la mayoría de las otras clases Swing no es necesario conocer todos sus métodos para comenzar a utilizarlos y darles una utilidad práctica.
Como programadores, sabemos muy bien que la presentacion de datos tabulados es una de las tareas más comunes que se presentan al momento de crear interfaces gráficas; desde la simple tabla que permite únicamente mostrar el resultado de una consulta, hasta las que permiten editar directamente el contenido de cada celda, ordenar las columnas, personalizar su apariencia, etc.Todas las tareas antes descritas, y muchas otras, son posibles de realizar utilizando la clase JTable; por supuesto, mientras más complejo sea el requerimiento a cubrir, se requerirá en igual medida utilizar más métodos o recursos de la clase.
Este primer artículo:
Muestra como crear una JTable sencilla para la visualizacion de datos.
Explica que es un modelo de tabla
Muestra como crear una JTable con DefaultTableModel como modelo de tabla
Muestra como crear una JTable con AbstractTableModel como modelo de tabla
Describe la API JTable
Describe la API DefaultTableModel
Describe la API AbstractTableModel
Un Ejemplo Sencillo
El título de este artículo es: JTable con ejemplos; asi que comenzaremos creando una tabla sencilla. Esta tabla únicamente mostrará un conjunto de datos definidos desde su constructor, para ello primero daremos una vistazo rápido a los constructores que proporciona esta clase; puedes ver al final del artículo con detalle más información.
JTable()
JTable(int numRows, int numColumns)
JTable(Object[][] rowData, Object[] columnNames)
JTable(TableModel dm)
JTable(TableModel dm, TableColumnModel cm)
JTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm)
JTable(Vector rowData, Vector columnNames)
Para este primer ejemplo utilizaremos el 3er. constructor de la lista anterior. El cual nos permite construir una tabla a partir de dos parámetros; el primero de ellos: rowData es un array bidimencional de objetos que representa el contenido de la tabla, y el segundo: columnNames representa los nombres de cada columna, contenidos también en un array que por lo general es un array de String's. Nuestro primer ejemplo tendra las siguientes columnas: String[] columnNames =
{"Nombre", "Apellido", "Pasatiempo", "Años de Practica", "Soltero(a)"};
Y utilizaremos el siguiente array para su contenido: Object[][] data = {
{"Mary", "Campione", "Esquiar", new Integer(5), new Boolean(false)},
{"Lhucas", "Huml", "Patinar", new Integer(3), new Boolean(true)},
{"Kathya", "Walrath", "Escalar", new Integer(2), new Boolean(false)},
{"Marcus", "Andrews", "Correr", new Integer(7), new Boolean(true)},
{"Angela", "Lalth", "Nadar", new Integer(4), new Boolean(false)}
};
El constructor, entonces queda asi: JTable table = new JTable(data, columnNames);
El código completo de nuestro primer ejemplo es el siguiente:
Ejemplo 1. SimpleTable1.javaimport javax.swing.JTable;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.*;
import java.awt.event.*;
public class SimpleTable1 extends JFrame {
public SimpleTable1() {
super("Ejemplo 1");
//array bidimencional de objetos con los datos de la tabla
Object[][] data = {
{"Mary", "Campione", "Esquiar", new Integer(5), new Boolean(false)},
{"Lhucas", "Huml", "Patinar", new Integer(3), new Boolean(true)},
{"Kathya", "Walrath", "Escalar", new Integer(2), new Boolean(false)},
{"Marcus", "Andrews", "Correr", new Integer(7), new Boolean(true)},
{"Angela", "Lalth", "Nadar", new Integer(4), new Boolean(false)}
};
//array de String's con los títulos de las columnas
String[] columnNames = {"Nombre", "Apellido", "Pasatiempo",
"Años de Practica", "Soltero(a)"};
//se crea la Tabla
final JTable table = new JTable(data, columnNames);
table.setPreferredScrollableViewportSize(new Dimension(500, 70));
//Creamos un JscrollPane y le agregamos la JTable
JScrollPane scrollPane = new JScrollPane(table);
//Agregamos el JScrollPane al contenedor
getContentPane().add(scrollPane, BorderLayout.CENTER);
//manejamos la salida
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String[] args) {
SimpleTable1 frame = new SimpleTable1();
frame.pack();
frame.setVisible(true);
}
}"
..."Para usar tablas, hay que distinguir dos cosas. Por un lado tenemos el JTable, que es lo que vemos. Por otro lado tenemos los datos, que es lo que queremos pintar en el JTable. Los datos pueden guardarse en cualquier clase que implemente TableModel. Java nos ofrece DefaultTableModel, una clase que implementa TableModel y nos permite añadir, modificar y borrar esos datos.La forma sencilla de juntar todo esto es
DefaultTableModelo datos = new DefaultTableModel();
JTable tabla = new JTable(datos);
y ya está.Ahora podemos añadir columnas a nuestros datos llamando adatos.addColumn ("Nombre columna");
y podemos añadir, borrar y modificardatos.addRow ( arrayConLosDatosParaUnaFila );
}datos.removeRow ( fila );
datos.setValueAt (dato, fila, columna)".
JTable
La forma más sencilla de usar un JTable y tener toda su funcionalidad es instanciar un DefaultTableModel y meterlo en el JTable, en el constructor DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);
Podemos añadir columnas directamente en el modelo modelo.addColumn("etiqueta columna 1");
modelo.addColumn("etiqueta columna 2");
Podemos añadir datos directamente en el modelo, así como borrarlos o modificarlos Object [] fila = new Object[2];
fila[0] = "dato columna 1";
fila[1] = "dato columna 3";
modelo.addRow ( fila ); // Añade una fila al final
modelo.setValueAt ("nuevo valor", 0, 1); // Cambia el valor de la fila 1, columna 2.
modelo.removeRow (0); // Borra la primera fila
Todo lo que hagamos se reflejará de inmediato en el JTable.
Obtener fila y columna del JTable en la que se hace click
A veces nos interesa seleccionar una fila del JTable para hacer algo con ella (sacar un menú, recoger datos para mostrarlos en otro sitio, etc).
Una forma de hacerlo es añadiendo un MouseListener al JTable, de esta manera tabla.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int fila = tabla.rowAtPoint(e.getPoint());
int columna = tabla.columnAtPoint(e.getPoint());
if ((fila > -1) && (columna > -1))
System.out.println(modelo.getValueAt(fila,columna));
}
});
Hemos añadido un MouseAdapter para no tener que implementar todos los métodos del MouseListener.
Con el método tabla.rowAtPoint() es posible enterarnos en qué fila de del JTable ha ocurrido el evento del ratón (el click en este caso). Para ello basta llamar a este método pasándole las coordenadas x,y del evento de ratón, que se obtienen con el método e.getPoint().
Una vez que sabemos la fila, debemos comprobar si es mayor que -1. El método rowAtPoint() nos devuelve -1 si pinchamos en el JTable, pero fuera de cualquier fila. Es el caso de que el JTable tenga un tamaño en pixels superior al que le corresponde según su número de filas.
Lo mismo vale para columnAtPoint().
Una vez que tenemos la fila y sabemos que no es -1, es fácil a través del modelo obtener los datos correspondientes. En este caso se escribe por pantalla con un System.out.prinln() el valor de la fila y columna que se ha seleccionado.
Hacer que una celda del JTable no sea editable
Si usamos DefaultTableModel las celdas del JTable son editables por defecto. A veces esto no nos interesa y JTable no tiene métodos para impedirlo. La forma de decidir qué celdas son o no editables es hacer nuestro propio modelo de datos, nuestro TableModel. La forma sencilla de hacerlo es heredar de DefaultTableModel y redefinir el método isCellEditable() para que sirva a nuestros propositos public class MiModelo extends DefaultTableModel
{
public boolean isCellEditable (int row, int column)
{
// Aquí devolvemos true o false según queramos que una celda
// identificada por fila,columna (row,column), sea o no editable
if (column == 3)
return true;
return false;
}
}
En este ejemplo, hemos creado nuestro propio modelo de datos que hace que la columna 4 (los índices empiezan en cero) de la tabla sea editable y el resto no. Ahora simplemente instanciamos el JTable usando este modelo y rellenamos los datos igual que antes MiModelo modelo = new MiModelo();
JTable tabla = new JTable(modelo);
Cambiar el tipo de dato con DefaultTableModel
DefaultTableModel por defecto le dice al JTable que todos los datos que tiene son Object. A veces, porque queramos cambiar el TableCellRenderer o cualquier otro motivo, nos interesa que determinadas columnas se consideren como Boolean, como Integer o cualquier otro tipo de dato.
Para modificar esto, tenemos que crearnos nuestro propio modelo de Datos. La forma más sencilla es heredar de DefaultTableModel y redefinir el método getColumnClass(). public class MiModelo extends DefaultTableModel
{
/** Primera columna Boolean, segunda Integer y el resto Object */
public Class getColumnClass(int columna)
{
if (columna == 0) return Boolean.class;
if (columna == 1) return Integer.class;
return Object.class;
}
}
En el ejemplo se ha hecho que la primera columna sea de Boolean, la segunda de Integer y el resto de Object.
Una cosa curiosa de los Boolean, es que el JTable al pintarlos los pone como JCheckBox.
Hacer visible una fila concreta del JTable dentro de un JScrollPane
Para que un JTable tenga barras de scroll y tenga una "cabecera" con las etiquetas de las columnas, es necesario meterla en un JScrollPane. Esto se puede hacer de dos formas. JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane(tabla);
o bien JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(tabla);
es bastante habitual al principio equivocarse y usar el método add(), que NO funcionará correctamente JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
// Esto NO funciona.
scroll.add(tabla);
Cuando tenemos un JTable metido dentro de un JScrollPane, a veces queremos que las barras de scroll se desplacen para que una determinada celda sea visible.
No conozco una forma inmediata de hacerlo, pero una posible solución es esta. ...
// Nos devuelve la posición en pixels de una celda en fila,columna
Rectangle r = tabla.getCellRect( fila, columna, true);
// Mueve el scroll para que el rectangulo sea visible
scrollPane.getViewport().scrollRectToVisible (r);
La forma más sencilla de usar un JTable y tener toda su funcionalidad es instanciar un DefaultTableModel y meterlo en el JTable, en el constructor DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);
Podemos añadir columnas directamente en el modelo modelo.addColumn("etiqueta columna 1");
modelo.addColumn("etiqueta columna 2");
Podemos añadir datos directamente en el modelo, así como borrarlos o modificarlos Object [] fila = new Object[2];
fila[0] = "dato columna 1";
fila[1] = "dato columna 3";
modelo.addRow ( fila ); // Añade una fila al final
modelo.setValueAt ("nuevo valor", 0, 1); // Cambia el valor de la fila 1, columna 2.
modelo.removeRow (0); // Borra la primera fila
Todo lo que hagamos se reflejará de inmediato en el JTable.
Obtener fila y columna del JTable en la que se hace click
A veces nos interesa seleccionar una fila del JTable para hacer algo con ella (sacar un menú, recoger datos para mostrarlos en otro sitio, etc).
Una forma de hacerlo es añadiendo un MouseListener al JTable, de esta manera tabla.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int fila = tabla.rowAtPoint(e.getPoint());
int columna = tabla.columnAtPoint(e.getPoint());
if ((fila > -1) && (columna > -1))
System.out.println(modelo.getValueAt(fila,columna));
}
});
Hemos añadido un MouseAdapter para no tener que implementar todos los métodos del MouseListener.
Con el método tabla.rowAtPoint() es posible enterarnos en qué fila de del JTable ha ocurrido el evento del ratón (el click en este caso). Para ello basta llamar a este método pasándole las coordenadas x,y del evento de ratón, que se obtienen con el método e.getPoint().
Una vez que sabemos la fila, debemos comprobar si es mayor que -1. El método rowAtPoint() nos devuelve -1 si pinchamos en el JTable, pero fuera de cualquier fila. Es el caso de que el JTable tenga un tamaño en pixels superior al que le corresponde según su número de filas.
Lo mismo vale para columnAtPoint().
Una vez que tenemos la fila y sabemos que no es -1, es fácil a través del modelo obtener los datos correspondientes. En este caso se escribe por pantalla con un System.out.prinln() el valor de la fila y columna que se ha seleccionado.
Hacer que una celda del JTable no sea editable
Si usamos DefaultTableModel las celdas del JTable son editables por defecto. A veces esto no nos interesa y JTable no tiene métodos para impedirlo. La forma de decidir qué celdas son o no editables es hacer nuestro propio modelo de datos, nuestro TableModel. La forma sencilla de hacerlo es heredar de DefaultTableModel y redefinir el método isCellEditable() para que sirva a nuestros propositos public class MiModelo extends DefaultTableModel
{
public boolean isCellEditable (int row, int column)
{
// Aquí devolvemos true o false según queramos que una celda
// identificada por fila,columna (row,column), sea o no editable
if (column == 3)
return true;
return false;
}
}
En este ejemplo, hemos creado nuestro propio modelo de datos que hace que la columna 4 (los índices empiezan en cero) de la tabla sea editable y el resto no. Ahora simplemente instanciamos el JTable usando este modelo y rellenamos los datos igual que antes MiModelo modelo = new MiModelo();
JTable tabla = new JTable(modelo);
Cambiar el tipo de dato con DefaultTableModel
DefaultTableModel por defecto le dice al JTable que todos los datos que tiene son Object. A veces, porque queramos cambiar el TableCellRenderer o cualquier otro motivo, nos interesa que determinadas columnas se consideren como Boolean, como Integer o cualquier otro tipo de dato.
Para modificar esto, tenemos que crearnos nuestro propio modelo de Datos. La forma más sencilla es heredar de DefaultTableModel y redefinir el método getColumnClass(). public class MiModelo extends DefaultTableModel
{
/** Primera columna Boolean, segunda Integer y el resto Object */
public Class getColumnClass(int columna)
{
if (columna == 0) return Boolean.class;
if (columna == 1) return Integer.class;
return Object.class;
}
}
En el ejemplo se ha hecho que la primera columna sea de Boolean, la segunda de Integer y el resto de Object.
Una cosa curiosa de los Boolean, es que el JTable al pintarlos los pone como JCheckBox.
Hacer visible una fila concreta del JTable dentro de un JScrollPane
Para que un JTable tenga barras de scroll y tenga una "cabecera" con las etiquetas de las columnas, es necesario meterla en un JScrollPane. Esto se puede hacer de dos formas. JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane(tabla);
o bien JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(tabla);
es bastante habitual al principio equivocarse y usar el método add(), que NO funcionará correctamente JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
// Esto NO funciona.
scroll.add(tabla);
Cuando tenemos un JTable metido dentro de un JScrollPane, a veces queremos que las barras de scroll se desplacen para que una determinada celda sea visible.
No conozco una forma inmediata de hacerlo, pero una posible solución es esta. ...
// Nos devuelve la posición en pixels de una celda en fila,columna
Rectangle r = tabla.getCellRect( fila, columna, true);
// Mueve el scroll para que el rectangulo sea visible
scrollPane.getViewport().scrollRectToVisible (r);
Meter un ResultSet en un JTable. El ResultSetMetaData
..."En este tutorial tenemos un ejemplo en el que se consulta una base de datos MySQL y el resultado se muestra en un JTable. Nos centraremos en cómo meter el ResultSet en el JTable y de paso crearemos una pequeña clase ConversorResultSetADefaultTableModel que se pueda usar siempre, independientemente de la consula, la tabla, el número de columnas, etc. Eso sí, con sus limitaciones.
LA BASE DE DATOS
Presuponemos que tenemos instalado MySQL y que hemos creado una base de datos y una tabla con datos similar a la siguiente:
mysql> create database prueba;
mysql> use prueba;
mysql> create table persona (id smallint auto_increment, nombre varchar(60), nacimiento date, primary key(id));
mysql> insert persona values (NULL, 'Pedro', '1995-09-12');
Es decir, una base de datos prueba con una tabla persona que tiene los campos id, nombre y nacimiento tal cual se ve en el recuadro.
También suponemos que tenemos disponible el jar con el Driver de MySQL y que lo ponemos en el CLASSPATH o lo añadimos a nuestro proyecto si usamos un IDE.
Es decir, una base de datos prueba con una tabla persona que tiene los campos id, nombre y nacimiento tal cual se ve en el recuadro.
También suponemos que tenemos disponible el jar con el Driver de MySQL y que lo ponemos en el CLASSPATH o lo añadimos a nuestro proyecto si usamos un IDE.
LA CONSULTA Y EL ResultSet
Primero se obtiene la conexión a la base de datos con un código como este:
DriverManager.registerDriver(new com.mysql.jdbc.Driver());Connection conexion = DriverManager.getConnection("jdbc:mysql://localhost/prueba","usuario","clave");
Por supuesto tendrás que cambiar el "usuario" y "clave" por los que tú tengas en la base de datos. También, si la base de datos no corre en tu ordenador local, tienes que cambiar "localhost" por el nombre o IP del ordenador donde corra la base de datos.
El siguiente paso es realizar la consulta y obtener el ResultSet. El código es el siguiente
Statement s = conexion.createStatement();ResultSet rs = s.executeQuery("select * from persona");
METER EL ResultSet EN UN JTable
Para meter los datos en el JTable, usaremos un DefaultTableModel. Para ello basta con instanciar el JTable de esta forma
DefaultTableModel modelo = new DefaultTableModel();JTable tabla = new JTable(modelo);
Ahora sólo hay que rellenar el DefaultTableModel con los datos del ResultSet. La forma "manual" de hacer esto es la siguiente
//Creamos las columnas.modelo.addColumn("id");modelo.addColumn("nombre");modelo.addColumn("nacimiento");
// Bucle para cada resultado en la consultawhile (rs.next()){
// Se crea un array que será una de las filas de la tabla.
Object [] fila = new Object[3];
// Hay tres columnas en la tabla // Se rellena cada posición del array con una de las columnas de la tabla en base de datos. for (int i=0;i<3;i++)>
fila[i] = rs.getObject(i+1);
// El primer indice en rs es el 1, no el cero, por eso se suma 1.
// Se añade al modelo la fila completa. modelo.addRow(fila);
}
Con esto basta. Todo lo que hagamos en el DefaultTableModel se refresca automáticamente en el JTable. Por ello, según se va ejecutando este código, en el JTable se iran añadiendo automáticamente los datos.
Con esto basta. Todo lo que hagamos en el DefaultTableModel se refresca automáticamente en el JTable. Por ello, según se va ejecutando este código, en el JTable se iran añadiendo automáticamente los datos.
LOS METADATOS
El código que acabamos de hacer está claro que es muy dependiente de la tabla de base de datos que estamos consultando. Hay que añadir tantas columnas como campos tenga el resultado de base de datos. El nombre de las columnas depende de qué estemos consultando, es decir, un nombre de persona, una marca de coche, etc.
Sin embargo, existe una forma más o menos automática de hacer esto. Dado un ResultSet que obtenemos como consulta de base de datos, podemos interrogarle sobre cuántas columnas tiene y cuáles son los nombres de sus campos. Con ello, podemos hacer el código anterior de forma genérica, de tal manera que sólo teniendo el ResultSet y le DefaultTableModelo, podemos rellenarlo sin saber en absoluto qué consulta ni qué tablas se han consultado.
Para obtener esta información, hay que pedirle los MetaDatos al ResulSet. El código que lo hace es este
ResultSetMetaData metaDatos = rs.getMetaData();
La clase ResultSetMetaData contiene toda la información sobre los campos de base de datos contenidos en el ResultSet. Necesitamos preguntarle por el número de columnas y por la etiqueta para cada una de las columnas. Este es el código que lo hace
// Se obtiene el número de columnas.int numeroColumnas = metaDatos.getColumnCount();
// Se crea un array de etiquetas para rellenar
Object[] etiquetas = new Object[numeroColumnas];
// Se obtiene cada una de las etiquetas para cada columna
for (int i = 0; i <>
// Nuevamente, para ResultSetMetaData la primera columna es la 1.
etiquetas[i] = metaDatos.getColumnLabel(i + 1);
}
Listo. Ya hemos obtenido de forma genérica la información necesaria para rellenar el DefaultTableModel.
En la clase ConversorResultSetADefaultTableModel del ejemplo se hace precisamente esto. Se le pasa un DefaultTableModel y un ResultSet y se encarga de meter los datos de un lado a otro, utilizando este código genérico que hemos hecho. Una vez que tenemos el array de etiquetas, basta hacer esta llamada al DefaultTableModelo para configurar su número de columnas
modelo.setColumnIdentifiers(etiquetas);
El relleno de los datos es inmediato. Igual que el código "manual", pero se puede quitar el "3" y poner un "numeroColumnas".
EL EJEMPLO
En ResultSetATableModel.zip tienes los fuentes completos del ejemplo. Si tienes configurada la base de datos como se indicó al principio y tienes un usuario y password similar al del código, puedes desempaquetar, compilar y ejecutar con
Linux
$ unzip ResultSetATableModel.zip$ export CLASSPATH=.:/mysql-connector-java-3.1.12-bin.jar$ javac chuidiang/ejemplos/base_datos/*.java$ java chuidiang.ejemplos.base_datos.PruebaMySQL
Windows
$ unzip ResultSetATableModel.zip$ set CLASSPATH=.;\mysql-connector-java-3.1.12-bin.jar$ javac chuidiang\ejemplos\base_datos\*.java$ java chuidiang.ejemplos.base_datos.PruebaMySQL
Puesto que en el código de ejemplo he puesto que cada segundo se realice la consulta nuevamente y se refresquen los datos, mientras el progrma está en marcha puedes modificar, añadir o borrar datos de la tabla de base de datos. Verás como se actualizan en el JTable.
Puedes revisar los fuentes de ejemplo. La clase realmente interesante es ConversorResultSetADefaultTableModel que posiblemente puedas reutilzar tal cual o con pequeños cambios en tus proyectos.
Una pequeña observación respecto al código. Como SWING no es thread-safe, es decir, no se puede usar alegremente con varios hilos. Como en el ejemplo hay dos hilos: el del main y el de AWT, me he visto obligado en los sitios en que modifico el DefaultTableModel a usar un SwingUtilities.invokeAndWait(). Si quitas eso, es posible que te salten excepciones en el repintado del JTable (es lo que me pasaba a mí y por eso tuve que ponerlo)."
Listo. Ya hemos obtenido de forma genérica la información necesaria para rellenar el DefaultTableModel.
En la clase ConversorResultSetADefaultTableModel del ejemplo se hace precisamente esto. Se le pasa un DefaultTableModel y un ResultSet y se encarga de meter los datos de un lado a otro, utilizando este código genérico que hemos hecho. Una vez que tenemos el array de etiquetas, basta hacer esta llamada al DefaultTableModelo para configurar su número de columnas
modelo.setColumnIdentifiers(etiquetas);
El relleno de los datos es inmediato. Igual que el código "manual", pero se puede quitar el "3" y poner un "numeroColumnas".
EL EJEMPLO
En ResultSetATableModel.zip tienes los fuentes completos del ejemplo. Si tienes configurada la base de datos como se indicó al principio y tienes un usuario y password similar al del código, puedes desempaquetar, compilar y ejecutar con
Linux
$ unzip ResultSetATableModel.zip$ export CLASSPATH=.:
Windows
$ unzip ResultSetATableModel.zip$ set CLASSPATH=.;
Puesto que en el código de ejemplo he puesto que cada segundo se realice la consulta nuevamente y se refresquen los datos, mientras el progrma está en marcha puedes modificar, añadir o borrar datos de la tabla de base de datos. Verás como se actualizan en el JTable.
Puedes revisar los fuentes de ejemplo. La clase realmente interesante es ConversorResultSetADefaultTableModel que posiblemente puedas reutilzar tal cual o con pequeños cambios en tus proyectos.
Una pequeña observación respecto al código. Como SWING no es thread-safe, es decir, no se puede usar alegremente con varios hilos. Como en el ejemplo hay dos hilos: el del main y el de AWT, me he visto obligado en los sitios en que modifico el DefaultTableModel a usar un SwingUtilities.invokeAndWait(). Si quitas eso, es posible que te salten excepciones en el repintado del JTable (es lo que me pasaba a mí y por eso tuve que ponerlo)."
No hay comentarios:
Publicar un comentario