Pooabd api jdbc_1_lnl_facebook

PPPRRROOOGGGRRRAAAMMMAAACCCIIIÓÓÓNNN OOORRRIIIEEENNNTTTAAADDDAAA AAA OOOBBBJJJEEETTTOOOSSS

AAAPPPLLLIIICCCAAADDDAAA AAA BBBAAASSSEEESSS DDDEEE DDDAAATTTOOOSSS

Por

LAURA NOUSSAN LETTRY

API JDBC - Parte 1

Aviso Legal El presente libro electrónico

se distribuye bajo Attribution-NonCommercial-

NoDerivs 3.0 Unported

PPOOOO AAPPLLIICCAADDAA AA BBAASSEESS DDEE DDAATTOOSS

ÍNDICE

API JDBC – PARTE 1

Introducción

1. Nociones básicas de la Programación Orientada a Objetos. Concepto. Diferencias con la programación procedimental.

2. Qué es Java. Concepto. Creación de clases, uso de paquetes. 3. Utilización de Formularios y Menús para manipular datos. Paquete Java

Swing.

4. Creación de una conexión con la API JDBC. Aplicación de SQL-DML a través de Java

1 2 9 16

ACTIVIDADES Unidad 2 Tareas

Parte 1 Lectura, trabajos, prácticas propuestas en el Website de la Materia.

(*): En el Website de la materia:

http://www.lnoussanl.com.ar/java&bd

FUENTES Bibliográficas Consultadas

1. Documentación Java en general:

The Java Tutorials:

http://docs.oracle.com/javase/tutorial

2. Documentación sobre Swing:

http://docs.oracle.com/javase/tutorial/uiswing/index.html

3. API JDBC:

http://www.oracle.com/technetwork/java/overview-141217.html

The Java Tutorial: http://docs.oracle.com/javase/tutorial/jdbc/index.html

BIBLIOGRAFÍA para el Alumno

1. Contenidos de esta Unidad

2. Programas fuentes linkeados en el site web de la materia y que son complementarios al contenido.

3. Demás material bibliográfico linkeado en el sitio web de la materia.

(*)

http://www.lnoussanl.com.ar/javabd/


API JDBC – PARTE 1

INTRODUCCIÓN

Sería arriesgado abordar de lleno el estudio del API JDBC sin repasar conceptos básicos del Paradigma de Programación Orientada a Objetos, y en particular sin utilizar Java como lenguaje.

El API JDBC permite la conexión con cualquier RDBMS que tenga implementado el Driver JDBC siguiendo las clases del API. Cabe aclarar además, que el API es parte integrante de los primeros desarrollos de la plataforma Java, mediante el paqute java.sql. Asimismo en la actualidad está presente en los diferentes entornos o plataformas de desarrollo: JavaSE, JavaME y JavaEE.

Por lo antes expresado, a modo de repaso se plantea el uso de java con programación orientada a objetos. Primero se encara la solución de problemas sencillos utilizando sólo código, para pasar con posterioridad a la utilización de Formularios, y en este caso de la librería JavaSwing, por ser una librería ideal para el desarrollo de aplicaciones de escritorio.

A través de los diferentes ejemplos desarrollados, el estudiante comprenderá que las clases bases, es decir, aquellas que algorítmicamente resuelven el planteo del problema, son fundamentales y ciertamente el medio que usemos para construir la aplicación, es independiente de ellas; ya sea que se trate de aplicaciones Swing, Jsp o Applets de Java.

En el último punto se aborda una introducción, con un ejemplo práctico, del API JDBC creando una conexión que permite devolver los datos de una consulta realizada sobre un RDBMS. Siguiendo la metodología empleada en los capítulos anteriores, se realiza la conexión sobre los dos RDBMS vistos con anterioridad: MySQL y SQL Server.

En la segunda parte se abordará con más profundidad la temática de las Excepciones puesto que el API ha sido construido y pensado para darle robustez al sistema transaccional. Lógicamente también se abordará en detalle el API JDBC y se utilizarán objetos Statements que permiten realizar inserciones, actualizaciones y eliminaciones de tablas.


El API JDBC – parte 1 pág. 1/19

API JDBC

NOCIONES BÁSICAS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS. Concepto. Diferencias con la programación procedimental.

La programación orientada a objetos (POO) es un paradigma de programación que enfoca el desarrollo de aplicaciones de manera integral.

No se puede encarar el estudio y utilización del API JDBC de Java sin hacer un repaso de conceptos básicos de lo que es la POO; partiendo de la base de que el API es parte integrante de la plataforma Java en sus diferentes versiones: JavaSE, JavaEE y JavaME.

A diferencia de la programación procedimental, en la programación orientada a objetos se gestionan los atributos y métodos de un objeto en forma conjunta y atómica. Un objeto considera ambos aspectos como fundamentales y los trata en conjunto, es decir, los atributos y métodos del objeto están diseñados para trabajar en conjunto en una plantilla llamada clase. Cuando se ejecuta el programa, se instancia al objeto definido en la plantilla.

En cambio, en la programación procedimental, los procedimientos y funciones están separados de los atributos de los ‘objetos’ que gestionan, y todo el sistema se controla mediante los mismos. Por lo tanto, los datos se suelen tratar en forma independiente del proceso, en cierto modo restándole importancia, y focalizando en realidad todo el esfuerzo en el proceso.

Las características de un lenguaje basado en el paradigma de programación orientado a objetos, básicamente debe contar con los siguientes elementos:

� CLASE: una clase es un modelo o plantilla para representar un objeto. Se puede decir entonces que es el molde básico para luego crear los objetos

o Una clase se define con atributos y métodos.

o Los atributos son las propiedades que van a caracterizar al objeto en forma general y los métodos son las funciones u operaciones que van a poder realizar el objeto.

� OJETO: es una ENTIDAD, es decir, es “algo concreto” obtenido de la plantilla; por lo tanto también podríamos decir que una CLASE es una abstracción de un objeto.

Por lo tanto, un objeto cuenta con una identidad (a través de uno o más valores de sus atributos que lo diferencia de otros), con un estado que viene dado a través de los datos del objeto (del conjunto de valores de sus atributos) y de un comportamiento (a través de sus métodos).

Sin embargo la POO se basa en algunos postulados, que también la diferencian de la programación estructurada, siendo los más importantes los siguientes:

1) Abstracción: se definen las características esenciales del objeto (tanto atributos como comportamiento)

