I. TEMA: “Control JTable con Base de Datos

1. Contenido:

v DEFINICIÓN:

JTABLE

Un JTable es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc.

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 tú puedes visualizar esta tabla, brindándole al usuario organización de información, oportunidades de editar y cambiar el tamaño de las columna entre otras.

INICIOS DE JTABLE

En principio se creó 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 para el manejo de datos, dando así al programador mucha más 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 sí 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 tú 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.

¿Y LA INFORMACIÓN, Y LAS COLUMNAS?

Jtable te brinda muchas facilidades para poder crear una table, y así mismo de llenarla con la información que desees ( números, letras etc...) por lo que sencillamente dentro de una tabla esta automáticamente a través de la información debidamente separada - por ""(comillas) o por , (coma) - es capaz de contabilizarlas y al mismo tiempo llenarla con la información que se le dio; es decir el programador solo se debe encargar de poner los títulos de las tablas y así mismo de escribir la información en el mismo orden en que desee que salga de acuerdo con los títulos y Jtable se encargara automáticamente de colocar la información donde se le indico.

¿UN CHECK BOX?

Para un CellRendered con un TableModel sencillo, tal vez identificar clases pueda ser algo más complejo que no pueda hacer, pero para uno un poco más avanzado, esto sería muy fácil, y para esto cito el caso de un CHECK BOX(casilla de verificación) el cual es un componente grafico generado por Jtable después de que identifica una información tipo boolean, dándole así la apariencia de un cuadro rellenable, un check box no es más que eso, una opción - que puede ser editable o no - que simplemente se chulea para indicar un sí o un no ( si esta chuleado significa verdadero, sino lo esta indica falso), la cual el usuario solo puede colocar mediante un TableModel que sepa identificar clases.

JAVA SWING – RELLENAR JTABLE DE BASE DE DATOS

Igual te interesa seguir este otro tutorial antes de empezar con este: Java Swing – Conectar a MySQL con patrón singleton

Para hacer esto nos vamos a la vista de diseño, y en la paleta hacemos clic en el botón de JScrollPane (recordar antes poner un Layout en la pantalla) y lo hacemos del tamaño que queramos. Una vez tenga creado el JScrollPane seleccionamos de la paleta el JTable y hacemos clic dentro de JScrollPane en la zona Viewport.

Ahora, en el recuadro de propiedades, hacemos clic en el botón Convert to local field (un botón que tiene un cuadrado rojo con una flecha hacia un rombo verde) para poder cojer la tabla desde toda la clase (lo hacemos variable local). Una vez hecho esto ya podemos ir a editar el código directamente.

Ahora le vamos a crear un modelo a la tabla, para que sea más fácil tratar con ella. Para ello en el apartado de variables locales juntos a la tabla que acabamos de crear creamos el modelo de manera que quedarían ambas cosas así:

1 2	private JTable table; private DefaultTableModel modelo;

También añadimos la instancia de la conexión:

1	DataConnection con = DataConnection.getInstance();

Si falta algún paquete por importar podéis hacer ctrl + shift + o para que se importen automáticamente los paquetes necesarios.

Una vez hecho esto copiamos el siguiente código al final del todo del método constructor (o init, según como lo tengáis):

Una vez hecho esto, creamos 2 métodos, el rellenarTabla (), para llenar la tabla con los datos de la base de datos, y el vaciarTabla () que sirve para vaciar la tabla por si hay que volver a rellenarla con algún cambio.

v PROPIEDADES:

Llenar un JTable con datos de una base de datos MySql

Para poder hacer esto, primero ya debes de haber importado tu librería de MySql conector y ya tienes tu clase de conexión, si no es así, favor de ver primero este post, haz clic aquí.

Después insertamos un JTable, del lado derecho tenemos el Swing Controls, haz clic sobre Table y después haz clic sobre tu JFrame para que se inserte el JTable, después, en el Panel de Properties, busca la opción model y haz clic en el botón de los 3 puntos.

Después en property using, eliges la opción Custom code…

Después le damos un nombre a nuestro modelo de nuestra tabla, yo le pondré modeloTabla.

Una vez que le asignamos el modelo a nuestra tabla, vamos al código para asignarle los encabezados y ver cómo vamos a rellenar la tabla.

Primero damos de alta nuestro modelo ya que lo que hicimos anteriormente fue asignarle el modelo a la tabla pero no lo declaramos, y es lo que vamos hacer aquí.

Primero, se importan las librerías que se van a ocupar que son:

import javax.swing.table.DefaultTableModel;
import java.sql.*;
import java.util.logging.*;

