martes, 15 de abril de 2008

PRESENTADO POR STIVEN HERNANDEZ

CONEXION JAVA-MYSQL

QUE ES MYSQL:
MySQL es un sistema de administración de bases de datos (Database Management System, DBMS) para bases de datos relacionales. Así, MySQL no es más que una aplicación que permite gestionar archivos llamados de bases de datos o , lo que es lo mismo.[1]

Instalamos MYSQL:



Luego de finalizar la configuración se procede a la configuración de MySql:





Configuramos el servidor como maquina de desarrollo:

En la vista de de configuración de desarrollo se configura el numero de usuarios:










En este paso definimos el password del administrador “root” del SGBD MySQL:




Ventana de proceso de que toda la configuración esta bien:


Instalamos el cliente SQLYog para MySQL, este cliente permite interactuar con MySQL ya que dispone de ventanas graficas, ademas existe diferentes clientes los cuales podemos elegir libremente.






Conexión entre netbeans y MySQL.Para ello primero ingresamos al netbeans, una vez dentro, elegimos la opción SERVICES, luegoDatabases>Drivers, luego clic derecho en este, para luego clic en NEW DRIVER..., se muestra la ventanasiguiente en el cual debemos darle la ruta de nuestro driver.


Una vez terminada la instalación, podemos hacer ya la prueba de conexión a MySQL mediante el cliente, previamente instalado, para ello ingresamos al programa cliente, y ejecutamos ó creamos una nueva conexión al MySQL, para ello ingresamos los datos necesarios, el password de ROOT creada durante la instalación del MySQL. y Si la conexión fue exitosa, se debe mostrar las bases de datos y todo lo demás, que existe dentro del MySQL.
El siguiente paso será crear una base de datos, y por lo menos crear un par de tablas dentro, esto nos servirá para las pruebas de conexión desde java, posteriormente.


primeramente ingresamos al netbeans, una vez dentro, elegimos la opción SERVICES, luego
Databases>Drivers, luego clic derecho en este, para luego clic en NEW DRIVER..., se muestra la ventanasiguiente en el cual debemos darle la ruta de nuestro driver.



Una vez registrado el driver, ya podemos hacer la conexión con MySQL. Para ello hacemos clic derecho sobre el driver de MySQL registrado, y luego clic en CONNECT USING..., luego se muestra una ventana, en el cual debemos ingresar los datos de nuestra base de datos creada anteriormente. Un ejemplo de conexión de muestra en la
siguiente ventana.



Si la conexión fue exitosa se debe mostrar la ventana de confirmación, con el mensaje de CONNECTION ESTABLISHED. De lo contrario se debe revisar que los datos ingresados sean los correctos. Un aspecto que me pareció súper genial, al margen la conexión, era la posibilidad de poder interactuar de forma directa con la base de datos de MySQL, desde netbeans, sin la necesidad de un cliente especial para ello, para lo cual simplemente es necesario logearse con una cuenta de usuario, como por ejemplo el ROOT, y ya podemos estar adentro, viendo, creando, eliminando y insertando datos, como se muestra en la ventana siguiente.



Si somos mas curiosos, podemos ver mas opciones que nos permiten interactuar con nuestra base de datos.
Bueno, hemos terminado la primera parte de la conexión directa, desde netbeans al MySQL, y hemos visto y utilizado las herramientas que nos facilitan el uso y manejo de la base de datos desde el IDE. Ahora nos toca hacer aplicaciones reales, específicamente para la web, para ello es necesario realizar algunas configuraciones adicionales.
Primeramente, como lógico, debemos crear un proyecto web, dentro de netbeans, para luego agregarle el driver de conexión entre java y MySQL (Connector/J driver), esto en forma de librería, este paso se irán especificando en los siguientes pasos.
Primeramente creamos la librería con el driver, para ello vamos al menú TOOLS>LIBRARIES, luego dentro de la ventana hacemos clic en NEW LIBRARY..., y luego colocamos Library Name = MySQL y Library Type=Class Libraries, luego una vez creado la librería, elegimos este, y le agregamos el *.jar.

Ahora, una vez creado la librería con el *.jar dentro, luego este debe ser agregado al proyecto, específicamente dentro de la carpeta LIBRARIES, para ello vamos dentro de la opción Projects>webapplication4>libraries, hacemos clic derecho sobre el ultimo, y luego clic en ADD LIBRARY..., después dentro de la ventana, elegimos la librería MySQL que acabamos de crear. webapplication4 es el nombre de mi proyecto.




Si usted ha agregado correctamente entonces la ruta del Connector/J del *.jar de JDBC en su ambiente de CLASSPATH se mantiene fijo.
Tip: Cuando usted hace los cambios a cualquiera de sus variables de ambiente (como CLASSPATH), cierre y re-abre cualquier orden abierto las ventanas puntuales para que ellos se refresquen su ambiente de valores no actualizados.
Ya tenemos configurado las variables de ambiente de forma correcta, el siguiente paso es crear nuestro script java, el cual accederá a la base de datos.
Nosotros crearemos un programa de Java simple que intentará conectar a nuestro servidor de base de datos MySQL usando el driver Connector/J de JDBC. Cree un nuevo archivo de *.java.

CODIGO:

mport java.io.*;
import java.net.*;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
import javax.naming.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class listahr extends HttpServlet
{
private static final String CONTENT_TYPE = "text/html;charset=UTF-8";
Connection conn;
ResultSet resultado;
Statement sentencia;
String login = "root";
String password = "secreto";
String bd = "mysql";
String url = "jdbc:mysql://localhost:3306/"+bd;
public void registrar() throws SQLException, Exception, NamingException
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
}
public void conectar() throws SQLException,Exception
{
conn = DriverManager.getConnection(url,login,password);
}
public void consultar() throws SQLException,Exception
{
sentencia = null;
resultado = null;
sentencia = conn.createStatement();
resultado = sentencia.executeQuery("select * from departamento");
}
public void init(ServletConfig config) throws ServletException
{
super.init(config);
}
public void resultado(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
response.setContentType(CONTENT_TYPE);
PrintWriter out = response.getWriter();
out.println("

Servlet de conexion a BD..." + request.getContextPath () + "

");
try
{ registrar();
try
{ conectar();
if (conn != null)
{ out.println("Conexión a base de datos " + url + " ... Ok");
conn.close();
}
}
catch(Exception e)
{
out.println("Error en la conexion a BD " + url + e.getMessage());
}
}
catch(Exception e)
{
out.println("Error en el registro del driver " + url + e.getMessage());
}
out.close();
}
public String getServletInfo()
{
return "Short description";
}
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
resultado(request, response);
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
resultado(request, response);
}
}[2]

[1]http://www.esepestudio.com/articulo/desarrollo-web/bases-de-datos-mysql/Que-es-MySQL.htm
[2]http://www.latindevelopers.com/forum/viewtopic.4857.html.

CONEXION ORACLE-JAVA

QUE ES ORACLE:
básicamente una herramienta cliente/servidor para la gestión de Bases de Datos. Es un producto vendido a nivel mundial, aunque la gran potencia que tiene y su elevado precio hace que sólo se vea en empresas muy grandes y multinacionales, por norma general. En el desarrollo de páginas web pasa lo mismo: como es un sistema muy caro no está tan extendido como otras bases de datos, por ejemplo, Access, MySQL, SQL Server, etc.[1]

CONEXION:

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.

  1. l 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) .
  2. 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).
  3. El driver JDBC OCI permite realizar llamadas a ORACLE OCI directamente desde Java proporcionando
    un alto grado de compatibilidad con una versión específica de ORACLE utilizando métodos nativos, pero específicos de la plataforma.
  4. 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.
  5. 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.
  6. Es necesario crear un "wrapper" para poder ejecutar el programa desde PL/SQL o SQL.
  7. Una vez hecho esto, podemos ejecutar la función como si se tratase de una función PL/SQL.
[2]
[1]http://www.desarrolloweb.com/articulos/840.php.
[2]http://www.devjoker.com/contenidos/Articulos/132/Como-conectar-a-ORACLE-con-Java.aspx

CONEXION ACCESS-JAVA

QUE ES ACCESS:
Podemos definir Access como una herramienta para la administración de bases de
datos relacionales.
En su forma más simple, una base de datos es una colección de datos
relacionados a un tema particular, una lista de datos. Cuando se efectúa una lista
de direcciones, nombres, productos, se está generando una base de datos. De
hecho, no es necesario usar un programa de bases de datos para crear una: se
podría estar haciendo una lista como la que acabamos de mencionar usando
Excel, Word o (incluso) el Bloc de notas.[1]

CREAR UN NUEVO 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.

CARGAR EL DRIVE:

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

EL OBJETO DE CONEXION:

Debemos realizar la conexión a nuestro origen de datos. Para ello debemos crear un objeto Connection de la siguiente forma:

Connection con = DriverManager.getConnection("jdbc:odbc:Nombre_Perfil_DSN", "Nombre_Usuario", "Contraseña");

Los dos últimos parámetros pueden ser cadenas vacías "" a no ser que la base de datos las requiera. Con esto ya hemos realizado una conexión a nuestra base de datos. Pero esto todavía no es suficiente. Ahora vamos a crear un objeto Statement con el que podremos ejecutar y hacer consultas SQL. Si hasta ahora todo ha sido rutinario a partir de ahora vamos a poder crear código más adaptado a las necesidades de nuestro programa.

[2]


[1]http://faa.unse.edu.ar/alumnos/document/Acc2K_1.pdf
[2]http://www.gamarod.com.ar/articulos/como_conectar_java_y_access.asp

CONEXION SQL SERVER-JAVA

SQL Server : es un potente motor de bases de datos de alto rendimiento capaz de soportar millones de registros por tabla con un interface intuitivo y con herramientas de desarrollo integradas como Visual Studio 6.0 o .NET, además incorpora un modelo de objetos totalmente programable (SQL-DMO) con el que podemos desarrollar cualquier aplicación que manipule componentes de SQL Server, es decir, hacer aplicación para crear bases de datos, tablas, DTS, backups, etc., todo lo que se puede hacer desde el administrador del SQL Server y podemos hacerlo no solo en Visual C++ sino también en Visual Basic, ASP y por supuesto en .NET.[1]

Para establecer una conexión a una base de datos con la clase DriverManager, debe registrar primero el controlador como en el ejemplo siguiente:

Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

Una vez cargado el controlador, puede establecer una conexión con una URL de conexión:

String connectionUrl = "jdbc:sqlserver://localhost:1433;" +

"databaseName=AdventureWorks;user=MyUserName;password=*****;";

Connection con = DriverManager.getConnection(connectionUrl); [2]

Este es bloque para la conexion:

// cargar el controlador JDBCODBC
try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
} catch (Exception e) {
System.out.println("Fallo en carga del controlador JDBC/ODBC");
}
// obtener la conexion
try {
Connection con = DriverManager.getConnection(
"jdbc:odbc:cursopoo",
"alumno",
"alumnopoo");
} catch (Exception e) {
System.err.println("problemas para conectar a "+URL);
}

[2]




[1]http://www.netveloper.com/contenido2.aspx?IDC=64_0.
[3]http://www.tamps.cinvestav.mx/~ilopez/poo/poo-XIII.pdf.

CONEXION JAVA -POSTGRES

PostgreSQL :es un Sistema de Gestión de Bases de Datos Objeto-Relacionales (ORDBMS) que ha sido desarrollado de varias formas desde 1977. Comenzó como un proyecto denominado Ingres en la Universidad Berkeley de California. Ingres fue más tarde desarrollado comercialmente por la Relational Technologies/Ingres Corporation.

En 1986 otro equipo dirigido por Michael Stonebraker de Berkeley continuó el desarrollo del código de Ingres para crear un sistema de bases de datos objeto-relacionales llamado Postgres. En 1996, debido a un nuevo esfuerzo de código abierto y a la incrementada funcionalidad del software, Postgres fue renombrado a PostgreSQL, tras un breve periplo como Postgres95. El proyecto PostgreSQL sigue actualmente un activo proceso de desarrollo a nivel mundial gracias a un equipo de desarrolladores y contribuidores de código abierto.

PostgreSQL está ampliamente considerado como el sistema de bases de datos de código abierto más avanzado del mundo. Posee muchas características (las cuales serán discutidas en detalle en la sección denominada ``Juego de Características de PostgreSQL'') que tradicionalmente sólo se podían ver en productos comerciales de alto calibre.[1]




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 mas 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 y realizar lo que nos concierne, Altas, Bajas y Modificaciones a nuestras tablas.

Para empezar, debemos de importar lo siguiente:

import java.sql.*;

Cabe mencionar que hay una gran diferencia entre Select y Update, Insert o Delete, ya que no se aplican de igual manera. A continuación muestro el proceso para realizar un Select (en idioma geek, vamos a selectear)

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, necesitariamos 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();
}
}
}

Para realizar todo aquello diferente a un Select, utilzaremos lo siguiente:

/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra máquina, necesitariamos 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();

//Una variable String para almacenar la sentencia SQL
String query = "update moo.usuarios set nombre = 'Mauricio' where id = '1'";

//Ejecutamos la consulta SQL
stmt.executeQuery(query);

//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();
}

Es muy importante tener en cuenta que si este método lo utilizas en una función para hacerla llamar cuando lo necesites, y quieras enviarle tanto argumentos como retornar resultados, en la función de Select las líneas siguientes NO deben de estar presentes:

stmt.execute("END");
stmt.close();

Y en la parte de Update, Insert o Delete, solo la siguiente línea:

stmt.execute("END");[2]



[1]http://www.sobl.org/traducciones/practical-postgres/node12.html
[2]http://www.mygnet.net/articulos/java/conectado_postgresql_con_java.1162


MANEJO DE EXCEPCIONES EN JAVA

QUE ES UNA EXCEPCIÓN EN JAVA:

Es un evento que ocurre durante la ejecución del programa y detiene el flujo normal de la secuencia de instrucciones de esos programas; 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 para detección y corrección de errores, Si hay un error, la aplicación no debería morirse y generar un core (meollo) o un crash en DOS. Se debería lanzar un throw (arrojar, derribar, echar) una excepción que a su vez debería capturarse en un catch (captura) y resolver la situación de error, o bien poder ser tratada finally (finalmente) por un gestor por defecto. La gestión de excepciones en Java proporciona un mecanismo poderoso para controlar programas que tengan muchas características dinámicas durante su ejecución.[1]

MANEJO DE EXCEPCIONES:

El manejo de excepciones es una estructura de control de los lenguajes de programación diseñada para manejar condiciones anormales que pueden ser tratadas por el mismo programa que se desarrolla.[2]

Por ejemplo, un programa puede admitir cierto número de errores en el formato de los datos y continuar su proceso para producir el mejor resultado posible en lugar de producir una salida aparatosa llena de mensajes de error probablemente incomprensibles para el usuario. Muchas veces la acción asociada a una excepción es simplemente producir un mensaje informativo y terminar, otras veces, es sólo indicación de la necesidad de un cambio en la estrategia de resolución del problema

A continuación se muestra como se utiliza las excepciones, a partir de la versión iterativa de HolaIte.java (“Tomado del Libro JAVA 2 Manual de Usuario y Tutorial- pag. 180”)

import java.awt.*;

import java.applet.Applet.*;

public class HolaIte extends Applet{

private int i = 0;

private String Saludos[]={

“Hola Mundo!”;

“HOLA Mundo!”;

“HOLA MUNDO!”;

};

public void paint( Graphics g ) {
    try {
        g.drawString( Saludos[i],25,25 );
        } catch( ArrayIndexOutOfBoundsException e ) {
            g.drawString( "Saludos desbordado",25,25 );
        } catch( Exception e ) {
            // Cualquier otra excepción
            System.out.println( e.toString() );  
        } finally {
            System.out.println( "Esto se imprime siempre!" );
        }
    i++;
    }[1]

CAPTURA DE EXCEPCIONES:

Las excepciones lanzadas por un método que pueda hacerlo deben recogerse en un bloque try/catch o try/ finally.

TRY:

Es el bloque de código donde se prevé que se genere una excepción. Es como decir “intenta estas sentencias y mira a ver si se produce una excepción”, seguido ir seguido al menos por un catch o una cláusula finally.

CATCH:

Es el código que se ejecuta cuando se produce la excepción. Es como decir “controlo cualquier excepción que coincida con mi argumento”). No hay código alguno que entre en bloque try y un bloque catch, ni entre bloques catch.

FINALLY:

Es el bloque de código que se ejecuta siempre, haya o no haya excepciones, existe controversia en su utilidad. Este bloque finally puede ser util cuando no hay ninguna excepción. Es un trozo de código que se ejecuta independientemente de lo que haga el bloque try.

THROW:

Se utiliza para lanzar explícitamente una excepción. En primer lugar se debe obtener una descripción de un objeto Throwable (throw ObjetoThrowable), bien mediante una cláusula catch o bien creándolo mediante el operador new.

THROWS:

Si un método es capaz de provocar una excepción que no maneja el mismo, debería especificar este comportamiento para que los métodos que lo llamen puedan colocar protecciones frente a una excepción. La palabra clave Throws se utiliza para identificar la lista posible de excepciones que un método puede lanzar.[1]

[1]] JAVA 2 Manual del Usuario y Tutoríal.

[2]http://es.wikipedia.org/wiki/Manejo_de_excepciones

lunes, 14 de abril de 2008

AWT Y SWING

AWT: es el acronimo del X Windows Tollkit para java, en donde X puede ser cualquier cosa: Abstract, Alternative, Awkward, Another, o Asqueroso; aunque parece que JavaSoft se decanta por abstracto (seriedad ante todo). Se trata de una biblioteca de clases Java para el desarrollo de Interfaces Graficas de Usuario. La versión del AWT que JavaSoft proporciona para JDK se desarrollo en solo dos meses y, aunque se ha retocado posteriormente, es la parte mas débil de todo lo que representa Java como lenguaje.

JavaSoft , en vista de la precariedad de que cuenta con el AWT, y para asegurarse de que los elementos que desarrolla para generar interfaces graficas sean fácilmente transportables entre plataforma, se ha unido con Netscape, IBM y Lighthouse Design para crear un conjunto de clases que proporcionen una sensación agradable y sean mas faciles de utilizar por el programador. Esta colección de clases son de Java Foundation Classes (JFC), que en la plataforma Java2 están constituidas por cinco grupos de clases: AWT, Java2D, Accesibilidad y Soltar y Swing.

  • AWT: engloba a todos los componentes del awt que existían en la versión 1.1.2 del JDK y los que han incorporado en versiones posteriores.
  • Java 2D: es un conjunto de clases graficas bajo licencia de IBM/Taligent.
  • Accesibilidad: proporcionar clases para facilitar el uso de computadores y tecnología informática a disminuidos, como lupas de pantalla, cosas así.
  • Arrastrar y Soltar (Drag and Drop): son clases en las que soporta Glasgow, que es la nueva generación de los JavaBeans.

Swing, es la parte mas importante. Ha sido creada en conjunto con Netscape y proporcionan una serie de componentes muy bien descritos y especificados de forma que su presentación visual es independiente de la plataforma en que se ejecute el applet o la aplicación que utilice esta clase. Swing simplemente extiende el AWT añadiendo un conjunto de componentes, JComponents, y sus clases de soporte. Hay un conjunto de componentes de Swing que son análogos a los de AWT, hay algunos de ellos que participan de la arquitectura MVC (Modelo-Vista-Controlador), aunque Swing también proporciona otros widgets nuevos como árboles, pestañas, etc.[1]

De los anteriores paquetes, los más utilizados, con diferencia, son AWT y Swing. Entonces AWT fue el primero en aparecer y proporciona componentes básicos de entrada/salida; Swing recoge la mayor parte de la funcionalidad de AWT, aportando clases más complejas y especializadas que las ya existentes, así como de otras de nueva creación. [2]

[1] JAVA 2 Manual del Usuario y Tutoríal.
[2] Java a través de ejemplos.

JTABLE

JTABLE

Las tablas en Swing son importantes y poderosas, en pricipio se crearon para construir una interfaz ligada a base de datos a traves del Java Database Connectivity (JDBC) y así evitar la complejidad inherente al manejo de los datos, proporcionando mucha flexibilidad al programador.[1].

Que es JDBC? : La colectividad de la base de datos de Java (JDBC , Java Database Connectivity) es un marco de programación para los desarrolladores de Java que escriben los programas que tienen acceso a la información guardada en bases de datos, hojas de calculo, y archivos "planos". JDBC se utiliza comúnmente para conectar un programa del usuario con una base de datos por “detrás de la escena”, sin importar qué software de administración o manejo de base de datos se utilice para controlarlo.[2].

La JTable controla como se presentan los datos, siendo el TableModel quien controla los datos en si mismos. Para crear una JTable habria que crear pues, previamente, un TableModel. Se puede implementar, para ello, la interfaz TabelModel.[1]

La interfaz TableModel: define una serie de metodos para acceder a los datos contenidos en una determinada posición en la tabla y tambien para asignar valores a la tabla. A continuacion se muestran algunos de los metodos que ofrece esta interfaz (consultad la ayuda para ver la lista completa)

// Para ob t ene r e l n´umero de columnas que posee l a t a b l a :
p u b l i c i n t getColumnCount ( )

// Para obtener el numero de filas que posee la tabla :
public int getRowCount ( )

// Para obtener el valor en una determinada celda de la tabla :
public Object getValueAt ( i n t rowIndex , i n t columnIndex )

// Para establecer el valor de una determinada celda de la tabla :
void setValueAt ( Object aValue , int rowIndex , int columnIndex )

Para realizar un model que sustituya al que se ofrece por defecto con la clase JTable hay dos
opciones:

1. Realizar una clase que implemente todos los m´etodos de la interfaz TableModel.

2. Realizar una clase que extienda a la clase AbstractTableModel (Esta segunda opcion es la que se muestra en el código de ejemplo proporcionado).

La clase AbstractTableModel ya implementa
alguno de los metodos de la interfaz TableModel pero deja otros 3 métodos de la interfaz sin
implementar:

1 public int getRowCount ( ) ;
2 public int getColumnCount ( ) ;
3 public Object getValueAt ( int row , int column ) ;[3]

Ahora creando un Modelo de Tabla –TableModel:

El modelo de tabla será aquel que determine la forma que nuestra tabla tendrá, y su comportamiento ante los eventos.
Generalmente utilizamos un tabla para listar algo, o cargar datos de forma rapida, por ejemplo personas. En este ejemplo utilizare una clase Personas que tiene tres atributos: Apellido, Nombre (Strings) y número de documento (int).
Lo primero que hay que hacer es crear una clase que implemente la interfaz TableModel. En dicha clase se instanciaran tres variables; dos del tipo LinkedList y una del tipo Persona.

public class MyModelo implements TableModel{
private LinkedList datos = new LinkedList();
private LinkedList listeners = new LinkedList();

Peronas persona =new Peronas();

….
}

La clase LinkedList es una especie de lista que permite incluir y manejar elementos a través de operaciones. Pudiendo ser de cualquier tipo, incluso null. Esta clase nos brinda métodos uniformados para insertar, borrar, obtener y poner elementos en la lista.
La implementación de la interfaz TableModel nos obliga a la utilización de algunos métodos que mostrare a continuación:

1)
public int getColumnCount() {
return 3;
}

Este metodo determina la cantidad de columnas que la tabla tendera. Por ejemplo si queremos que la tabla tenga 3 debemos retornar el numero 3

2)
public int getRowCount() {

return datos.size();
}

Retorna la cantidad de filas, se basa en la lista de elementos declarada con anterioridad.

3) Hora viene uno de los métodos mas importantes el que servirá para obtener los datos de la lista.

public Object getValueAt(int rowIndex, int columnIndex) {
Personas aux;
//castemos el dato de la lista a una variable del tipo Personas
aux = (Personas)(datos.get(rowIndex));
// Se obtendra la persona seleccionada según el numero de fila
switch (columnIndex)
{
case 0:
return aux.getDni();

case 1:
return aux.getApellido();
case 2:
return aux.getNombre();
default:
return null;

}
}

4) asi como tenemos el metodo get existe el metodo set

public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
Personas aux;
aux = (Personas)(datos.get(rowIndex));
switch(columnIndex)
{
case 0:
aux.setDni((Integer)aValue);
break;

case 1:
aux.setApellido((String)aValue);
break;
case 2:

aux.serNombre((String)aValue);
break;
default:
break;

}

TableModelEvent evento = new TableModelEvent (this, rowIndex, rowIndex,
columnIndex);
avisaSuscriptores (evento);
}

aValue es un objeto que se pasa como parametro y que contendrá, en nuestro caso, a la persona, pero para convertirla primero debemos castearlo.
Un TableModelEvent se utilizar para notificar a los suscriptores (todos aquellos que necesitan conocer las actividades que se realizan sobre el modelo, por ejemplo la tabla) que el tablemodel a cambiado.

5)
public Class getColumnClass(int columnIndex) {
// Devuelve la clase que hay en cada columna.
switch (columnIndex){
case 0:
return Integer.class;
case 1:

return String.class;
case 2:
return String.class;
default:
return Object.class;
}
}

Nos permitirá obtener las clases de cada columna para utilizarla después.

6)
public String getColumnName(int columnIndex) {
switch (columnIndex)

{
case 0:
return "DNI";
case 1:
return "Apellido";
case 2:

return “Nombre”;
default:

return null;
}
}
Este metodo permite definir el nombre de los campos que saldran en el encabezado de la tabla.

7)
public boolean isCellEditable(int rowIndex, int columnIndex) {
return true;
}

Determina si la celda es editable, nosotros podemos jugar con condicionales para determinar que columnas serán editables y cuales no. En este caso todas las celdas son editables.

8)
public void addTableModelListener(TableModelListener l) {
// Añade el suscriptor a la lista de suscriptores
listeners.add (l);
}

9)
public void removeTableModelListener(TableModelListener l) {
// borra un suscriptor
listeners.remove(l);
}

Una ves que terminamos con todos lo métodos que se nos exige implementar, podemos empezar a crear nuestros propios métodos para el manejo de los datos de las celdas.
Lo primero que aremos será crear el método que avise a los suscriptores que el modelo a cambiado y por lo tanto la tabla deberá cambiar.

private void avisaSuscriptores (TableModelEvent evento){
int i;
for (i=0; i

((TableModelListener)listeners.get(i)).tableChanged(evento);
}

Después comenzaremos a crear los metodos para insertar, borrar y acualizar las personas de la tabla

Insertar:

public void insertarPersona (Personas 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
avisaSuscriptores (evento);
}

Con el metodo LinkedList.add() agregamos un elemento a la lista de elemntos que contiene los datos de las personas. Después de ello debemos crear un TableModelEvent que permita notificar de la inserción del dato a la lista.

La estructura del constructor del TableModelEvent que utilizamos es:

TableModelEvent(TableModel modeloDeTabla, int filaInicio, int filaFin, int columna, int tipoEvento)

En este caso en particular, estamos incertando en la ultima fila por que la fila de inicio y de fin es la misma , los cambios se realizarán en todas las columnas, y el evento es un INSERT.

Borrar:

public void borrarPerona (int fila){
datos.remove(fila);
TableModelEvent evento = new TableModelEvent (this, fila, fila,
TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);

avisaSuscriptores (evento);
}

Similar a al anterior pero para borrar.

Actualizar:

public void updateTurno(Turnos turno_completo, int fila){
datos.remove(fila);
datos.add(fila,turno_completo);
TableModelEvent e =new TableModelEvent(this,fila,fila,TableModelEvent.ALL_COLUMNS,TableModelEvent.UPDATE);
this.avisaSuscriptores(e);
}

A la hora de realizar el update, prefiero primero remover de la lista el elemento (persona) que se encuentra en el lugar indicado por el parametro fila, para despues realizar la acutalizacion.

Construyendo la tabla:

Una vez creado el modelo de tabla que vamos a utilizar, solo resta crear la tabla.
Después de ver distintos códigos de cómo se crearon tablas y scrollpane, y luego se le asignaban restricciones, layouts y metodos etc, etc, encontré navegando la forma mas sencilla de crearla:
En el frame que vamos a utilizar, podemos arrastrar y soltar algún JScrollPane así lo ubicamos y le damos el tamaño que deseamos. Luego vamos al codigo y escrivimos:

MyModelo modelo =new MyModelo();
JTable tabla =new JTable(modelo);
JScrollPane jScrollPane1 =new JScrollPane(tabla);//este es el scroll creado por el ide y
//le modificamos el constructor pasandole como parametro la tabla

Sencillito no? y así, como por arte de magia tendremos una tabla. Eso si después si queremos, podemos agregar código para darle a nuestra tabla un comportamiento mas profesional.

Trabajando con los datos de la tabla:

Si queremos cargar un dato de la tabla a una variable para que la podamos manejar directamente de la memoria podemos hacer uso del los eventos del Mouse o de algún botón. Se puede realizar código que cargue todos los datos o seleccionar uno… en fin las posibilidades son muchas.

En el caso de insertar la persona hacemos:

Personas p = new Personas(25425456,”Lopez”,”Juan”);
modelo.insertarPersona(p);

..y la persona se agregara al final de la tabla.
De forma similar trabajamos con el resto de los métodos del modelo.
Mas adelante, escribiré como definir el tamaño de las columnas, y las posibilidades de agregarle componentes a las celdas, imágenes, colores, etc.
Espero haber sido de ayuda, saludos y hasta la proxima. [4]

UN EJEMPLO DE JTABLE:


[1]

[1] Libro JAVA 2 Manual de usuario y tutorial.
[2] http://www.acm.org/crossroads/espanol/xrds7-3/ovp_marzo2001.html.
[3] http://informatica.uv.es/it3guia/LP/laboratorio/P8/p8.pdf.
[4]http://arodm.blogspot.com/2006/11/tablas-under-java-i-jtables-tablemodel.html



JCOMBOX

JCOMBOX:

Las listas y cajas de "combo" en swing funcionan del mismo modo que lo hacian en AWT , aunque tienen incrementada la funcionalidad a traves de algunas funciones de conveniencia añadida. Por ejemplo, JList tiene un constructor al que se puede pasar un array de objetos String para que los presente, como una lista que se despliega hacia abajo y nos permite elegir entre varias opciones diferentes.[1]

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.[2]



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 país, 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.

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.



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



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.



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



[2]

[1]libro JAVA 2 Manual del usuario y tutorial.
[2]http://www.magusoft.net/trials/combobox.html.