2) Encapsulamiento: todos los elementos de una misma entidad están al mismo nivel de abstracción

3) Aislamiento: los objetos están aislados del entorno o contexto que los rodea, lo que permite proteger sus atributos y métodos

4) Modularidad: es más fácil dividir una aplicación grande en componentes debido a que unos objetos se pueden ensamblar unos con otros, ya que se comunican mediante mensajes;

5) Herencia: significa en concreto que una clase hija heredará todos los atributos y métodos de la clase padre.

6) Polimorfismo: el significado obvio de esta palabra es “varias formas” y quiere decir que un objeto puede tener métodos con el mimo nombre que otros objetos diferentes y no interferirán entre sí; por ejemplo.

7) Recolección de basura: es una característica importante y que en los hechos significa que aquél objeto que no es utiliza se destruye.

Veremos ejemplos prácticos de estas características, para lo cual hay que comprender que las clases no se diseñan solas y se debe especificar el nivel de ocultamiento o aislamiento que el objeto tendrá. Esto lo veremos a través de ejemplos con Java.

Prof

. Lau

ra N

ouss

an L

ettry



QUÉ ES JAVA. Concepto. Diseño de Clases. Los calificadores de acceso. Herencia y Polimorfismo. Uso de paquetes

Java es mucho más que un lenguaje de programación, es una Plataforma de Desarrollo de Software multiplataforma y gratuita. Como ya anticipáramos, en la actualidad cuenta con distintas plataformas de desarrollo dependiendo del tipo de usuario y de lo que se necesite desarrollar. Así por ejemplo existe una plataforma de desarrollo para móviles, para empresas, etc. No ahondaremos en ello puesto que no es nuestro objetivo y todo lo que uno quiera saber puede encontrarlo en la web de Oracle.

Al ser Java un lenguaje totalmente orientado a objetos nos permite crear las clases o plantillas y posteriormente crear los objetos.

Vamos a encarar los distintos tópicos en base a ejemplos que se pueden descargar desde el sitio web de la materia: http://www.lnoussanl.com.ar/java&bd

Para poder diseñar una clase tenemos que tener en cuenta el objeto del mundo real que queremos diseñar. El primer ejemplo, que es básico, se trata de diseñar la Clase Persona. Como todos sabemos una persona tiene ciertas características que la diferencian de otra y el proceso de analizar cuáles son las características que hacen que sea una persona es lo que se llama Abstracción.

Como atributos básicos pues podemos mencionar: el apellido, el nombre y la fecha de nacimiento. Lógicamente una persona tiene otras características por, ejemplo, el color de cabello y de ojos, los estudios que cuenta, etc. Sin embargo para el ejemplo utilizaremos los tres primeros.

En el mundo real sabemos que una persona puede tener el mismo nombre y apellido que otra persona, siendo mucho más difícil que coincida con la fecha de nacimiento, pero nada nos asegura que no pueda suceder esto. De hecho, el motivo por el cual las personas tienen un número de documento es justamente para evitar ambigüedades en cuanto a su identificación.

Así pues el otro atributo básico que necesitamos, es el número de documento.

Como una buena práctica de programación, en el curso, seguiremos estas sencillas reglas:

1. El nombre de la clase siempre va en singular y la primera letra en mayúscula

2. Los atributos y métodos de las clases se escribirán con su primera letra en minúscula.

3. Las clases que representen los objetos con los que trabajaremos compartirán un mismo espacio, en principio, llamado paquete.

4. Las clases además estarán escritas por separado en archivos *.java separados del archivo que inicie el objeto llamado aplicación.

A continuación transcribo los archivos java que describen el problema planteado:

Archivo Persona.java:

1 package TOI_2013.ejemplo1; 2 3 /** 4 * 5 * @author Laura Noussan Lettry 6 */ 7 public class Persona { 8 //atributos 9 private String apellido=""; 10 private String nombre=""; 11 private String fecha_nac=" / / "; 12 private int documento=0; 13 14 //métodos 15 //constructor 16 public Persona(String a,String n,String f, int d){ 17 apellido=a; 18 nombre=n; 19 fecha_nac=f; 20 documento=d; 21 } 22 23 public String mostrarDatos(){ 24 return "Los datos de la Persona son:\n " 25 + "Apellido: "+this.apellido.toString()+ 26 "\n Nombre: "+this.nombre.toString()+ Pr

of. L

aura

Nou

ssan

Let

try



27 "\n Fecha de Nacimiento: "+this.fecha_nac.toLowerCase()+ 28 "\n Documento: "+this.documento; 29 } 30 }//fin clase Persona

La clase runtime o clase de la Aplicación está diseñada en el archivo Ejemplo1.java, es decir va por fuera de la clase en un archivo aparte.

Archivo Ejemplo1.java

1 package TOI_2013.ejemplo1; 2 import javax.swing.JOptionPane; 3 4 /** 5 * @author Laura Noussan Lettry 6 */ 7 public class Ejemplo1 { 8 9 /** 10 * @param args the command line arguments 11 */ 12 public static void main(String[] args) { 13 //aquí se utiliza el constructor diseñado 14 Persona Pedro= new Persona("Moreno","Pedro","20/05/1996",42500333); 15 JOptionPane.showMessageDialog(null,Pedro.mostrarDatos() ) ; 16 } 17 }//fin clase Ejemplo1

Análisis de las clases:

La clase Persona creará un objeto persona que tendrá los atributos apellido, nombre, fecha de nacimiento y documento.

La creación del objeto se lleva a cabo mediante un método especial, llamado constructor. El constructor ha sido diseñado de modo tal que recibe las variables que se asignarán a los atributos.

Además del constructor también se ha diseñado el método mostrarDatos() que permite ver los datos de la persona.

En la clase Ejemplo1 podemos ver que se crea el objeto Persona y luego, mediante un control JOptionPane (de la librería Swing de Java) se muestran los datos.

Aquí es importante entender que tanto los atributos como los métodos de la clase Persona están afectados por calificadores de acceso o visibilidad, que veremos a continuación.

Figura 1: ejecución Ejemplo1.java

Los calificadores de acceso: private, protected, public y package

¿Qué significa que un atributo sea privado?: quiere decir que el atributo sólo podrá ser accesible por un método de la clase; es decir, son sólo visibles para la clase.

Con el calificador protected, los atributos sólo son visibles para la clase y clases hijas.

El calificador package es el utilizado por omisión si no se especifica otro y la visibilidad abarca a todas las clases del mismo paquete.

El calificador public implica que los miembros de una clase son visibles desde cualquier código. Prof

. Lau

ra N

ouss

an L

ettry



Vamos a crear otro ejemplo con la Clase Persona, donde vamos a tener dos constructores, el anterior y uno que aparentemente no hace nada, pero sí que hace: construye el objeto con los valores que hemos inicializado los atributos. Para que no haya problemas, hemos creado las clases Persona.java y Ejemplo2.java en otro paquete:

Archivo Persona.java

1 package TOI_2013.ejemplo2; 2 3 /** 4 * 5 * @author Laura Noussan Lettry 6 */ 7 class Persona { 8 //atributos 9 private String apellido=""; 10 private String nombre=""; 11 private String fecha_nac=" / / "; 12 private int documento=0; 13 14 //métodos 15 //constructores 16 Persona(){ 17 18 } 19 Persona(String a,String n,String f, int d){ 20 apellido=a; 21 nombre=n; 22 fecha_nac=f; 23 documento=d; 24 } 25 26 String mostrarDatos(){ 27 return "Los datos de la Persona son:\n " 28 + "Apellido: "+this.apellido.toString()+ 29 "\n Nombre: "+this.nombre.toString()+ 30 "\n Fecha de Nacimiento: "+this.fecha_nac.toLowerCase()+ 31 "\n Documento: "+this.documento; 32 } 33 }//fin clase Persona

archivo Ejemplo2.java

1 package TOI_2013.ejemplo2; 2 import javax.swing.JOptionPane; 3 4 /** 5 * 6 * @author Laura Noussan Lettry 7 */ 8 class Ejemplo2 { 9 10 /** 11 * @param args the command line arguments 12 */ 13 public static void main(String[] args) { 14 15 Persona Desconocida= new Persona(); 16 JOptionPane.showMessageDialog(null ,Desconocida.mostrarDatos(),"Mensaje 1",1 ) ; 17 Persona Martin = new Persona("Carrera","Martin","12/05/1996",43000000); 18 JOptionPane.showMessageDialog(null,Martin.mostrarDatos(),new String("Mensaje 2"),1 ) ; 19 20 } 21 }//fin clase Ejemplo2 Pr

of. L

aura

Nou

ssan

Let

try



Además de crear otro constructor en la Clase Persona también hemos quitado los calificadores de acceso public de la clase y de los métodos; salvo el método principal de la aplicación. Por lo tanto, por omisión, la clase Persona y la clase Ejemplo2 utilizan el calificador Packaged

También hemos usado una variante más elaborada de la clase JOptionPane que nos permite agregarle un título al mensaje:

� JOptionPane.showMessageDialog(null ,Desconocida.mostrarDatos(),"Mensaje 1",1 )

� JOptionPane.showMessageDialog(null,Martin.mostrarDatos(),new String("Mensaje 2"),1 )

El número 1, al final de la lista de argumentos, significa que la ventana será del tipo Información con un ícono “I”. Pueden consultar la documentación de java o bien probar con otros números.

En la siguiente figura se muestra las dos ventanas que se muestran al ejecutar el programa.

Figura 2: ejecución de Ejemplo2.java

Herencia y Polimorfismo en Java

Vamos a utilizar otro ejemplo para poder mostrar en forma clara qué es la herencia y qué es el polimorfismo.

Herencia

La HERENCIA es una de las relaciones que se pueden dar entre clases. Otras relaciones que se pueden dar son la DEPENDENCIA y la AGREGACIÓN.

Ahora veremos solamente la herencia.

Para entender qué es la HERENCIA vamos a crear una clase llamada VehiculoTerrestre, y otras cuatro clases más llamadas Auto, Moto, Carreta y Cuatriciclo.

La lógica nos indica que tanto un auto como una moto o un cuatriciclo son vehículos a motor, por lo tanto tendrán un motor; en cambio la carreta no tiene motor. Esta ya es una diferencia entre las clases hijas.

La clase madre tendrá en principio tres atributos básicos: patente, color y cantidad de ruedas (ya que todo vehículo terrestre tiene ruedas).

La clases hijas a su vez tendrán atributos que las identifican como una auto, como un cuatriciclo, o como una moto o una carreta. Una de ellas es la cantidad de ruedas, pero supondremos que la carreta no tiene patente.

La idea es que una moto tiene dos ruedas y un auto cuatro ruedas, pero me dirán un cuatriciclo también tiene cuatro ruedas. ¡¡Sí!!, tiene los mismos atributos que un auto salvo porque no tiene techo ni ventanas. ¡¡Sí!!, entonces se podría pensar que un cuatriciclo hereda esos atributos de un auto!! Pues No!!. Aquí viene lo importante de la POO: se trata de hacer una abstracción de la realidad, no de forzar la realidad para tener una abstracción para usar la herencia sólo para heredar métodos. Lo que corresponde para un cuatriciclo es considerar que no tiene techo, en todo caso y no se puede decir, en lenguaje coloquial que un cuatriciclo es un auto ¿no? Por eso es que

¡¡NO HAY QUE USAR LA HERENCIA DE CUALQUIER MANERA!!

Así pues tenemos dos alternativas claras: el atributo que represente si el objeto tiene techo o no, puede estar en la clase Cuatriciclo o en la clase VehiculoTerrestre. Lo más práctico es que esté en la clase madre, en realidad. Los vehículos a motor tendrán o no techo, dependiendo del tipo de vehículo. Es lo más realista.

Lo más fácil es elegir la primera opción, más que nada por cuestiones didácticas.

Veamos la clase madre: archivo VehiculoTerrestre.java Prof

. Lau

ra N

ouss

an L

ettry



Archivo VehiculoTerrestre.java

1 package ejemplo3; 2 3 /** 4 * 5 * @author Laura Noussan Lettry 6 */ 7 public class VehiculoTerrestre { 8 //atributos 9 protected String patente; 10 protected String color; 11 protected int ruedas; 12 protected boolean techo; 13 //métodos 14 //constructor 15 public VehiculoTerrestre(String p, String c, int r,boolean t){ 16 patente=p; 17 color=c; 18 ruedas=r; 19 techo=t; 20 } 21 public String getPatente(){ 22 return this.patente; 23 } 24 public String mostrarDatos(){ 25 return new String("Patente: "+getPatente()+"\n Color: "+this.color+ 26 "\n Cantidad de Ruedas: "+this.ruedas); 27 } 28 public String soyUn(){ 29 String cadena; 30 switch (this.ruedas){ 31 case 2: 32 if(this.patente.equals("")) 33 cadena = new String("Soy una CARRETA"); 34 else 35 cadena=new String("Soy una MOTO"); 36 break; 37 case 3: 38 cadena = new String("Soy un TRICICLO"); 39 break; 40 case 4: 41 if(this.techo) 42 cadena = new String("Soy un AUTO"); 43 else 44 cadena =new String("Soy un CUATRICICLO"); 45 break; 46 default: 47 cadena = new String("SOY UN OVNI"); 48 49 }//fin switch 50 51 return cadena; 52 }//fin soyUn() 53 }//fin clase VehiculoTerrestre

En cuanto a las clases hijas, las transcribimos a continuación:

Archivo Auto.java

1 package ejemplo3; 2 3 /** 4 * 5 * @author Laura Noussan Lettry 6 */ 7 public class Auto extends VehiculoTerrestre { 8 //atributos

Prof

. Lau

ra N

ouss

an L

ettry



9 private boolean motor; 10 private int puertas; 11 //métodos 12 //constructor 13 public Auto(String pat, String c, int r,int p){ 14 super(pat,c,r,true);//suponemos que un auto tiene techo 15 motor=true; 16 puertas=p; 17 18 } 19 @Override//sobreescribe al mismo método con el mismo nombre de la clase madre 20 public String mostrarDatos(){ 21 String cadena1 =super.mostrarDatos(); //va a mostrar los datos del vehículo 22 //esta es para los datos del auto 23 String cadena2="\n tiene Motor: "+this.motor+ 24 "\n y tiene: "+this.puertas+" puertas."; 25 return cadena1+cadena2; 26 } 27 28 }//fin clase auto

El archivo Moto.java

1 package ejemplo3; 2 3 /** 4 * 5 * @author Laura Noussan Lettry 6 */ 7 public class Moto extends VehiculoTerrestre { 8 //atributos 9 private boolean motor; 10 //métodos 11 //constructor 12 public Moto(String p, String c, int r){ 13 super(p,c,r,false);//una moto no tiene techo 14 motor=true; 15 16 } 17 @Override//sobreescribe al mismo método con el mismo nombre de la clase madre 18 public String mostrarDatos(){ 19 String cadena1 =super.mostrarDatos(); //va a mostrar los datos del vehículo 20 //esta es para los datos de la moto 21 String cadena2="\n tiene Motor: "+this.motor; 22 return cadena1+cadena2; 23 } 24 25 }//fin clase Moto

El archivo Cuatriciclo.java

1 package ejemplo3; 2 3 /** 4 * 5 * @author Laura Noussan Lettry 6 */ 7 public class Cuatriciclo extends VehiculoTerrestre { 8 //atributos 9 private boolean motor; 10 11 //métodos 12 //constructor 13 public Cuatriciclo(String p, String c, int r){ 14 super(p,c,r,false);//un cuatriciclo no tiene techo 15 motor=true; 16 Pr

of. L

aura

Nou

ssan

Let

try



17 } 18 @Override//sobreescribe al mismo método con el mismo nombre de la clase madre 19 public String mostrarDatos(){ 20 String cadena1 =super.mostrarDatos(); //va a mostrar los datos del vehículo 21 //esta es para los datos del cuatriciclo 22 String cadena2="\n y tiene Motor: "+this.motor; 23 return cadena1+cadena2; 24 } 25 26 }//fin clase Cuatriciclo

El archivo Carreta.java

1 package ejemplo3; 2 3 /** 4 * 5 * @author Laura 6 */ 7 public class Carreta extends VehiculoTerrestre { 8 //atributos 9 private boolean motor; 10 //métodos 11 //constructor 12 public Carreta(String pat, String c, int r){ 13 super(pat,c,r,false);//la carreta no tiene techo 14 motor=false; 15 16 } 17 @Override//sobreescribe al mismo método con el mismo nombre de la clase madre 18 public String mostrarDatos(){ 19 String cadena1 =super.mostrarDatos(); //va a mostrar los datos del vehículo 20 //esta es para los datos de la carreta 21 String cadena2="\n tiene Motor: "+this.motor; 22 return cadena1+cadena2; 23 } 24 }//fin clase carreta

La palabra reservada this (este) hace referencia al atributo o método del objeto actualmente en ejecución.

La palabra reservada extends (extiende en español) es la que permite definir a una clase como hija de otra, ya que extiende tanto sus métodos como sus atributos.

La palabra reservada super(argumentos) permite pasar al constructor de la clase madre los valores de los atributos

El método mostrarDatos() está presente tanto en las clases hijas como en la clase madre. Dicho método de la clase madre lo que hace es mostrar información del objeto madre; y en las clases hijas se llama a método del mismo nombre pero de la clase.

En las clases hijas el método está sobrescribiendo al de la clase madre, de allí que se diga que redefine o se sobrescribe e método. Esto se indica con la siguiente cláusula: @Override (ver la línea de código 17 ó 18, según el archivo de las clases hijas)

Polimorfismo en Java

Este método mostrarDatos, presente en todas las clases, es un claro ejemplo de Polimorfismo. Es fácil entender el por qué no hay ambigüedad cuando se ejecuta el programa; simplemente dichos métodos, con el mismo nombre, forman parte de una clase particular; y por lo tanto, cuando el objeto en cuestión se crea, están encapsulados tanto sus atributos como sus métodos. Esto no es posible en la programación estructurada.

El calificador de acceso protected

Para que la herencia pueda funcionar es necesario que archivos externos a la clase VehiculoTerrestre puedan acceder a sus atributos, para lo cual es necesario que dichos atributos estén declarados con éste. Pr

of. L

aura

Nou

ssan

Let

try



De esta manera, las clases hijas pueden acceder a los atributos de la clase madre, de lo contrario, no se podría (con el calificador private) y no tendría sentido por cuestiones de seguridad utilizar el calificador public en dichos atributos. Si así hiciéramos, cualquier otra clase y no sólo las hijas e inclusive clases de otros paquetes podrían acceder a los atributos.

Las clases hijas son clases externas a la clase VehiculoTerrestre, pero todas forman parte del mismo paquete, este es otro de los requisitos.

Un paquete reúne clases vinculadas y puede considerarse como una carpeta o directorio.

Finalmente falta la clase runtime. Declarada en el archivo ejemplo3.java

1 package ejemplo3; 2 3 import javax.swing.JOptionPane; 4 5 /** 6 * 7 * @author Laura 8 */ 9 public class Ejemplo3 { 10 /** 11 * @param args the command line arguments 12 */ 13 public static void main(String[] args) { 14 15 VehiculoTerrestre V1 = new Auto("GEP022","BLANCO",4,3); 16 VehiculoTerrestre V2 = new Moto("EWKJ36","ROJO",2); 17 VehiculoTerrestre V3 = new Carreta ("","GRIS",2); 18 VehiculoTerrestre V4 = new Cuatriciclo ("AAIW77","AMARILLO",4); 19 JOptionPane.showMessageDialog(null,V1.mostrarDatos(),V1.soyUn(),1 ) ; 20 JOptionPane.showMessageDialog(null,V2.mostrarDatos(),V2.soyUn(),1 ) ; 21 JOptionPane.showMessageDialog(null,V3.mostrarDatos(),V3.soyUn(),1 ) ; 22 JOptionPane.showMessageDialog(null,V4.mostrarDatos(),V4.soyUn(),1 ) ; 23 } 24 }//fin clase ejemplo3

Aquí hemos utilizado otra variante del método showMessageDialog del componente JOptionPane de modo tal que el título de la ventana muestre el tipo de objeto (método soyUn de la clase madre), y que la ventana sea del tipo información (el número 1).

La salida del programa se muestra en la figura 3

Utilización de Formularios y Menús para manipular datos. Paquete Java Swing.

El objetivo de la materia es gestionar bases de datos con Java mediante el API JDBC. Para ello es necesario manejar bien los objetos, ya que las conexiones a bases de datos utilizan objetos Java para

Figura 3: ejecución del programa Ejemplo3.java

Prof

. Lau

ra N

ouss

an L

ettry



manejar los datos que se encuentran en RDBMS, pero también es necesario poder manipular los formularios y menús que obtendrán los datos del usuario o de las consultas que éste haga al RDBMS.

Para encarar la creación de formularios y menús, y poder gestionar una aplicación, utilizaremos para crear la Vista del Usuario el paquete Java Swing.

Formularios en Java

Utilizaremos las mismas clases utilizadas en el ejemplo anterior: Auto, Moto, Carreta, Cuatriciclo y VehiculoTerrestre; lo que cambia es la clase runtime, en realidad, ya que necesitamos gestionar las clases base de otra manera, mediante una aplicación interactiva y visual.

La Clase runtime será un Jframe para crear un Auto, como ejemplo inicial de cómo hay que trabajar con formularios Java.

Cabe aclarar que NetBeans presenta con la librería Swing la facilidad de diseñar gráficamente el formulario y automáticamente agrega el código necesario de los diferentes componentes (Paneles, cuadros de texto, etc.)

Lo primero que hay que hacer es crear un nuevo paquete que llamaré Ejemplo4 y allí copiar las cinco clases antes mencionadas.

Lo segundo es crear un Jframe, que será la clase runtime para crear y mostrar un Auto

Figura 4: creación de un formulario JFrame al que le hemos agregado un Panel y un Botón. Hay que notar que tenemos muchos componentes Swing: contenedores, controles y menús.

Se puede apreciar que el Panel tiene un borde, para lo cual basta con pulsar sobre éste y mediante el botón derecho del ratón seleccionar la opción propiedades dentro del menú desplegable y allí ir a Borde. Algo parecido ocurre con el Botón, hay que modificar las propiedades para colocarle un título apropiado.

Finalmente el Formulario nos quedará como lo muestra la Figura 5.

Según el constructor Auto, pues necesitamos 4 atributos, motivo por el cual necesitamos cuatro cuadros de texto con sus correspondientes labels.

Después, si recordamos el ejemplo anterior, por un lado hay que crear el objeto y por otro queremos mostrar los datos del objeto; esto se logra con los botones.

A continuación hemos copiado el código fuente (el que se puede ver en

Figura 5: Diseño del Formulario para crear un Auto Prof

. Lau

ra N

ouss

an L

ettry



NetBeans, y lógicamente agregar código y/o modificar) pulsando sobre la solapa denominada Source ya que hasta ahora hemos estado en Design

En la vista Diseño del formulario además hemos modificado las propiedades, primero para utilizar nombres de variables que nos indiquen para qué sirven.

En la siguiente figura 6, si hacemos zoom, podremos ver que el JTextField tiene un nombre de variable: patente y un tipo de acceso: private. El tipo de acceso lo coloca NetBeans por omisión pero el nombre de variable también lo coloca por omisión, lo hemos cambiado para que sea coherente con el dato que queremos manipular.

Las clases originales no se modifican para nada!!!.

A continuación se transcribe el código de la clase runtime; es decir la del formulario:

1 package ejemplo4; 2 3 import javax.swing.JOptionPane; 4 import javax.swing.JTextField; 5 6 /** 7 * 8 * @author Laura Noussan Lettry 9 */ 10 public class CrearAuto extends javax.swing.JFrame { 11 12 /** 13 * Creates new form 14 */ 15 public CrearAuto() { 16 initComponents(); 17 } 18 19 /** 20 * This method is called from within the constructor to initialize the form. 21 * WARNING: Do NOT modify this code. The content of this method is always 22 * regenerated by the Form Editor. 23 */ 24 @SuppressWarnings("unchecked") 25 // <editor-fold defaultstate="collapsed" desc="Generated Code"> 26 private void initComponents() { 27

Figura 6: modificar las propiedades de los controles Swing

Prof

. Lau

ra N

ouss

an L

ettry



28 jPanel1 = new javax.swing.JPanel(); 29 patente = new javax.swing.JTextField(); 30 jLabel1 = new javax.swing.JLabel(); 31 jLabel2 = new javax.swing.JLabel(); 32 jLabel3 = new javax.swing.JLabel(); 33 jLabel4 = new javax.swing.JLabel(); 34 color = new javax.swing.JTextField(); 35 cantRuedas = new javax.swing.JTextField(); 36 cantPuertas = new javax.swing.JTextField(); 37 jToggleButton1 = new javax.swing.JToggleButton(); 38 jButton1 = new javax.swing.JButton(); 39 40 setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); 41 setTitle("AUTO"); 42 43 jPanel1.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED)); 44 45 jLabel1.setText("Patente"); 46 47 jLabel2.setText("Color"); 48 49 jLabel3.setText("Cantidad de Ruedas"); 50 51 jLabel4.setText("Cantidad de Puertas"); 52 53 javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1); 54 jPanel1.setLayout(jPanel1Layout); 55 jPanel1Layout.setHorizontalGroup( 56 jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 57 .addGroup(jPanel1Layout.createSequentialGroup() 58 .addContainerGap() 59 .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false) 60 .addGroup(jPanel1Layout.createSequentialGroup() 61 .addComponent(jLabel1) 62 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) 63 .addComponent(patente)) 64 .addGroup(jPanel1Layout.createSequentialGroup() 65 .addComponent(jLabel2) 66 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) 67 .addComponent(color)) 68 .addGroup(jPanel1Layout.createSequentialGroup() 69 .addComponent(jLabel3) 70 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) 71 .addComponent(cantRuedas, javax.swing.GroupLayout.PREFERRED_SIZE, 32, javax.swing.GroupLayout.PREFERRED_SIZE)) 72 .addGroup(jPanel1Layout.createSequentialGroup() 73 .addComponent(jLabel4) 74 .addGap(18, 18, 18) 75 .addComponent(cantPuertas))) 76 .addContainerGap(170, Short.MAX_VALUE)) 77 ); 78 jPanel1Layout.setVerticalGroup( 79 jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 80 .addGroup(jPanel1Layout.createSequentialGroup() 81 .addGap(30, 30, 30) 82 .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) 83 .addComponent(patente, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) 84 .addComponent(jLabel1)) 85 .addGap(18, 18, 18) 86 .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) 87 .addComponent(jLabel2) 88 .addComponent(color, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) 89 .addGap(18, 18, 18) 90 .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) 91 .addComponent(jLabel3) 92 .addComponent(cantRuedas, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))

Prof

. Lau

ra N

ouss

an L

ettry



93 .addGap(18, 18, 18) 94 .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE) 95 .addComponent(jLabel4) 96 .addComponent(cantPuertas, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) 97 .addContainerGap(47, Short.MAX_VALUE)) 98 ); 99 100 jToggleButton1.setText("Crear Auto"); 101 jToggleButton1.addActionListener(new java.awt.event.ActionListener() { 102 public void actionPerformed(java.awt.event.ActionEvent evt) { 103 jToggleButton1ActionPerformed(evt); 104 } 105 }); 106 107 jButton1.setText("Ver Auto"); 108 jButton1.addActionListener(new java.awt.event.ActionListener() { 109 public void actionPerformed(java.awt.event.ActionEvent evt) { 110 jButton1ActionPerformed(evt); 111 } 112 }); 113 114 javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); 115 getContentPane().setLayout(layout); 116 layout.setHorizontalGroup( 117 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 118 .addGroup(layout.createSequentialGroup() 119 .addContainerGap() 120 .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) 121 .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 49, Short.MAX_VALUE) 122 .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false) 123 .addComponent(jToggleButton1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) 124 .addComponent(jButton1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) 125 .addGap(39, 39, 39)) 126 ); 127 layout.setVerticalGroup( 128 layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 129 .addGroup(layout.createSequentialGroup() 130 .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) 131 .addGroup(layout.createSequentialGroup() 132 .addGap(36, 36, 36) 133 .addComponent(jToggleButton1) 134 .addGap(18, 18, 18) 135 .addComponent(jButton1)) 136 .addGroup(layout.createSequentialGroup() 137 .addContainerGap() 138 .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))) 139 .addContainerGap(23, Short.MAX_VALUE)) 140 ); 141 142 pack(); 143 }// </editor-fold> 144 145 private void jToggleButton1ActionPerformed(java.awt.event.ActionEvent evt) { 146 auto = new Auto(obtenerCadena(this.patente),obtenerCadena(this.color),obtenerEntero(this.cantRuedas),obtenerEntero(this.cantPuertas)); 147 } 148 149 private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) { 150 151 JOptionPane.showMessageDialog(null,auto.mostrarDatos() , auto.soyUn(), 1); 152 153 } 154

Prof

. Lau

ra N

ouss

an L

ettry



155 /** 156 * @param args the command line arguments 157 */ 158 public static void main(String args[]) { 159 /* 160 * Set the Nimbus look and feel 161 */ 162 //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) "> 163 /* 164 * If Nimbus (introduced in Java SE 6) is not available, stay with the 165 * default look and feel. For details see 166 * http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 167 */ 168 try { 169 for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) { 170 if ("Nimbus".equals(info.getName())) { 171 javax.swing.UIManager.setLookAndFeel(info.getClassName()); 172 break; 173 } 174 } 175 } catch (ClassNotFoundException ex) { 176 java.util.logging.Logger.getLogger(CrearAuto.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 177 } catch (InstantiationException ex) { 178 java.util.logging.Logger.getLogger(CrearAuto.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 179 } catch (IllegalAccessException ex) { 180 java.util.logging.Logger.getLogger(CrearAuto.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 181 } catch (javax.swing.UnsupportedLookAndFeelException ex) { 182 java.util.logging.Logger.getLogger(CrearAuto.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); 183 } 184 //</editor-fold> 185 186 /* 187 * Create and display the form 188 */ 189 java.awt.EventQueue.invokeLater(new Runnable() { 190 191 public void run() { 192 new CrearAuto().setVisible(true); 193 } 194 }); 195 } 196 // Variables declaration - do not modify 197 private javax.swing.JTextField cantPuertas; 198 private javax.swing.JTextField cantRuedas; 199 private javax.swing.JTextField color; 200 private javax.swing.JButton jButton1; 201 private javax.swing.JLabel jLabel1; 202 private javax.swing.JLabel jLabel2; 203 private javax.swing.JLabel jLabel3; 204 private javax.swing.JLabel jLabel4; 205 private javax.swing.JPanel jPanel1; 206 private javax.swing.JToggleButton jToggleButton1; 207 private javax.swing.JTextField patente; 208 // End of variables declaration 209 210 // atributos que vienen de las clases 211 212 VehiculoTerrestre auto=null; 213 ///métodos propios 214 private int obtenerEntero(JTextField cadena) { 215 return Integer.parseInt(cadena.getText()); 216 } 217 private String obtenerCadena(JTextField cadena){ 218 return cadena.getText(); 219 } 220 221 }

Prof

. Lau

ra N

ouss

an L

ettry



IMPORTANTE

Casi todo el código ha sigo creado por NetBeans, en base al diseño que llevamos a cabo o la configuración que hicimos de las propiedades y eventos que tienen o manejan los diferentes controles y componentes Swing que agregamos al formulario. En particular el código que está sombreado con color gris, no lo podemos modificar en forma directa, sólo cambiando las propiedades del control o componente Swing, lo podemos modificar o bien eliminar.

El código que sí hemos añadido es el siguiente:

• En la línea 212 hemos declarado la variable auto así:

VehiculoTerrestre auto=null;

• De la línea 145/147: es un método que maneja el evento de pulsar el ratón o presionar Enter sobre el primer botón, Crear Auto. La firma del método lo escribe automáticamente el software y deja espacio para que nosotros lo configuremos.

Allí hemos ingresado el código necesario para poder crear el objeto Auto:

Auto = new Auto(obtenerCadena(this.patente),obtenerCadena(this.color),

obtenerEntero(this.cantRuedas),obtenerEntero(this.cantPuertas));

• De la línea 149/153: es un método que maneja el evento del botón Ver Auto y el código que hemos ingresado es compatible con el visto en el ejemplo anterior.

JOptionPane.showMessageDialog(null,auto.mostrarDatos(), auto.soyUn(), 1);

• De la línea 214/219 hemos creado estos dos métodos que nos permiten convertir el contenido de las variables de tipo JTextField (es decir, los cuadros de texto) a String o a int ya que la clase Auto pasa a su clase madre, VehiculoTerrestre, dos atributos que son String y dos atributos que son enteros.

A continuación se muestra la ejecución del programa (el único archivo que es ejecutable es el formulario):

Figura 7: ingresando los datos de un auto para luego apretar el botón CrearAuto

Prof

. Lau

ra N

ouss

an L

ettry



Figura 8: Una vez creado el auto pulsamos el botón VerAuto para ver los datos.

Todo sin modificar una sola línea de las clases que resuelven el problema!! ¿por qué? Pues porque ese problema es resuelto por estas cinco clases que en conjunto representan el algoritmo. En cambio, cómo se capturan los datos, con qué y todo el manejo de eventos puede ser gestionado por un JFrame, por un Applet, por un Jsp, etc.

Creación de una conexión con la API JDBC. Aplicación de SQL-DML a través de Java

En la primera y segunda parte hemos visto qué es un RDBMS y cómo se puede diseñar el modelo de datos y cómo se puede convertir en un diseño físico a través de SQL para crear una base de datos relacional.

La cuarta parte abarcará aspectos conceptuales y prácticos del API JDBC que nos permite conectarnos, mediante la plataforma java, a cualquier RDBMS que haya implementado esta API.

El BrowserSQL que utilizamos para crear las bases de datos vistas con anterioridad se basa en esta API, por eso mismo se pueden no sólo realizar las conexiones a la base de datos, sino aplicar directamente el lenguaje SQL tanto DML como DDL.

Lo que se intenta ahora es mostrar cómo crear una conexión JDBC y cómo devolver una consulta sobre una o más tablas del RDBMS. Ya sabemos, al haber utilizado el BrowserSQL, que JDBC crea un objeto que es la conexión misma y necesita dos cosas básicas: a) el Driver (que el programa lo busca en forma automática) y la cadena de conexión con el usuario y su contraseña.

O sea, por un lado necesitamos crear un objeto conexión, que tendrá un objeto Connection, que pertenece al API JDBC. Así mismo este objeto tiene otros objetos, por ejemplo un objeto Statement que sirve para ejecutar setencias SQL y un objeto ResultSet que devuelve los datos de una consulta. Un objeto Statement sirve tanto para utilizar SQL DDL como SQL DML, el ResultSet devuelve los datos de una consulta,

Con esta API se puede hacer mucho más de lo que vamos a ver aquí: vamos a crear una clase base Conexión con un atributo Connection y vamos a mostrar el resultado de una consulta. Por ahora nada más.

Prof

. Lau

ra N

ouss

an L

ettry



Archivo Conexión.java

1 package toi_conexion; 2 3 import java.awt.HeadlessException; 4 import java.sql.Connection; 5 import java.sql.DriverManager; 6 import java.sql.ResultSet; 7 import java.sql.SQLException; 8 import java.sql.Statement; 9 import java.util.logging.Level; 10 import java.util.logging.Logger; 11 import javax.swing.JOptionPane; 12 /** 13 * @author Laura Noussan Lettry 14 * esta clase maneja la conexión en el nivel más bajo. 15 * Se necesitan importar los paquetes java.sql más importantes 16 * del API JDBC 17 */ 18 public class Conexion { 19 //atributos con los que vamos a crear un objeto Connection 20 private Connection conn=null;//variable que maneja la conexion 21 //constructor 22 public Conexion(String driver, String cadena, String usuario, String clave){ 23 //primero setear el Driver 24 //pero tenemos que usar excepciones, no hay otra 25 try{ 26 String controlador = new String(driver); 27 Class.forName(controlador).newInstance(); 28 //si ya tenemos el controlador instanciado podemos crear la conexión 29 try{ 30 conn=DriverManager.getConnection(cadena,usuario,clave); 31 JOptionPane.showMessageDialog(null,"Conectado!!","Información",1 ) ; 32 33 }//fin try por conexion ya establecido el driver 34 catch (SQLException | HeadlessException e){ 35 String mensajeExcepcion="Error al realizar la Conexión: \n"+ 36 e.getMessage()+ 37 "\nLocalización: "+ 38 e.getLocalizedMessage(); 39 JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepción !!",1 ) ; 40 } 41 }//fin try por Driver 42 catch(ClassNotFoundException | InstantiationException | IllegalAccessException e){ 43 String mensajeExcepcion="Error al cargar el controlador: \n"+ 44 e.getMessage()+ 45 "\nLocalización: "+ 46 e.getLocalizedMessage(); 47 JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepción !!",1 ) ; 48 } 49 }//fin constructor 50 public void Desconectar(){ 51 try { 52 if(conn != null){ 53 conn.close(); 54 String mensaje="Desconectado!!"; 55 JOptionPane.showMessageDialog(null,mensaje,"Información",1 ) ; 56 }//fin if 57 }//fin try 58 catch (SQLException | HeadlessException e){ 59 String mensajeExcepcion="Error al Desconectar: \n"+ 60 e.getMessage()+ 61 "\nLocalización: "+ 62 e.getLocalizedMessage(); 63 JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepciñon !!",1 ) ; 64 65 }//fin catch 66 }//fin método Desconectar()

Prof

. Lau

ra N

ouss

an L

ettry



67 public String mostrarSQL(String cadena){ 68 String miConsulta=""; 69 try { 70 Statement sql = conn.createStatement(); //se crea un Statement para la conexión 71 sql.executeQuery(cadena); //se ejecuta la consulta 72 ResultSet r=sql.getResultSet(); //se obtiene el resultado de la consulta 73 String tupla[]= new String [2];//para tomar los datos del resultset 74 75 String titulos[]= new String[2];//para mostrar los títulos de la consulta 76 titulos[0]="Id materia"; 77 titulos[1]="nom_materia"; 78 79 while (r.next()){ 80 tupla[0]=r.getString("idmateria"); 81 tupla[1]=r.getString("nom_materia"); 82 miConsulta=miConsulta+"\n"+ 83 tupla[0]+" | "+tupla[1]; 84 }//fin while 85 //ahora agregamos los titulos al comienzo de la cadena 86 miConsulta=titulos[0]+" | "+titulos[1]+"\n"+ 87 miConsulta; 88 89 }//fin try 90 catch (SQLException ex) { 91 Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex); 92 } 93 return miConsulta; 94 }//fin método mostrarSQL()

Como podemos apreciar en varias partes del código se ha tenido que utilizar excepciones. Cualquier conexión y operaciones SQL requerirán siempre del uso de excepciones, por lo general SQLException del paquete java.sql.Exception.

La explicación del código es la siguiente:

El constructor crea un objeto Conexión cuyo único atributo es una variable de tipo Connection de la API JDBC. Como puede verse en el código hay un bloque TRY anidado dentro de otro. Esto es porque lo primero que hay que hacer es establecer el Driver JDBC con el que se quiere conectar. La clase del Driver depende del RDBMS con el que nos vamos a conectar. Si este bloque faya, directamente se lanza la excepción y no se crea la conexión. Si este bloque TRY es exitoso se pasa al siguiente bloque TRY donde se pasan las variables necesarias para establecer la conexión con el RDBMS. Si no se puede establecer la conexión, entonces se ejecuta el bloque CATCH que captura la Excepción SQL.

El método desconectar() es simple de entender: si existe la conexión, pues la desconecta.

El método mostrarSQL(String cadena) trabaja sobre dos objetos diferentes del objeto conn, que es de tipo Connection:

1. Ejecutar la sentencia SQL mediante un objeto Statement (es un objeto el objeto Connection), y

2. Consultar al objeto ResultSet (también otro objeto de un objeto Connection) y con él construir una cadena que es devuelta para su posterior tratamiento. Veremos que la cadena se usa después en el runtime.

El archivo runtime o aplicación que hemos creado se llama TOI_conexion y no utiliza formularios sino sólo código.

Archivo TOI_conexion.java

1 package toi_conexion; 2 import javax.swing.JOptionPane; 3 4 /** 5 * Runtime para conectarse a dos DBMS utilizando la clase Conexion.java 6 * @author Laura Noussan Lettry 7 */ 8 public class TOI_conexion{ 9 /** 10 * @param args the command line arguments 11 */ 12 public static void main(String[] args) {

Prof

. Lau

ra N

ouss

an L

ettry



13 //variables para los drivers de ambos RDBMS 14 String driverMySQL ="com.mysql.jdbc.Driver"; 15 String driverSQLServer ="com.microsoft.sqlserver.jdbc.SQLServerDriver"; 16 //cadenas de conexion al servidor y puerto de cada RDBMS para conectarse a Escuela 17 String cadenaMySQL ="jdbc:mysql://localhost:3306/escuela"; 18 String cadenaSQLServer ="jdbc:sqlserver://localhost:1433;databaseName=escuela"; 19 //cadenas de nombre de usuario 20 String usMySQL="root"; 21 String usSQLServer="sa"; 22 //cadena de la contraseña 23 String claveMySQL="lacontrasenia"; 24 String claveSQLServer="lacontrasenia"; 25 //la consulta que vamos a hacer en los 2 DBMS es 26 String consulta="SELECT * FROM MATERIAS"; 27 28 //conectarse a MySQL 29 Conexion mysql = new Conexion(driverMySQL,cadenaMySQL,usMySQL,claveMySQL); 30 String resultadoMySQL=mysql.mostrarSQL(consulta); 31 JOptionPane.showMessageDialog(null,resultadoMySQL,"Consulta Materias en MySQL!",1 ) ; 32 33 //conectarse a SQLServer 34 Conexion sqlserver = new Conexion(driverSQLServer,cadenaSQLServer,usSQLServer,claveSQLServer); 35 String resultadoSQLServer=sqlserver.mostrarSQL(consulta); 36 JOptionPane.showMessageDialog(null,resultadoSQLServer,"Consulta Materias en SQL Server!",1 ) ; 37 38 //AHORA DESCONECTAMOS 39 mysql.Desconectar(); 40 sqlserver.Desconectar(); 41 }//fin main

El código está explicado en el mismo programa. Para ejecutarlo directamente en otro equipo, pues se deben cambiar los valores de las cadenas de conexión, la cadena de usuario y la contraseña. La cadena del Driver no es necesario cambiarla.

Otro aspecto importante es que en NetBeans debemos seleccionar las librerías JDBC para cada driver, como se aprecia en la imagen. En el BrowserSQL en la carpeta Lib, se encuentran los drivers JDBC de estos dos DBMS; o bien se puede bajar el de SQL Server desde la web ya que el de MySQL viene dentro del paquete Java, pero hay que linkearlo en la carpeta Libraries del proyecto.

En la figura 10 se muestra la salida del programa cuando es ejecutado.

Figura 9: no olvidar los Drivers JDBC o librerías necesarias

Figura 10: el programa muestra los datos de la tabla Materias Prof

. Lau

ra N

ouss

an L

ettry



Pr

of. L

aura

Nou

ssan

Let

try

Education

Pooabd api jdbc_1_lnl_facebook