Después como se dijo anteriormente, se declara nuestro modelo que le asignamos a nuestra tabla, se declara con DefaultTableModel, y la librería que ocupa es javax.swing.table.DefaultTableModel y además llamamos a nuestra conexión de base de datos, yo lo llamo como conexion.conexion por que la primera conexión quiere decir que es mi Package y la segunda conexión quiere decir que es mi Clase.

Bien, enseguida si te das cuenta aparece modelo Tabla, lo que estamos haciendo ahí es inicializando nuestro modelo, fíjate que como parámetros de DefaultTableModel esta null y getColumnas (), bien donde esta null, sería la parte que ocuparíamos para llenar la tabla de datos, pero aún no llegamos ahí y llamamos a getColumnas () si te das cuenta es una subClase de tipo String array donde especificamos el encabezado de cada columna.

Además observa que tenemos otra subClase que se llama setFilas(), esta ahí porque al iniciar la clase va a ejecutar todo lo que este en setFilas() que es nuestro código que llenará la tabla de información (no importa si te da error, deja esa línea ya que si esa no se llenará el JTable).

Ahora lo más importante, llenar la JTable de datos, para esto vamos a ver que tiene la subClase setFilas () que es la que llenará la JTable de información.

Te explico el código:

Primero declaro un variable de tipo String que se llama en mi caso sql y como valor de esa variable esta la consulta que le haré a mi base de datos para que se llene la información, fíjate que son 3 columnas las que estoy pidiendo en mi consulta, las misma que tiene mi JTable.

Utilizo PreparedStatement para inicializar mi consulta.

Después utilizo ResultSet para ejecutar mi consulta.

Observa después que declaro un variable de tipo Object con el nombre datos [] y le digo que va a ver 3 objetos (las 3 columnas que pedí en mi consulta a la base de datos).

Ahora ocupo while para que me del resultado de mi consulta como parámetro le paso la variable de ResultSet y ocupamos next() para que me devuelva todos los registros que resultaron de mi consulta que realice, también observa que utilizo un bucle for dentro de while, le estoy indicando que solo va a recorrer 3 columnas y después pare la ejecución de for y al final de while fíjate que tenemos nuestro modelo de nuestra tabla que se llama modeloTabla y ocupamos el objeto addRow(datos) y como parámetro nuestro array de tipo Object que se llama datos, lo que hacemos aquí es agregar la información por fila.

v EJEMPLOS:

¿UN LIST BOX?

En algunas oportunidades, para cierto tipo de información que deseamos que el usuario complete, necesitamos darle al usuario, cierto tipo de opciones cosa que a través de un List Box tu puedes ofrecer al usuario el tipo de respuestas que tu desees que el selecciones, este tipo de organización de información ya no es tan sencillo como declarar una información tipo boolean, toca crear la lista.

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 propósitos
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);
http://www.chuidiang.com/chuwiki/index.php?title=JTable#JTable

