Control JTable con Base de Datos
UNIVERSIDAD POLITÉCNICA AMAZÓNICA
INTEGRANTE :
CRISTHEL EDITH DELGADO BUSTAMANTE
ALEXANDRA VILLANUEVA ABANTO
BAGUA GRANDE-UTCUBAMBA-AMAZONAS
TEMA:
“Control JTable con Base de Datos
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);
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
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
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.
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
v
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:
- Es un control que nos permite mostrar la información en el orden que queramos.
- Además funciona como el datagridview el cual es un control utilizado en visual que si deseas puedes editar la información mostrado o sino deseas puedes hacerlo que no sea editable
- Es recomendable porque puedes mostrar todos los datos que deseas.
5. CONCLUSIONES:
Ø Este control también sirve para
registrar información si lo desea.
Ø Además a este control usted lo podrá
dar el número de columnas y de filas que desee.
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.
2.Este control es de mucha ayuda para poder desarrollar software en los cuales se va a tener que mostrar la información que esta almacenada en la besa de datos.
3. La información que desea guardar en la base de datos como se da en el caso de los detalles para que la persona que este manipulando pueda verificar la información guardada.
7. GLOSARIO DE TÉRMINOS:
- DIFERIR: Dicho de una persona o de una cosa: Distinguirse de otra.
- POST:Enviar.
- DEFAULT: Defecto.
- INTERFAZ:Conexión o frontera común entre dos aparatos o sistemas independientes.Conexión, física o lógica, entre una computadora y el usuario, un dispositivo periférico o un enlace de comunicaciones.
- DATABASE: Base de Datos.
- Estática : es un estado en el que las posiciones relativas de los subsistemas no varían con el tiempo.
- Base De Datos :e
- Vinculo:
- Protocolo:Es un sistema de reglas que permiten que dos o más entidades de un sistema de comunicación
- Oracle :es una compañía especializada en el desarrollo de soluciones de nube y locales.
8. Bibliografía:
Comentarios
Publicar un comentario