lunes, 14 de abril de 2008

¿COMO CONECTAR UNA BASE DE DATOS DESDE JAVA?

1.Conexión con Acces:

JDBC y ODBC

La capacidad para acceder a bases de datos desde Java la ofrece la API JDBC (Java DataBase Conectivity). JDBC es un estándar para manejar bases de datos en Java. ODBC es un estándar de Windows para manejar bases de datos, de forma que cualquier programa en Windows que desee acceder a bases de datos genéricas debe usar este estándar. La necesidad de crear un estándar propio para acceder a bases de datos desde Java se explica porque el estándar ODBC está programado en C y un programa que use este estándar, por lo tanto, depende de la plataforma.

Controladores JDBC-ODBC

Necesitamos acceder a un origren de datos ODBC pero contamos con una API que usa el estándar JDBC. Para solventar este problema las empresas realizan drivers que traducen el ODBC a JDBC. Hay varios tipos de Driver, pero para nuestro ejemplo usaremos los llamados puentes JDBC-ODBC. Estamos de suerte porque el JDK de Windows incorpora el driver necesario para conectar bases de datos Access.[1]

"...Acces no es una Base de Datos que sirva para grandes volúmenes de datos, ni que se la pueda pedir una gran concurrencia de peticiones. Si bien, esta es una base de datos con la que se puede empezar a aprender, además de dar funcionalidad a usuarios domésticos.
Access puede ser también un buen inicio para empezar a aprender a conectar bases de datos mediante JDBC. Los pasos que tendremos que seguir para conseguir esto son los siguientes:
Deberemos de crear una conexión ODBC. Una conexión ODBC permite crear una forma unificada de accesos entre una base de datos, sea cual sea su tipo (MS Access, FoxPro, MySQL,…) y el sistema Windows, y por ende los programas que corren sobre el.
Para crear una conexión ODBC deberemos de ir al Panel de Control >> Herramientas Administrativas >> Orígenes de Datos (ODBC). Si bien, esto puede cambiar dependiendo de la versión del sistema operativo y del lenguaje del sistema instalado. Al final nos aparecerá una imagen como la que sigue:



Lo siguiente que deberemos de hacer es crear un DSN del sistema. Esto lo que va a hacer es dar un nombre representativo a la base de datos que elijamos. Para ello deberemos de ir a la pestaña DSN de Sistema y pulsar sobre el botón de “Agregar…”. Saliendonos la siguiente ventana:[2]



Crear un nuevo DNS (Data Source Name):Para realizar la conexión a una base de datos ODBC necesitaremos crear un perfil DSN desde el panel de control y posteriormente accederemos a la base de datos a partir del nombre del perfil. En el perfil DSN lo que se hace es indicar el driver a utilizar, así como el archivo o archivos del origen de datos. Estos son los pasos a llevar a cabo para configurar un perfil DSN.
1.- Iremos a Panel de Control. Ello se hace desde Inicio->Configuración o desde MiPC.
2.- Ahora hacemos doble-click en el icono de Fuentes de datos ODBC (32 bits).
3.- En nuestra pantalla aparecerá ahora la pestaña DSN usuario seleccionada. Para crear un nuevo perfil haremos click en Agregar...
4.- A continuación se nos pide que ingresemos el controlador que vamos a usar en el nuevo perfil. En nuestro caso será Microsoft Access Driver (*.mdb).
5.- Una vez aquí sólo nos queda dar un nombre al origen de datos y especificar el archivo .mdb de origen. Tras aceptar la ventana ya tenemos creado un perfil con lo que ya podemos comenzar a programar.[1]

El tipo de base de datos que añadiremos será el MS Access. (*.mdb). Ahora deberemos de indicar el nombre del DSN y la ubicación de nuestra base de datos. La ventana será la que sigue:






Una vez que tenemos creado el DSN del sistema pasaremos a nuestro programa Java. Hay que recordar que para establecer una conexión JDBC necesitaremos dos cosas: el nombre del driver que realizará la conexión y la URL destino donde está la base de datos. En el caso de las conexiones ODBC existe un driver estandar que se llama

sun.jdbc.odbc.JdbcOdbcDriver.

Veamos como sería la línea de conexión de dicho driver.

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

Por lo que se refiere a la URL de destino, en el caso de ODBC se sigue la siguiente nomenclatura:"jdbc::" Donde el subprotocol sería odbc y el subname el nombre de DSN de sistema que hayamos asignado a nuestra base de datos. Quedándonos la URL de conexión de la siguiente forma:

String url = "jdbc:odbc:DSN_LineaDeCodigo"; Solo nos quedará el realizar la conexión:

Connection db = DriverManager.getConnection (url, "usuario","password");

En usuario y password deberemos de poner el nombre del usuario y password que tenga de acceso la base de datos. Si es que los tiene. En caso negativo se debarán vacios. [1]

Cargar el Driver: Lo primero es hacer una llamada al Driver JDBC-ODBC para cargarlo. Eso se consigue con las siguientes líneas de código:
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch(Exception e){ System.out.println("No se ha podido cargar el Driver JDBC-ODBC");
}

Con esto ya tenemos cargado el Driver. Ahora básicamente trabajaremos con tres objetos. Estos objetos son: Connection, Statement y ResultSet. El objeto Connection se obtiene al realizar la conexión a la base de datos. El objeto Statement se crea a partir del anterior y nos permite ejecutar SQL para hacer consultas o modificaciones en la base de datos. En caso de hacer una consulta (SELECT ... FROM ...) se nos devolverá un objeto que representa los datos que deseamos consultar; este objeto es un objeto ResultSet (Hoja de resultados).[2]"

El objeto Connection Connection con = DriverManager.getConnection("jdbc:odbc:Nombre_Perfil_DSN", "Nombre_Usuario", "Contraseña");[2]

2.Conexión con Oracle: Para poder conectar a Java con ORACLE lo primero que necesitamos es la implementación de JDBC para ORACLE. Esta implementación se encuentra en el archivo Classes12.jar que podemos encontrar en el siguiente directorio del servidor de Oracle.

%ORACLE_HOME%\jdbc\lib

ORACLE_HOME es una variable de entorno que se crea durante la instalación del servidor ORACLE, y que indica donde está instalado fisicamente ORACLE dentro del sistema de archivos, normalmente C:\oracle\ora92 para servidores Windows y ORACLE 9i. Esta .misma nomenclatura se aplica al hablar de la instalación cliente

Debemos configurar correctamente nuestra variable CLASSPATH para incluir en ella el archivo Classes12.jar.
Oracle proporciona los siguientes drivers en su implementacion JDBC:
  • JDBC Thin Driver: No requiere de la instalación cliente de ORACLE. Ideal para Applets.

  • JDBC OCI : API nativa de ORACLE, para aplicaciones J2EE.

  • JDBC KPRB driver: (default connection) para Java Stored Procedures y Database JSP's.

Todos los drivers soportan la misma sintaxis y funcionalidad, por lo que nuestro código variará únicamente en la forma de crear la conexion.

Conectar a ORACLE con JDBC Thin Driver: El driver JDBC Thin se conecta y comunica con ORACLE a nivel de sockets. Proporciona su propia versión del protocolo Net8 (SQL*Net) sobre TCP/IP, por lo que no es necesario que exista una instalación de la parte cliente de ORACLE. Dado que este driver es código 100% Java es completamente independiente de la plataforma de ejecución, y como implementa su propia versión del protocolo es ideal para aplicaciones que se ejecutan sobre un navegador Web (applets)

import java.sql.*;

class dbAccess

{

public static void main (String args [])

throws SQLException

{

try

{ Class.forName

("oracle.jdbc.driver.OracleDriver");

}

catch (ClassNotFoundException e)

{

e.printStackTrace();

}
Connection conn = DriverManager.getConnection

("jdbc:oracle:oci:@ORACLEBD", "user", "passw");

// @TNSNames_Entry, userid, password

Statement stmt = conn.createStatement();

ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");

while (rset.next()) System.out.println (rset.getString(1));

// Print col 1 stmt.close();

}

}

Conectar a ORACLE con JDBC OCI Driver: El driver JDBC OCI usa el API ORACLE OCI (Oracle Call Interface) para interactuar con ORACLE, por lo que es necesaria la instalación y configuración de la parte cliente de ORACLE. El driver OCI trabaja con SQL*Net o Net8, por lo que tamdebemos haber creado un alias en el archivo TNS names (%ORACLE_HOME%\network\ADMIN):

ORACLEBD =

(DESCRIPTION =

(ADDRESS_LIST =

(ADDRESS = (PROTOCOL = TCP)(HOST = WIN01)(PORT = 1521))

)

(CONNECT_DATA =

(SERVICE_NAME = ORACLEBD)

)

)

El driver JDBC OCI permite realizar llamadas a ORACLE OCI directamente desde Java proporcionandoun alto grado de compatibilidad con una versión específica de ORACLE utilizando métodos nativos, pero específicos de la plataforma.


import java.sql.*; }

class dbAccess

{

public static void main (String args []) throws SQLException

{

try

{

Class.forName ("oracle.jdbc.driver.OracleDriver");

}

catch (ClassNotFoundException e)

{

e.printStackTrace();

}

Connection conn = DriverManager.getConnection

("jdbc:oracle:oci:@ORACLEBD", "user", "passw");

// @TNSNames_Entry, userid, password

Statement stmt = conn.createStatement();

ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");

while (rset.next())

System.out.println (rset.getString(1));

// Print col 1 stmt.close();

}

}

Conectar a ORACLE con JDBC KPRB Driver:Por último el driver ORACLE JDBC KPRB es utilizado para escribir en Java procedimientos almacenados, funciones, triggers ... Ofrece acceso a la conexion activa por lo que no es necesario crear ninguna conexión adicional.


El driver JDBC KPRB de ORACLE permite obtener un handle de la conexion actual del contexto a través del método OracleDriver.defaultConenction(). Como hemos dicho, se utiliza para procedimientos almacenados, triggers .... Para ejecutar un procedimiento almacenado debemos estar conectados a ORACLE a través de una herramienta cliente como SQL*Plus., lo que hacemos con defaultConenction() es acceder a está conexion.


import java.sql.*;

class dbAccess{

public static String showBanner() throws SQLException

{

String banner=""; Connection conn = (new oracle.jdbc.driver.OracleDriver)).defaultConnection();

Statement stmt = conn.createStatement();

ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");

while (rset.next()) banner += rset.getString(1);

//stmt.close(); NO CERRAR LA CONEXION return banner;

}

}

[3]

3. CONEXIÓN CON SQL SERVER: En esencia las dos líneas que hacen la magia son estas y van en la clase principal:

String jdbc_driver ="com.mysql.jdbc.Driver"; // Driver para MySQL

String jdbc_url="jdbc:mysql://localhost/discoteca?user=root&password=kimono";

// Nombre de la base de datos

Aquí la base de datos se llama discoteca y el password es kimono. La BD esta en la misma computadora (localhost)

Para una BD en Access usa:

String jdbc_driver = "sun.jdbc.odbc.JdbcOdbcDriver";

String jdbc_url = "jdbc:odbc:inventario_cd";

Para una BD en SQL usa:

String jdbc_driver = "com.mysql.jdbc.Driver"; // Driver para MySQL

String jdbc_url = "jdbc:mysql://localhost/discoteca?user=root&password=kimono";

// Nombre de la base de datos
[4]


4.CONEXIÓN CON POSTGREST:“…Primero, es necesario descargarse el JDBC Driver para PostgreSQL. Este se encuentra en la página http://jdbc.postgresql.org/index.html Obviamente, será necesario contar con nuestra Base de Datos funcionando para realizar las consultas necesarias.

Posteriormente hay que determinar la manera de agregar este Driver a nuestro proyecto. NetBeans ofrece una manera más que sencilla.

Conociendo la ubicación de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos, ubicamos en el Árbol de Proyecto la opción Libraries, clic Derecho en ella y seleccionamos Add JAR / Folder..., de esta manera estaremos agregando ej .JAR del Driver que descargamos. Esto nos crea en nuestro proyecto una carpeta llamada "dist" y en ella otra de nombre "lib" donde esta nuestro Driver.

Ahora, teniendo lo necesario, podemos probar nuestra conexión con PostgreSQL

Para empezar, debemos de importar lo siguiente:

import java.sql.*;

public class Main{

public static void main(String[] args){

/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra máquina, necesitaríamos estar registrados en ella y contar con su IP*/

String url = "jdbc:postgresql://localhost/moo";

try{

//Acceso al Driver

Class.forName("org.postgresql.Driver");

//La conexión con los parámetros necesarios

Connection con = DriverManager.getConnection( url,"postgres","postgres");

//Abrimos la conexión y la iniciamos

Statement stmt = con.createStatement();

/*Un ResultSet es como en .NET un DataSet, un arreglo temporal donde se almacenará el resultado de la consulta SQL*/

ResultSet rs;

//Una variable String para almacenar la sentencia SQL

String query = "select id as ID from moo.usuarios";

//En el ResultSet guardamos el resultado de ejecutar la consulta

rs = stmt.executeQuery(query);

//En un ciclo while recorremos cada fila del resultado de nuestro

Select while ( rs.next()){

/*Aqui practicamente podemos hacer lo que deseemos con el resultado, en mi caso solo lo mande a imprimir*/

System.out.println(rs.getString("ID") + "\t" + rs.getString("ID"));

}

//Cerramos la conexión

stmt.execute("END");

stmt.close();

con.close();

}

catch( Exception e ){

//Por si ocurre un error

System.out.println(e.getMessage());

e.printStackTrace();

}

}

}

[5]

BIBLIOGRAFIA


[1] http://www.gamarod.com.ar/articulos/como_conectar_java_y_access.asp

[2] http://codigosjava.blogspot.com/2007/08/jdbc-conectarse-una-base-de-datos-ms.html

[3] http://www.devjoker.com/contenidos/Articulos/132/Como-conectar-a-ORACLE-con-Java.aspx

[4] http://www.yoreparo.com/foros/programacion/100248.html

[5]http://www.mygnet.net/articulos/java/conectando_postgresql_con_java.1162

¿COMO MANEJAR EXCEPCIONES EN JAVA?

“…Una excepción es un evento que ocurre durante la ejecución de un programa y detiene el flujo normal de la secuencia de instrucciones de ese programa; en otras palabras, una excepción es una condición anormal que surge en una secuencia de código durante su ejecución.
Las excepciones en Java están destinadas, al igual que en el resto de los lenguajes que las soportan, para la detección y corrección de errores. Si hay un error, la aplicación no debería morirse y generar un core (o un crash en caso del DOS). Se debería lanzar (throw) una excepción que a su vez debería capturar (catch) y resolver la situación de error, o poder ser tratada finalmente (finally) por un gestor por defecto u omisión. Java sigue el mismo modelo de excepciones que se utiliza en C++. Utilizadas en forma adecuada, las excepciones aumentan en gran medida la robustez de las aplicaciones.

La gestión de excepciones en Java proporciona un mecanismo excepcionalmente poderoso para controlar programas que tengan muchas características dinámicas durante su ejecución. Las excepciones son formas muy limpias de manejar errores y problemas inesperados en la lógica del programa, y no deberían considerarse como un mecanismo general de ramificaciones o un tipo de sentencias de salto. Los lugares más indicados para utilizar excepciones son aquellos en los que se usan valores como 0 o 1, en C/C++, para indicar algún fallo funcional. Por ejemplo:

#include

int fd;
fd = open( "leeme.txt" );
if( fd == -1 && errno == EEXIT )
fd = open( "defecto.txt" );
}
En este programa C, si falla la primera sentencia open() por cualquiera de las 19 razones distintas de EEXIT por las que puede fallar, entonces el programa se continuaría ejecutando y moriría por alguna razón misteriosa más adelante, dejando atrás un problema de depuración complicado y frustrante.
La versión Java del código anterior, tal como se muestra a continuación:
FilterReader fr;
try {
Fr = new FilterReader( "leeme.txt" );
} catch( FileNotFoundException e ) {
fr = new FilterReader( "defecto.txt" );
}
Proporciona una oportunidad para capturar una excepción más genérica y tratar la situación con elegancia o, en el peor de los casos, imprimiría el estado de la pila de memoria.
Por ello, que la utilización adecuada de las excepciones proporcionará un refinamiento profesional al código que cualquier usuario futuro de las aplicaciones que salgan de la mano del programador que las utilice agradecerá con toda seguridad.” [1]

“…En todo programa existen errores inesperados en tiempo de ejecución, y también errores que no consideramos debido a nuestra propia inexperiencia como programadores. Unos de estos errores ocurren por ejemplo, al intentar acceder a un elemento del arreglo que está fuera del límite de nuestro arreglo, o cuando intentamos acceder a un archivo inexistente, entre otros. Normalmente estos errores interrumpen el flujo de ejecución de nuestros programas, hasta el extremo de provocar la terminación del programa en forma inmediata. Java hace uso de las excepciones, para poder controlar los errores en tiempo de ejecución. En Java, casi todos los tipos de errores que puedan surgir en tiempo de ejecución lanzan excepciones, es decir, cuando ocurre un error dentro de un método de Java, este método crea un objeto Exception, dicho objeto contiene información sobre la excepción, que incluye su tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún código para manejar el error. El manejo de excepciones en Java sigue una estructura como esta:

try {
//Codigo donde puede ocurrir un error
}
catch (ExcepcionA ex) { // Que se va a hacer en caso quese lanze una Excepcion A }
...
catch (ExcepcionZ ex) { // Que se va a hacer en caso quese lanze una Excepcion Z }"[2]

BIBLIOGRAFIA

[1] http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte9/cap9-1.html#Cap9_1_1

[2] http://perseo.cs.buap.mx/~danguer/projects/curso_java/manual/node3.html


¿COMO MANEJAR JTABLE EN JAVA?

"...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, etc.
Como muchos componentes de java, se ha seguido una separación modelo-vista . La vista es el componente visual que vemos en pantalla, el modelo es una clase que contiene los datos que luego se verán en pantalla. El modelo de datos únicamente contiene los datos, no sabe nada de quién va a visualizar los datos ni como.
La forma más rápida y sencilla
Aparte de usar otros constructores que hay en JTable, una de lasformas más rápidas y sencillas de utilizar un JTable teniendo toda su funcionalidad, consiste en instanciar como modelo de datos un DefaultTableModel y luego un JTable , pasándole el modelo en el constructor. El código quedaría:

DefaultTableModel modelo = new DefaultTableModel();JTable tabla = new JTable (modelo);
A partir de ahora todo se maneja con el modelo. En cuanto añadamos, borremos o cambiemos datos del modelo, el JTable se enterará y actualizará automáticamente. El DefaultTableModel tiene todos los métodos necesarios para modificar datos en su interior, añadir filas o columnas y darle a cada columna el nombre que queramos
El DefaultTableModel es un modelo genérico y puede no ser suficiente (o al menos, incómodo de usar) para nuestros propósitos.
Es bastante habitual el querer manejar la tabla como si fuera una lista, de forma que cada fila corresponde a una clase de datos y las columnas son los atributos de esa clase. Por ejemplo, queremos una lista de Persona y cada persona tiene un nombre, un apellido y una edad. Queremos pintar este lista en una tabla de forma que tiene tres columnas (nombre, apellido y edad) y tantas filas como Personas haya en la lista. Lo ideal seria tener un modelo al que le diga:
modelo.anhadePersona (persona); y no un
modelo.setValueAt (fila, columna, persona.nombre);
columna++;
modelo.setValueAt (fila, columna, persona.apellido);
columna++;
modelo.setValueAt (fila, columna, edad);
y algo parecido para obtener o borrar una persona dentro del modelo.
Por ello, a veces es más cómodo implementar nuestros propios modelos de tabla. La cosa es fácil, únicamente debemos implementar la interface TableModel y luego poner además todos los métodos que queramos, como el anhadePersona() o el damePersona() mencionados antes.
Una clase que implemente un TableModel debe redefinir los siguientes métodos:
class MiModelo implements TableModel
{
public void addTableModelListener (TableModelListener l) {...}
public Class getColumnClass (int columIndex) {...}
public int getColumnCount() {...}
public String getColumnName (int columnIndex) {...}
public int getRowCount() {...}
public Object getValueAt (int rowIndex, int columnIndex) {...}
public boolean isCellEditable (int rowIndex, int columnIndex) {...}
public void removeTableModelListener (TableModelListener l) {...}
public void setValueAt (Object aValue, int rowIndex, int columnIndex)
}
Hay básicamente tres tipos de métodos:
Métodos para manejo de suscriptores al modelo. Un suscriptor es cualquier clase que quiera enterarse de cambios en los datos del modelo. El JTable es un ejemplo claro. El JTable se suscribe a cambios de datos en el modelo y de esta forma, en cuanto cambiemos datos en el modelo, el JTable se entera y se repinta automáticamente la pantalla. En este grupo están los métodos addTableModelListener() y removeTableModelListener()
Métodos para manejo de datos. Permiten obtener y cambiar datos dentro de la tabla. Son los métodos getValueAt() y setValueAt().
El resto son métodos para obtener información de la tabla en sí misma, como número de filas, número de columnas, si una fila-columna es o no editable, nombre de la columna, etc.
Métodos para los suscriptores
Para implementar los métodos de los suscriptores necesitamos que nuestro modelo tenga una lista de suscriptores y únicamente hay que añadir o borrar suscriptores de esa lista. El código puede ser tan simple como esto:
class MiModelo implements TableModel
{
public void addTableModelListener (TableModelListenerl) {
suscriptores.add (l);
}
public void removeTableModelListener (TableModelListener l) {
suscriptores.remove(l);<> }
private LinkedList suscriptores = new LinkedList();
}
Si en vez de implementar TableModel, heredamos de AbstractTableModel , ya tenemos esto implementado, además de otra serie de métodos que nos serán útiles más adelante.
Metodos para manejo de los datos
Para el manejo de datos, sólo tenemos dos métodos. El que pone un dato en una fila, columna y el que lo obtiene. Si seguimos con la idea de hacer una lista de personas, el código puede quedar como esto:

class MiModelo implements TableModel
{
public void setValueAt (Object dato, int fila, int columna) {
// Obtenemos la persona de la fila indicada
Persona aux = (Persona)datos.get (fila);
switch (columna) {
// Nos pasan el nombre.
case 0:
aux.nombre = (String)dato;
break;
// Nos pasan el apellido.
case 1:
aux.apellido = (String)dato;
break;
// Nos pasan la edad.
case 2:
aux.edad = ((Integer)dato).intValue();
break;
}
// Aquí hay que avisar a los sucriptores del cambio.
// Ver unpoco más abajo cómo.
}
public Object getValueAt (int fila, int columna) {
// Obtenemos la persona de la fila indicada
Persona aux = (Persona)datos.get (fila);
switch (columna) {
// Nos piden el nombre
case 0:
return aux.nombre;
break;
// Nos piden el apellido
case 1:
return aux.apellido;
break;
// Nos piden la edad.
case 2:
return new Integer (aux.edad);
break;
}
return null;
}
private LinkedList datos = new LinkedList();
}

Simplemente hemos declarado una lista de personas como atributo privado de la clase y hecho los switch necesarios para poner u obtener el campo concreto de Persona para la columna indicada. El Object recibido y devuelto para cada campo puede ser lo que nosotros queramos, pero para una fila, columna dada, debe ser del mismo tipo en ambos métodos. Dicho de otra forma, si devolvemos un Integer, nos pasará un Integer. Además, debe ser un Object (una instancia de una clase), por eso tratamos la edad como Integer y no como int.
El método setValueAt() tiene una pequeña pega. Cualquier modificación que hagamos en los datos, debe ser notificada a los suscriptores. Debemos crear un TableModelEvent , rellenarlo con los datos adecuados y avisar a los suscriptores.
El TableModelEvent se puede rellenar con el constructor. Para el caso de setValueAt() debemos poner después de cambiar el dato (del switch) algo como esto

TableModelEvent evento = new TableModelEvent (this, fila, fila, columna);

Se le pasan como parámetros:
  • El modelo de datos que ha cambiado. En nuestro caso this.
  • La fila inicial que ha cambiado.
  • La fila final que ha cambiado, en nuestro caso la misma que la inicial, puesto que sólo ha cambiado una.
  • La columna que ha cambiado.

Una vez creado el evento, hay que pasárselo a los suscriptores a través de su método tableChanged()

int i;

for (i=0; i

((TableModelListener)suscriptores.get(i)).tableChanged(evento);

Debemos hacer esto en todos los métodos que hagamos que cambien el modelo de datos, bien sea modificando datos, borrando o añadiendo filas o columnas.

Los demás métodos son de información general para la tabla y no tienen demasiado truco.

  • Devolver la clase de cada columna. Devolveremos String.class para el nombre y el apellido e Integer.class para la edad. Este método lo utiliza el JTable para saber como presentar o editar cada dato. Si el JTable no conoce la clase que le devolvemos (no es de las normales de java), lo más posible es que trate el dato como un Object yllame a su método toString() para pintarlo.
  • Devolver el número de columnas. Para nuestro ejemplo de Persona, que tiene tres campos, devolveremos un 3.
  • Devolver el nombre de las columnas. En nuestro ejemplo devolveremos "Nombre", "Apellido" y "Edad".
  • Devolver cuántas filas hay (el número de elementos en nuestra lista de personas)
  • Devolver si una celda en fila,columna es o no editable, es decir, si el usuario puede escribir en ella y modificar los datos del modelo. En nuestro ejemplo devolveremos true .


Otros métodos
Puesto que para eso hemos hecho este modelo, vamos a añadirle un par de métodos que nos son útiles para el ejemplo y nos facilitan el añadir y borrar personas:


public void anhadePersona (Persona nuevaPersona) {

// Añade la persona al modelo

datos.add (nuevaPersona);

// Avisa a los suscriptores creando un TableModelEvent...

TableModelEvent evento; evento = new TableModelEvent (

this, this.getRowCount()-1, this.getRowCount()-1,

TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT);

// ... y avisando a los suscriptores

int i; for (i=0; i

((TableModelListener)suscriptores.get(i)).tableChanged(evento);

}


En este caso, en el evento, hemos puesto como fila la última, quees la recién añadida. Como columna hemos puesto TableModelEvent.ALL_COLUMNS que indica que todas las columnas se han visto afectadas. Finalmente, hay un nuevo parámetro que indica que la fila indicada se ha insertado. Si no ponemos nada en este parámetro (como en el caso del setValueAt()), indica queesos datos ya existían antes y que se han modificado.
Y otro método para borrar una fila:

public void borraPersona (int fila) {

// Se borra la fila datos.remove(fila);

// Y se avisa a los suscriptores, creando un TableModelEvent...

TableModelEvent evento = new TableModelEvent (this, fila, fila,

TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);

// ... y pasándoselo a los suscriptores

int i; for (i=0; i

((TableModelListener)suscriptores.get(i)).tableChanged(evento);

}


Nada especial que comentar. Se borra la fila que se indica, se crea el evento de forma similar al anterior, pero cambiando el último parámetro y se avisa a los suscriptores.

BIBLIOGRAFIA

http://www.chuidiang.com/java/tablas/tablamodelo/tablamodelo.php

miércoles, 9 de abril de 2008

¿COMO MANEJAR JCOMBOBOX EN JAVA?

Existen muchas ocasiones en donde el usuario del programa tiene que proporcionar datos que provienen de un conjunto finito y muy pequeño de posibles respuestas, esto significa que cada vez que se ejecute el programa, el usuario estará proporcionando las mismas respuestas.

Ejemplo de esta clase de datos, son por ejemplos Municipio en BC, las posibles respuestas solo son (Tecate, Tijuana, Mexicali, Ensenada, Rosarito), otro ejemplo es Sexo (Hombre, Mujer), etc.

Para situaciones como esta, existen componentes que permiten programar por adelantado las posibles respuestas, y el usuario solo debe seleccionar la respuesta apropiada , en lugar de tener que escribirla.

Este componente ComboBox nos permite definir en primera instancia un conjunto de datos o valores respuestas asociados a una caja de edición cualesquiera, así ahora el usuario tendrá la oportunidad de seleccionar un dato del conjunto de datos o respuestas ya predefinido.

Este componente ComboBox tiene dos partes, una parte de encabezado, para poner el nombre del grupo de respuestas( por ejemplo municipios, sexo, etc.).

La segunda parte es la lista de opciones o respuestas que se debe cargar al tiempo de diseño de la ventana.

Al momento de ejecución del programa, toda la lista de respuestas, estarán a la vista del usuario, para que este ultimo la seleccione.
Recordar que el usuario al momento de ejecución del programa, solo vera el encabezado, para seleccionar su respuesta deberá apretar la flechita que esta a un lado del encabezado.
Ejemplo:

import java.lang.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class prog16 {
//declaracion, creacion e inicializacion de componentes, objetos y variables
static JFrame ventana= new JFrame();
static JPanel p1= new JPanel(); static JPanel p2= new JPanel();
static String[] lista={"municipios","tecate","tijuana","ensenada","tecate"};
static JComboBox municipios = new JComboBox(lista );
static JTextField jt1=new JTextField(15); static JButton jb1= new JButton("OK");
// parte principal de programa

public static void main(String[] args)
{ // area de definicion de propiedades de el objeto
ventana.setTitle("mi programa");
ventana.setDefaultCloseOperation(ventana.EXIT_ON_CLOSE);
ventana.getContentPane().setLayout(new GridLayout(2,0));
//cargando panel1 con combobox y definiendo titulo
p1.setLayout(new GridLayout(1,0));
//observar que index cero es el titulo (aunque es un elemento mas)
municipios.setSelectedIndex(0); p1.add(municipios);
//cargando segundo panel con jbutton y jtextfield
p2.add(jb1); p2.add(jt1);
ventana.getContentPane().add(p1); ventana.getContentPane().add(p2);
ventana.pack(); ventana.setVisible(true);
jb1.addMouseListener( new MouseAdapter()
{ public void mousePressed(MouseEvent e){
// la propiedad getselecteditem() regresa un objeto
jt1.setText(String.valueOf( municipios.getSelectedItem() ) );
}} );
}; // termina main
} // termina clase[1]


Utilizar la clase JComboBox

Para utilizar la clase JComboBox en Java, hay que seguir una serie de pasos en los cuales se definirán variables y métodos de esta clase como se muestra en la siguiente figura:



Aquí el JComboBox, está mostrando una lista en la que se dan varias opciones predeterminadas del programa, y que para cada opción hay una acción al escogerla.

Para utilizar la clase JComboBox en un programa de Java, es necesario primero adicionar lo siguiente:
String[] flechaStrings = {"imagen 1", "imagen 2", "imagen 3", "imagen 4", "imagen 5"};

Aquí primero se definen los valores que se van a tomar, en este caso los carros, para aceptar la variable de tipo String, y que va a ser util al momento de que se tomen estos valores en lista adicionandola a la clase JComboBox, ya veremos como.

En las siguientes instrucciones se darán pasos para el adicionamiento de variables a la clase JComboBox.

public clase()
{ JComboBox lista = new JComboBox(flechaStrings);
lista.setSelectedIndex(0);

Aquí estamos primero tomando la clase para que dentro de esa clase, defina una variable lista y la tome como como new JComboBox, y que además adquiera los valores de (flechaStrings); que ya habíamos definido anteriormente. [2]


JComboBox
los JComboBox son muy parecidos a las Listas, excepto que estos también permiten la introducción de los datos, las maneras para crear son muy similares a las de JList:
new JComboBox();
new JComboBox(Object[] datos);
new JComboBox(Vector datos);
Lo métodos son:
  • void : addItem(Object item). Agrega un elemento al combo
  • Object: getSelectedItem(). Retorna el valor seleccionado.
  • int: getSelectedIndex(). Obtiene el índice seleccioando.
  • void: setEditable(boolean tipo). Determina si sólo mostrara los valores (false) o si se
    pueden escribir nuevos valores (true)
Y al igual que que JList, tiene un Listener que es: ItemListener que sólo implementa un método: public void itemStateChanged(ItemEvent e) que se realiza cuando se cambia a un item.
El registro del Listener se realiza con el método addItemListener de la clase JComboBox[3]

"...Utilizar un JComboBox es muy sencillo ya que únicamente necesitamos un arreglo de String para iniciarlo y si queremos podemos añadir más elementos de una manera muy sencilla. El JComboBox es muy útil cuando queremos mostrar una lista muy larga de la que solamente se va a elegir una sola opción o cuando no tenemos mucho espacio. Se podría utilizar en una calculadora para escribir funciones y poder ver cuales fuerno las últimas que fueron seleccionadas debido a que podemos seguir añadiendo elementos.

El primer archivo incluye un programa en el que podemos seleccionar que imagen mostrar mediante un JComboBox, el segundo archivo incluye las imágenes necesarias para que el programa pueda correr.

El constructor de un JComboBox es muy sencillo, lo único que recibe es un arreglo de String. Recuerda que para iniciar un arreglo en una sola línea puedes utilizar las llaves { } como se muestra en la fotografía.

Lo único que es importante mencionar del uso del JComboBox es cómo obtener lo que está seleccionado ya que es muy importante para las aplicaciones que usamos al manejar eventos saber qué seleccionó el usuario. Para conseguir esto podemos utilizar el método getSelectedItem() del JComboBox sólo hay que recordar que el método nos devuelve un Object y tenemos que hacerle un cast a String (poniendo la palabra String entre parentesis como se ve en la imágen).

También es muy sencillo añadir más elementos a un JComboBox una vez que ya está creado. Para hacerlo basta con utilizar el método addItem() que recibe un String.

Para poder escuchar eventos el JComboBox debe de tener un ActionListener que agregamos de la misma manera en que agregaríamos uno a un JButton.

¿Cómo utilizar un JComboBox?



También es muy sencillo añadir más elementos a un JComboBox una vez que ya está creado. Para hacerlo basta con utilizar el método addItem() que recibe un String.
Para poder escuchar eventos el JComboBox debe de tener un ActionListener que agregamos de la misma manera en que agregaríamos uno a un JButton





El constructor de un JComboBox es muy sencillo, lo único que recibe es un arreglo de String. Recuerda que para iniciar un arreglo en una sola línea puedes utilizar las llaves { }


Lo único que es importante mencionar del uso del JComboBox es cómo obtener lo que está seleccionado ya que es muy importante para las aplicaciones que usamos al manejar eventos saber qué seleccionó el usuario. Para conseguir esto podemos utilizar el método getSelectedItem() del JComboBox sólo hay que recordar que el método nos devuelve un Object y tenemos que hacerle un cast a String (poniendo la palabra String entre parentesis como se ve en la imágen). [4]



BIBLIOGRAFIA

[1] http://www.programacionfacil.com/java:jcombobox

[2] http://www.gfc.edu.co/estudiantes/anuario/2003/sistemas/orlando/SGML/Jcombobox/c22.html

[3] http://perseo.cs.buap.mx/~danguer/projects/curso_java/manual/node37.html

[4] http://www.magusoft.net/trials/combobox.html