La JTable controla cómo se presentan los datos, siendo el TableModel quien controla los datos en sí mismos. Para crear una JTable habrá pues que crear un TableModel antes, normalmente. Se puede implementar, para ello, el interfaz TableModel, pero es mucho más simple heredar de la clase ayuda AbstractTableModel. El ejemplo java1416.java muestra esta circunstancia.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
import com.sun.java.swing.event.*;
// El Modelo de la Tabla es el que controla todos los
// datos que se colocan en ella
class ModeloDatos extends AbstractTableModel {
Object datos[][] = {
{"uno","dos","tres","cuatro"},
{"cinco","seis","siete","ocho"},
{"nueve","diez","once","doce"},
};
// Esta clase imprime los datos en la consola cada vez
// que se produce un cambio en cualquiera de las
// casillas de la tabla
class TablaListener implements TableModelListener {
public void tableChanged( TableModelEvent evt ) {
for( int i=0; i < j="0;" tabla =" new" panel =" new" frame =" new">

Una vez que se tiene un TableModel, ya sólo resta colocarlo en el constructor de JTable. Todos los detalles de presentación, edición y actualización están ocultos al programador. En este ejemplo, se coloca la JTable en un JScrollPane, por lo que es necesario un método especial en JTable.
Las tablas pueden soportar un comportamiento más complejo. En el ejemplo java1417.java, se utiliza un método para cargar un array de ocho columnas por un ciento de filas y, posteriormente, la tabla es configurada para que muestre solamente las líneas verticales y permita la selección simultánea de la fila y columna en que se encuentre la celda marcada.
import java.awt.*;
import java.awt.event.*;

import java.util.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
class java1417 extends JPanel {
private JTable tabla;
private JScrollPane panelScroll;
private String titColumna[];
private String datoColumna[][];
public java1417() {
setLayout( new BorderLayout() );
// Creamos las columnas y las cargamos con los datos que van a
// aparecer en la pantalla
CreaColumnas();
CargaDatos();
// Creamos una instancia del componente Swing
tabla = new JTable( datoColumna,titColumna );
// Aquí se configuran algunos de los parámetros que permite
// variar la JTable
tabla.setShowHorizontalLines( false );
tabla.setRowSelectionAllowed( true );
tabla.setColumnSelectionAllowed( true );
// Cambiamos el color de la zona seleccionada (rojo/blanco)
tabla.setSelectionForeground( Color.white );
tabla.setSelectionBackground( Color.red );
// Incorporamos la tabla a un panel que incorpora ya una barra
// de desplazamiento, para que la visibilidad de la tabla sea
// automática
panelScroll = new JScrollPane( tabla );
add( panelScroll, BorderLayout.CENTER );
}
// Creamos las etiquetas que sirven de título a cada una de
// las columnas de la tabla
public void CreaColumnas() {
titColumna = new String[8];
for( int i=0; i < datocolumna =" new" iy="0;" ix="0;" ventana =" new">

Aunque el ejemplo contiene un array relativamente grande de datos, la clase JTable no manipula demasiado bien grandes cantidades de información, resultando un rendimiento bastante pobre cuando se sobrepasan los 2000 elementos.

JTable editable con base de datos

JTable es un componente swing java que nos permite mostrar datos en una tabla de una base de datos, sin embargo a diferencia de otros componentes similares de otros lenguajes de programación (Delphi por ejemplo), java no nos permite gestionar directamente los datos. Es eso lo que haremos hoy, construir un JTable editable, más propiamente, este JTable nos permitirá actualizar datos de una JTable directamente con la base de datos. Enjoy!

Necesitas:

§ Netbeans 6.9 o superior

§ Servidor MySQL

§ Conector MySQL JDBC

§ Java intermedio

§ 10 minutos de tu valioso tiempo

Por motivos didácticos y de simplicidad, solo se utilizara una tabla PERSONA con cuatro campos + su llave principal, la tabla es la siguiente:

CREATE TABLE persona (

  p_id int(11) NOT NULL auto_increment,

  p_nombre varchar(32) default 'Nombre',

  p_apellido varchar(32) default 'Apellido',

  p_edad int(2) default '18',

  PRIMARY KEY  (p_id)

) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=12 ;

INSERT INTO persona VALUES (1, 'Paca', 'Garte', 23);

INSERT INTO persona VALUES (2, 'Ana Lisa', 'Melchoto', 12);

INSERT INTO persona VALUES (3, 'Rosa', 'Melpito', 43);

INSERT INTO persona VALUES (4, 'Monica', 'Galindo', 63);

INSERT INTO persona VALUES (5, 'Lali', 'Cuadora', 21);

INSERT INTO persona VALUES (6, 'Mary', 'Quita', 19);

INSERT INTO persona VALUES (7, 'Flor D.', 'Turra', 26);

INSERT INTO persona VALUES (8, 'ana', 'Tomia', 18);

INSERT INTO persona VALUES (9, 'Evelin', 'Munda', 35);

INSERT INTO persona VALUES (10, 'Roque', 'Joso', 27);

INSERT INTO persona VALUES (11, 'German', 'Teca', 41);

Ok, debes crearla con todo y datos en tu base de datos.

1. Crea un proyecto en netbeans y añade un JFrame, a este añadele un control JTable, no es necesario cambiarle el nombre. Añade el Driver MySQL JDBC al proyecto.

2. Crea dos clases y llamalas database.java y MyTableCellEditor.java, la primera nos permite utilizar la base de datos y la segunda es la encargada de manipular los datos del JTable.

database.java: Esta clase es la encarga de conectarse a la base de datos, ademas tiene dos métodos para obtener una matriz con los registros de la tabla persona y un metodo para actualizar el registro dado su ID (Llave primaria)

import java.sql.*;

/**

 * @web http://www.jc-mouse.net

 * @author Mouse

*/

public class database {

 /* DATOS PARA LA CONEXION */

  private String bd = "";//BASE DE DATOS

  private String login = "root"; //USUARIO

  private String password = ""; //CONTRASEÑA

  private String url = "jdbc:mysql://localhost/"+bd;

  private Connection conn = null;

  /* Constructor de clase: Se conecta a la base de datos

*/

   public database(){

      try{

         //obtenemos el driver de para mysql

         Class.forName("com.mysql.jdbc.Driver");

         //obtenemos la conexión

         conn = DriverManager.getConnection(url,login,password);

         if (conn!=null){

            System.out.println("OK base de datos "+bd+" listo");

      }catch(SQLException e){

         System.out.println(e);

      }catch(ClassNotFoundException e){

         System.out.println(e);

    public Connection getConnection()

        return this.conn;

/* Realiza una consulta a la base de datos, retorna un Object[][] con los

 * datos de la tabla persona

*/

    public Object[][] Select_Persona()

     int registros = 0;

      String consulta = "Select p_id,p_nombre,p_apellido,p_edad FROM persona ";

      String consulta2 = "Select count(*) as total from persona ";

      //obtenemos la cantidad de registros existentes en la tabla

      try{

         PreparedStatement pstm = conn.prepareStatement( consulta2 );

         ResultSet res = pstm.executeQuery();

         res.next();

         registros = res.getInt("total");

         res.close();

      }catch(SQLException e){

         System.out.println(e);

    //se crea una matriz con tantas filas y columnas que necesite

    Object[][] data = new String[registros][4];

    //realizamos la consulta sql y llenamos los datos en la matriz "Object"

      try{

         PreparedStatement pstm = conn.prepareStatement(consulta);

         ResultSet res = pstm.executeQuery();

         int i = 0;

         while(res.next()){

            data[i][0] = res.getString( "p_id" );

            data[i][1] = res.getString( "p_nombre" );

            data[i][2] = res.getString( "p_apellido" );

            data[i][3] = res.getString( "p_edad" );

            i++;

         res.close();

          }catch(SQLException e){

               System.out.println(e);

    return data;

/* Ejecuta la actualizacion de la tabla persona dado los valores de actualizacion

 * y el ID del registro a afectar

*/

    public boolean update(String valores, String id)

        boolean res = false;

        String q = " UPDATE persona SET " + valores + " WHERE p_id= " + id;

        try {

            PreparedStatement pstm = conn.prepareStatement(q);

            pstm.execute();

            pstm.close();

            res=true;

         }catch(SQLException e){

            System.out.println(e);

        return res;

MyTableCellEditor: Esta clase es la encargada de la magia :), implementa la clase TableCellEditor y la modifica, primero, para recibir en el constructor una instancia de la clase database.java, y el nombre de la columna a la que pertenece la celda, esta clase, lo que hace es, obtener el valor de la celda y almacenarla en una variable, despues, cuando el usuario haga clic sobre la celda y modifique su valor, la clase se encarga de llamar a la función de actualización, si tiene existo cambia los valores en la base de datos, sino, retorna al antiguo valor y muestra un mensaje de alerta. La clase esta comentada así que creo que se entiende.

import java.awt.Component;

import javax.swing.AbstractCellEditor;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.table.TableCellEditor;

/**

 * @web http://www.jc-mouse.net

 * @author Mouse

*/

public class MyTableCellEditor extends AbstractCellEditor implements TableCellEditor{

    private database db;

    private String OldValue=""; //Valor antiguo de la celda

    private String NewValue=""; //valor nuevo de la celda

    private String NameColum="";//nombre de la columna

    private String ID="";// Llave del registro

    private JComponent component = new JTextField();

    public MyTableCellEditor(database db, String NameColumn)

            this.db = db;

            this.NameColum = NameColumn;

    public Object getCellEditorValue() {

        return ((JTextField)component).getText();

    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {

        OldValue = value.toString();//Toma valor de celda antes de cualquier modificación

        ID = table.getValueAt(row,0).toString();//obtiene el ID unico del registro

        ((JTextField)component).setText(value.toString());//coloca valor de la celda al JTextField

        return component;

    @Override

    public boolean stopCellEditing() {

        NewValue = (String)getCellEditorValue();//Captura nuevo valor de la celda

        //Compara valores, si no son iguales, debe actualizar registro

        if( !NewValue.equals(OldValue))

        {   //Realiza la actualizacion

            if( !db.update( NameColum+"='"+NewValue+"' ", ID ) )

            {   //Si existe algun error al actualizar, escribe viejo valor en la celda

                JOptionPane.showMessageDialog(null,"Error: No se puede actualizar");

                ((JTextField)component).setText(OldValue);

        return super.stopCellEditing();

3. Para terminar, debemos implementar ambas clases en la interfaz.java de la siguiente manera:

- Debemos importar la librería DefaultTableModel.

import javax.swing.table.DefaultTableModel;

- Declaramos las variables db y dtPersona, la primera instancia de clase database.java y la segunda una matriz [][]

private database db = new database();

    private Object[][] dtPersona;

- Agregamos una función privada Actualizar_Tabla(), como su nombre indica obtiene los datos del DataBase colocándoles en un DefaultTableModel y esta al JTable. Observe que obtenemos todos los registros y junto a todos los campos, 4 en total.

     private void Actualizar_Tabla(){

        //actualiza los datos de la tabla realizando una consulta a la base de datos

        String[] columNames = {"Codigo" ,"Nombre","Apellido","Edad"};

        dtPersona = db.Select_Persona();

        // se colocan los datos en la tabla

        DefaultTableModel datos = new DefaultTableModel(dtPersona,columNames);

        jTable1.setModel(datos);

- Aquí lo importante, en el constructor de la clase interfaz.java, agregamos el siguiente código, lo que hace, es hacer una llamada a nuestra función Actualizar_Tabla(), despues oculta la primera columna, la que corresponde a la llave primaria “p_id”, esto porque no queremos que se pueda editar esa columna, después añade a las restante columnas la clase MyTableCellEditor.

 public interfaz() {

        initComponents();

        this.setTitle("JTable editable * http://www.jc-mouse.net/");

        Actualizar_Tabla();

        //oculta columna ID

        jTable1.getColumnModel().getColumn(0).setMaxWidth(0);

        jTable1.getColumnModel().getColumn(0).setMinWidth(0);

        jTable1.getTableHeader().getColumnModel().getColumn(0).setMaxWidth(0);

        jTable1.getTableHeader().getColumnModel().getColumn(0).setMinWidth(0);

        //editor de caldas

        jTable1.getColumnModel().getColumn( 1 ).setCellEditor(new MyTableCellEditor(db,"p_nombre"));//Columna Nombre

        jTable1.getColumnModel().getColumn( 2 ).setCellEditor(new MyTableCellEditor(db,"p_apellido"));//Columna Apellido

        jTable1.getColumnModel().getColumn( 3 ).setCellEditor(new MyTableCellEditor(db,"p_edad"));//Columna Edad

2. Resumen:

Definición Jtable

INICIOS DE JTABLE

TABLE MODEL

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));

});

3. Summary:

JTable Control with Database

 Definition Jtable

Jtable is a class that allows me to organize a certain information in a table, this differs from a normal database because when using Jtable you can visualize this table, giving the user information organization, opportunities to edit and resize the columns between Others.

JTABLE STARTINGS

In principle, the Jtable class was created to constitute a database-bound interface through "Java Database Connectivity" (JDBC), thus avoiding the complexity that existed for managing data, thus giving the programmer much easier Time to work with this kind of information.

Jtable gives the programmer many facilities, as it has several features

TABLE MODEL

The Jtable class controls how the data is presented, with TableModel controlling the data itself. To create a Jtable, you must create a TableModel before, normally. TableModel what it does is to predetermine certain characteristics for the Jtable ie you can put certain parameters inside a TableModel and thus not have to always determine them.

Everything we do will be reflected immediately in the JTable.

Get row and column of JTable in which you click

Sometimes we are interested in selecting a row of JTable to do something with it (take a menu, collect data to show them elsewhere, etc).

One way to do this is by adding a MouseListener to the JTable, in this way

Table.addMouseListener (new MouseAdapter ()

{

Public void mouseClicked (MouseEvent e)

{

Int row = table.rowAtPoint (e.getPoint ());

Int column = table.columnAtPoint (e.getPoint ());

If ((row> -1) && (column> -1))

System.out.println (template.getValueAt (row, column));

});

4. Recomendaciones:

ü Para crear el JTable yo aconsejo crearlo de la vista de diseño de Java Swing, ya que así se sitúa directamente la tabla donde nosotros queramos sin tener que situarla a través de código. Recordar meter el JTable en un JScrollPane para que haya un scroll en caso de que los resultados sean más de los que se pueden ver en la tabla.

5. Conclusiones:

ü JTable es un componente swing java que nos permite mostrar datos en una tabla de una base de datos, sin embargo a diferencia de otros componentes similares de otros lenguajes de programación (Delphi por ejemplo), java no nos permite gestionar directamente los datos. Es eso lo que haremos hoy, construir un JTable editable, más propiamente, este JTable nos permitirá actualizar datos de una JTable directamente con la base de datos.

6. Apreciación del Equipo:

ü Un JTable es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc.

7. Glosario de Términos:

1) Diferir: