POOABD (POO Aplicada a B Datos) - API JDBC parte 2 -2020

PROGRAMACIÓN ORIENTADA A OBJETOS
PROGRAMACIÓN ORIENTADA A OBJETOS
APLICADA A BASES DE DATOS
APLICADA A BASES DE DATOS
Por
LAURA NOUSSAN LETTRY
JDBC – Java Database Connectiviy
Parte 2
Aviso Legal
El presente libro electrónico
se distribuye bajo
Attribution-NonCommercial-
NoDerivs 3.0 Unported
2013-2020

PROGRAMACIÓN III - POO APLICADA A BASES DE DATOS
ÍNDICE
JDBC (Java Database Connectivity) – PARTE 2
Introducción
1. Excepciones en Java. Concepto. Bloques Try y Catch.
2. API JDBC. El Controlador JDBC, concepto, características y clases
principales.
3. Aplicación Didáctica – Vista de Negocio: Clases Base y paquete
CORE
4. Aplicación Didáctica – Vinculando todo: a través de una ABM y
una Consulta
2
2
4
5
14
FUENTES Bibliográficas Consultadas
 Documentación Java en general:
 The Java tutorial: https://docs.oracle.com/javase/tutorial/
 Documentación sobre Swing:
 https://docs.oracle.com/javase/tutorial/uiswing/index.html
 API JDBC:
 https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/
 https://docs.oracle.com/javase/tutorial/jdbc/basics/
 https://docs.oracle.com/javase/tutorial/jdbc/overview/
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.
ACTIVIDADES
Parte 1 Lectura, trabajos y prácticas propuestas en el Website de la
Materia y autoevaluaciones disponibles en el aula virtual
(*): website de la materia: https://lnoussanl.org/javabd/
Profesora Lic. Laura Noussan-Lettry Página 1

JDBC - Java Database Connectivity – PARTE 2
INTRODUCCIÓN
Como ya saben, 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
paquete java.sql. Asimismo en la actualidad está presente en los diferentes entornos o
plataformas de desarrollo: JavaSE, JavaME y JavaEE.
En esta parte abordamos el estudio del API JDBC, los diferentes tipos que existen de
controladores JDBC; el manejo de excepciones y continuaremos con las diferentes vistas
que existirán en la aplicación didáctica, en particular la de negocio para darle un rápido
análisis a las clases de este paquete que son los que se comunican con el API JDBC y
con las clases bases de la aplicación vistas al final de la primera parte.
Como ya vimos en la primera parte, el uso del API JDBC no implica modificar las clases
bases que mapean a las tablas, pero sí implica crear la estructura de clases necesarias
que van a comunicarse con el API, que es lo que hace el paquete javabd_mapeo.core.
La imagen siguiente ahora indica el nombre del paquete. Las clases base, son las
indicadas en amarillo y configuran un nexo entre los formularios a nivel de capa de
aplicación y la capa de negocio, que pude considerarse un middleware desarrollado por
nosotros, que permite gestionar la complejidad de los datos y el manejo de excepciones
en el nivel más bajo posible de esta arquitectura en lugar de hacerlo en el nivel de la capa
de aplicación.

1
1-
- EXCEPCIONES EN JAVA. Concepto. Bloques Try y Catch
EXCEPCIONES EN JAVA. Concepto. Bloques Try y Catch.
.
Concepto.
Las Excepciones en Java son eventos que se producen durante la ejecución del programa y donde se
produce la interrupción del flujo normal de instrucciones. Este sería el concepto básico de lo que es una
excepción.
En java además las excepciones son objetos que tienen una jerarquía. La clase principal es la clase
Throwable que es hija directa de la clase Object.
En la POO hay que tener siempre presente que los métodos están definidos dentro de las clases
juntamente con los atributos; por lo tanto, cualquier problema que se presente en tiempo de ejecución,
se origina en un método.
Para manejar estos eventos es que Java tiene una estructura de clases que crean objetos de tipo
Exception y que se pueden o deben utilizar dentro del código para poder manejar estos eventos
inesperados.
El Tutorial Java expresa al respecto: “Cuando se produce un error dentro de un método, el método crea
un objeto y se lo entrega al runtime system. El objeto, llamado un objeto de excepción, contiene
información sobre el error, incluyendo su tipo y el estado del programa cuando se produjo el error. La
creación del objeto de excepción y su entrega al runtime system, es lo que se denomina lanzar una
excepción.”[1]
Después de lanzarse la excepción, el sistema en ejecución (runtime system) intentará manejarlo, es decir
procesar el error para que el programa no se cuelgue. Para manejarlo el runtime system se basa en la
pila de llamadas (una lista ordenada de los métodos que habían sido llamados con anterioridad al método
donde se produjo la excepción)
Figura 1: Pila de llamadas ante un error
La imagen de la Figura anterior nos muestra la pila de llamadas, desde el iniciador del programa
(rectángulo inferior) hasta el método donde se produjo el error. La lista roja típica (que por ejemplo
muestra Netbeans en su salida) cuando se produce un error, pues nos indicará otros métodos que han
sido llamados, y que pueden o no tener manejadores de excepciones.
Bloques try y catch
La documentación es bastante clara: un código Java es válido en la medida que incluya el manejo de
excepciones donde debe incluirse. Esto implica que cuando programamos con Java debemos analizar
nuestro código y detectar aquél que podría arrojar excepciones. Por ejemplo, el manejo de datos es un
caso típico (basta ir a la documentación java para darse cuenta) el uso de archivos es otro ejemplo típico.
¿Qué pasa si un usuario ingresa un nombre de archivo que no existe? Pues si está previsto que esto
puede ocurrir, el sistema no se colgará si se ha previsto la excepción.
El código que puede generar una excepción debe ir incluido dentro de un bloque try. Este bloque debe ir
seguido de uno o más bloques catch. Cada uno de los métodos o bloques catch debe especificar el tipo de

excepción que puede atrapar y un manejador de eventos. Después del último bloque catch puede ir un
bloque finally que es opcional y contiene código que siempre se ejecutará, sea que haya ocurrido o no
una excepción.
try {
código
}
catch (ExceptionType1 var_Name) {
código
}
catch (ExceptionType2 var_Name) {
código
}
finally{
código
}
También podemos utilizar la sentencia Throws que que nos permitiría lanzar una Excepción creada por
nosotros mismos y que queremos controlar mediante nuestro propio código.
2
2-
- API JDBC. El Controlador JDBC, concepto, características y clases
API JDBC. El Controlador JDBC, concepto, características y clases
principales
principales
The Java Database Connectivity (JDBC)
El API JDBC (Java Database Connectivity) es el estándar de la industria para la conectividad
independiente entre el leguaje de programación Java y un amplio rango de bases de datos basadas en
SQL, así como otros orígines de datos de tipos tabulares, como son por ejemplo las hojas de cálculo o los
archivos planos.
El API JDBC nos posibilita tres cosas:
1) establecer una conexión con una base de datos o con un orígen de datos tabular
2) Enviar sentencias SQL
3) Procesar los resultados.
La arquitectura del API JDBC
El API tiene dos conjuntos principales de interfaces. El primer conjunto está dirigido a los programadores
y el segundo conjunto, que es de más bajo nivel, a aquellos que escriben los drivers o controladores para
el API.
Nosotros, como programadores, utilizamos el conjunto de interfaces y objetos de nivel superior; en
cambio Oracle, IBM o Microsoft, empresas que han escrito controladores JDBC para sus bases de datos (y
los han escrito lógicamente en Java) han tenido que utilizar el conjunto de interfaces de más bajo nivel.
Por esto mismo, por ejemplo, si instalamos MySQL 8 Community Edition, que viene con importantes
cambios respecto a la versión 5.7 que se viene usando desde hace años (la 5) pues implicó que varias
empresas, incluida Oracle, tuvieran que cambiar los Drivers JDBC.
Las aplicaciones (de escritorio o las web) así como los Applets (aunque en este caso no es recomendable
por cuestiones de seguridad [1]) a través de los drivers o controladores JDBC. A los drivers JDBC se los
puede categorizar en 4 clases:
Tipo 4: Direct-to-Database Pure Java Driver
Este tipo de driver convierte las llamadas JDBC a las sentencias de protocolo utilizados directamente por
el DBM, por lo tanto las llamadas o mensajes son directos entre la máquina cliente y el DBMS. Es lo más
práctico para el acceso

Tipo 3: Pure Java Driver for Database Middleware
Driver JDBC para Middleware. Este tipo de driver traduce las llamadas JDBC al protocolo utilizado por el
software middleware del vendedor. Es decir, aquí hay un paso intermedio, a través del servidor
middleware, pero también es un controlador JDBC puro.
Tipo 2: Native API partly Java technology-enabled driver
Este tipo de driver convierte las llamadas JDBC en el lado del API cliente de la base de datos (Oracle,
Sybase, Informix, DB2 y otros DBMS). Como en el siguiente caso, este tipo de controlador requiere que
parte del código binario cargado en cada máquina cliente.
Tipo 1: JDBC-ODBC Bridge plus ODBC Driver
El Driver JDBC ODBD provee acceso JDBC a través de los drivers ODBC; aquí la comunicación no solo no
es directa sino que se tiene que manejar un Puente, donde el código binario ODBC tiene que ser cargado
en cada máquina cliente que utilice el driver JDBC-ODBC. La plataforma Java desde sus inicios ofrece un
driver PUENTE JDBC-ODBC que se suele utilizar en situaciones experimentales y cuando el proveedor de
la base de datos no ha provisto un driver para Java. Este es el caso, por ejemplo, si queremos conectar
una aplicación Java a una planilla Excel o a una base de datos Access [2]
- - - - - - - - - - - - - - - -
[1]: los Applets fueron muy utilizados al comienzo de Java pero paulatinamente se dejaron de usar y
ciertamente las últimas versiones de Java,con Oracle,ya no los soportan.
[2]: ciertamente ya no está soportado desde hace varios años el controlador JDBC-ODBC. Si quisiéramos
conectarnos a Access tendríamos que usar un plugin.
3- Aplicación Didáctica – Vista de Negocio: Clases Base y paquete
3- Aplicación Didáctica – Vista de Negocio: Clases Base y paquete
javabd_mapeo.core (o paquete CORE)
javabd_mapeo.core (o paquete CORE)
Las clases base son las que mapean las tablas y juntamente con el paquete Core se comunican con el API
JDBC. Las clases de este paquete son realmente gestionadoras del API-JDBC, de modo tal que toda la
complejidad del manejo de excepciones (que necesariamente se tienen que prever) está en el nivel de
negocio,en el más bajo posible y no en el nivel de aplicación.
Podemos apreciar que tenemos varios paquetes. Nos
interesan particularmente el de la aplicación principal:
app_escuela_2020_vers1 (contiene las clases bases y las
clases de nivel de aplicación) y el paquete
javabd_mapeo.core.
Este último es el paquete que gestiona el manejo de la
conexión de la base de datos y sus operaciones
Las clases del paquete javabd_mapeo.core son dos:
 Conectar.java
 UsarConexion.java
Ciertamente los nombres de las clases, como siempre
debería ser, pues lo dicen todo.
la clase Conectar es la clase que permite poder establecer
la conexión con el DBMS, la clase UsarConexion, utiliza
justamente la conexión para poder realizar
actualizaciones en la base de datos y consultas. Por ello
esta última clase se puede considerar una clase
sugestionadora de la conexión.
Figura 2: Paquete javabd_mapeo.core y sus clases
Para los prácticos es preciso agregar este paquete a cada proyecto

Paquete javabd_mapeo.core- Clase Conectar
A continuación se lista el código de la clase principal del paquete, la que permite establecer la conexión
con la base de datos
 Archivo Conectar.java
1 package javabd_mapeo.core;
2
3 import java.awt.HeadlessException;
4 import java.sql.Connection;
5 import java.sql.DriverManager;
6 import java.sql.SQLException;
7 import javax.swing.JOptionPane;
8
9 /**
10 *
11 * @author Laura Noussan Lettry <laura@lnoussanl.org>
12 * @Name Conectar
13 * @Created ON 23/02/2013
14 * @Created ON 14/05/2014 (actualizado)
15 * pertenece a javabd_mapeo_core version 2 - 2014
16 * @Created ON 29/08/2020 (actualizado) para mejorar el código
17 */
18
19 public class Conectar {
20 //atributos con los que vamos a crear un objeto Connection
21 private static Connection conn=null;//variable que maneja la conexion
22
23 //constructor
24 public Conectar(String driver, String cadena, String usuario, String clave){
25 //primero setear el Driver
26 //pero tenemos que usar excepciones, no hay otra
27 try{
28 String controlador = driver;
29 Class.forName(controlador).newInstance();
30 //si ya tenemos el controlador instanciado podemos crear la conexión
31 try{
32 conn=DriverManager.getConnection(cadena,usuario,clave);
33 JOptionPane.showMessageDialog(null,"Conectado!!","Información",1 ) ;
34
35 }//fin try por conexion ya establecido el driver
36 catch (SQLException e){
37 String mensajeExcepcion="Error al realizar la Conexión: n"+
38 e.getMessage()+
39 "nLocalización: "+
40 e.getLocalizedMessage();
41 JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepción !!",1 ) ;
42 }
43 catch (HeadlessException e){
44 String mensajeExcepcion="Error al realizar la Conexión: n"+
45 e.getMessage()+
49 }
50 }//fin try por Driver
51 catch(ClassNotFoundException e){
52 String mensajeExcepcion="Error al cargar el controlador: n"+
53 e.getMessage()+
Segundo try que
controla el
establecimiento
de la conexión
con el DBMS
Primer try que
controla la existencia
del Driver; es decir
que exista la clase
que llama al
controlador

57 }
58 catch(InstantiationException e){
60 e.getMessage()+
64 }
65 catch(IllegalAccessException e){
67 e.getMessage()+
71 }
72 }//fin constructor
73 public void Desconectar(){
74 try {
75 if(conn != null){
76 conn.close();
77 String mensaje="Desconectado!!";
78 JOptionPane.showMessageDialog(null,mensaje,"Información",1 ) ;
79 }//fin if
80 }//fin try
81 catch (SQLException e){
82 String mensajeExcepcion="Error al Desconectar: n"+
83 e.getMessage()+
87
88 }//fin catch
89 catch (HeadlessException e){
90 String mensajeExcepcion="Error al Desconectar: n"+
91 e.getMessage()+
95
96 }//fin catch
97 }//fin método Desconectar()
98 public static Connection getConexion(){
99 return Conectar.conn;
100 }
101 }
Lo primero que salta a la vista es la extención del constructor llamado lógicamente como la clase, Conectar.
Para poderse establecer la conexión necesitamos controlar todo lo que se pasa al constructor, lo primero es
que exista el Driver JDBC (lo provee cada fabricante de bases de datos SQL que quiera usar Java con su
base e datos).
También salta a la vista la cantidad de excepciones que hay que considerar.
El único atributo es la variable conn que representa a la conexión y que es de tipo Connection además tiene
el calificacor de acceso private y la palabra reservada static
El califidador private es lógico pero ¿por qué el static?
Bueno esto tiene que ver con el hecho de que cada vez que llamamos a la conexión esta es única y global,
lo que tiene sentido en una aplicación de escritorio. En una aplicación web no conviene tener la conexión
abierta sino que se abre cada vez que se necesita realizar una operación sobre la base de datos.
Método para
desconectarse.
Primero chequea que
esté establecida la
conexión. También va
encerrado en un bloque
try-catch.

Static: “Palabra clave del lenguaje de programación Java (TM) que se utiliza para definir una variable como
variable de clase. Las clases mantienen una copia de las variables de clase independientemente de cuántas
instancias existan de esa clase. "static" también se puede utilizar para definir un método como método de
clase. Los métodos de clase son invocados por la clase en lugar de una instancia específica y solo pueden
operar en variables de clase.” (fuente: https://docs.oracle.com/javase/tutorial/information/glossary.htm)
¿Cómo conectarnos al DBMS?
Ya vimos cómo generar el menú principal y cómo activar el método ActionPerformed, así pues ahora
simplemente se explicará el código que está presente en el método de conexión de la aplicación
didáctica. Sin embargo necesitamos contar con una variable de tipo de datos Conectar a nivel de Jframe
de modo tal que se pueda comunicar el menú Conectar a través del método
mnuConectarActionPerformed. También hay que prever la situación de desconectarnos de la base de
datos. En cualquier caso necesitamos una variable que sea de tipo de datos Conectar.
Figura 3: Necesitamos una variable privada de tipo de datos Conectar

Figura 4: Métodos para conectarse y desconectarse de la base de datos MySQL
El método mnuConectarActionPerformed(líneas 188/199) contiene toda la información necesaria para
lograr la conexión:el nombre del Driver JDBC para MySQL,la cadena de conexión, el usuario root de
MySQL y la contraseña.
El código de la línea 198 es el que crea el objeto dela conexión mediante la llamada a la clase Conectar del
paquete core.
El método mnuDesconectarActionPerformed(líneas 201/205) sirve para desconectarnos de la base de
datos. Pregunta si existe el objeto de la conexión y si es así llama al método Desconectar() de la clase
Conectar.
A este nivel, que estamos en el nivel superior y de gestión de la aplicación, no se ha utilizado ningún
bloque try-catch, porque no es necesario. El control de excepciones está en la clase Conectar del paquete
CORE.
Paquete javabd_mapeo.core- Clase UsarConexion
 Archivo UsarConexion.java
1 package javabd_mapeo.core;
2
3 import java.sql.Connection;
4 import java.sql.SQLException;
5 import java.sql.ResultSet;
6 import java.sql.Statement;
7 import java.util.logging.Level;
8 import java.util.logging.Logger;
9 import javax.swing.JOptionPane;
10 import javax.swing.table.DefaultTableModel;
11
12 /**
13 *
14 * @author Laura Noussan Lettry <laura@lnoussanl.org>
15 * @Name UsarConexion
16 * @Created ON 23/02/2013
17 * @Created ON 14/05/2014 (actualizado)
18 * pertenece a javabd_mapeo_core version 2 - 2014
19 * @Created ON 29/08/2020 (actualizado) para mejorar el código

20 */
21
22 public class UsarConexion {
23 Connection miConexion;
24 Statement sentencia=null;
25 ResultSet resultado;
26
27 public UsarConexion(Connection c){
28 this.miConexion=c;
29
30 }
31 //en esta versión retorna un entero, si es mayor a cero indica la cantidad
32 //de registros afectados, si es igual cero quiere decir que no se pudo
33 //llevar a cabo la ABM
34 public int ABM(String cadena){
35 int operacionesHechas=0;
36 try {
37
38 sentencia = miConexion.createStatement();
39 operacionesHechas = sentencia.executeUpdate(cadena);
40 if(miConexion.getAutoCommit()!=true)
41 miConexion.commit();
42
43 } catch (SQLException ex) {
44 String mensajeExcepcion="Error al realizar la ABM: n"+
45 ex.getMessage()+
47 ex.getLocalizedMessage();
49 Logger.getLogger(UsarConexion.class.getName()).log(Level.SEVERE, null, ex);
50 }
51 return operacionesHechas;
52
53 }
54
55 public void Consultar(String cadena){
56 try {
57 sentencia = miConexion.createStatement();
58 sentencia.executeQuery(cadena);
59 resultado = sentencia.getResultSet();
60
62 String mensajeExcepcion="Error al realizar la Consulta: n"+
63 ex.getMessage()+
68 }
69
70 }//fin Consultar
71 public int getCantidadRegistros(){
72
73 int cantFilas=0;
74 try {
75 resultado.last();
76 cantFilas = resultado.getRow();
77 resultado.first();
79 String mensajeExcepcion="Error al devolver la cantidad de columnas: n"+
80 ex.getMessage()+
Método ABM que se usa
en los formularios de
nivel de aplicación.
Simplemente se llama el
método con un único
parámetro: la cadena
SQL de actualización
El constructor: recibo
un objeto Connection,
es decir la conexión
establecida.
Método Consultar que
se usa en los
formularios de nivel de
aplicación, en concreto
para las consultas. Pasa
un único parámetro: la
cadena SQL con el
Select
Los siguientes métodos son específicos del
manejo que se necesita para saber qué
sucedió con la ABM o la consulta o bien
métodos que se aplican a objetos Swing.

85 }
86
87 return cantFilas;
88
89 }
90 public int getCantidadColumnasTabla(){
91 int cantCols=0;
92 try {
93 cantCols=resultado.getMetaData().getColumnCount();
95 String mensajeExcepcion="Error al devolver la cantidad de columnas: n"+
96 ex.getMessage()+
101 }
102 return cantCols;
103 }
104 public String getNombreColumnaTabla(int columna){
105 String nombre="";
106 try {
107 nombre=resultado.getMetaData().getColumnName(columna);
108
110 String mensajeExcepcion="Error al devolver el nombre de la columna: n"+
111 ex.getMessage()+
116 }
117 return nombre;
118 }
119 public String getTipoDatosColumnaTabla(int columna){
120 String nombre="";
121 try {
122 nombre=resultado.getMetaData().getColumnTypeName(columna);
124 String mensajeExcepcion="Error al devolver el nombre de la columna: n"+
130 }
131 return nombre;
132 }
133 public int getTamanioColumnaTabla(int columna){
134 int cantidad=0;
135 try {
136 cantidad=resultado.getMetaData().getColumnDisplaySize(columna);
138 String mensajeExcepcion="Error al devolver el tamaño de la columna: n"+
144 }
145 return cantidad;

146 }
147
148 public String[] getObtenerNombresColumnas(){
149 String nomCols[];
150 int i=0;
151 int cantCols = this.getCantidadColumnasTabla();
152 nomCols=new String[cantCols];
153 for(i=0;i<cantCols;i++){
154 nomCols[i]=new StringBuilder(this.getTamanioColumnaTabla(i+1)).toString();
155 nomCols[i]=this.getNombreColumnaTabla(i+1)+" | ";
156 }
157
158 return nomCols;
159 }//fin getObtenerNombresColumnas
160
161 public String getObtenerDatos(){
162 String datos="";
163 try {
164 int i;
166
167 while (resultado.next()){//el recodrset es una fila con 'n' columnas
168 String fila="";
170 //el contenido o valor de cada atributo
171 fila+=resultado.getString(i+1)+" | ";
172 }//los datos de un registro
173 datos+="n"+fila;
174 }//fin while
175
177 String mensajeExcepcion="Error al leer los datos del RecordSet: n"+
183 }
184 return datos;
185 }//fin getObtenerDatos
186 //método para obtener un arreglo de los datos, o sea, un registro
187 //para modificar o eliminar
188 public String[] getObtenerDatosClave(){
190 String datos[]=new String[cantCols];
191 try {
192 int i;
193 while (resultado.next()){//el recodrset es una fila con 'n' columnas
195 datos[i]= resultado.getString(i+1);
196 }//fin for
197 }//fin while
198
206 }
207 return datos;
208 }//fin getObtenerDatos

209
210 //con JTable
211 public String[] getObtenerNombresColumnasJTable(){
212 String nomCols[];
213 int i=0;
215 nomCols=new String[cantCols];
217 nomCols[i]=new StringBuilder(this.getTamanioColumnaTabla(i+1)).toString();
218 nomCols[i]=this.getNombreColumnaTabla(i+1);
219 }
220
221 return nomCols;
222 }//fin getObtenerNombresColumnasJTable
223
224 //con JTable
225 public DefaultTableModel getObtenerDatosJTable(){
226
227 DefaultTableModel modelo=null;
228 try{
229
230 String tupla[]= new String [this.getCantidadColumnasTabla()];
231 String titulos[]=this.getObtenerNombresColumnasJTable();
232 //crear el modelo y la cabecera de la tabla
233 modelo=new DefaultTableModel(null,titulos);
234 while (resultado.next()){
235 int j=1;
236 for(int i=0;i<tupla.length;i++){
237 tupla[i]=resultado.getString(this.getNombreColumnaTabla(j++));
238 }
239 modelo.addRow(tupla);
240 }
241 }
242 catch (SQLException ex) {
247 JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepción!",1 ) ;
249 }
250 return modelo;
251 }//fin getObtenerDatos2
252 }
En esta clase el constructor lo que hace es pasar la conexión, es decir, la clase tiene tres atributos pero
sólo uno nos interesa: la conexión activa que se asigna a la variable miConexion que tiene tipo de datos
Connection
Las otras dos variables están definidas así:
Statement sentencia=null;
ResultSet resultado;
El tipo de datos de la variable sentencia es Statement, es decir Sentencia SQL que pasaremos al API ya
sea de actualización o consulta.
El tipo de datos de la variable resultado es Resultset, es decir el resultado que devuelve la ejecución de la
sentencia SQL que se aplique.

4
4- Aplicación Didáctica –
- Aplicación Didáctica – Vinculando todo: a través de una ABM y una
Vinculando todo: a través de una ABM y una
Consulta
Consulta
Para comprender cómo funciona la clase UsarConexion veremos un ejemplo tanto de una ABM como de
una Consulta tomando como base la Tabla Materias, que es la más simple. Como además estos temas se
verán más adelante veremos el caso de borrar un registro en la ABM Materias y la consulta general tipo
listado sobre las Materias.
ABM: GesMaterias.java
346 private void btnBorrarActionPerformed(java.awt.event.ActionEvent evt) {
347 //para validar que el usuario esté conectado
348 if(Conectar.getConexion()!=null){
349 //como desabilitamos el txt_idmateria que es lo único que
350 materia = new Materia(convertirShort(this.txt_IdMateria));
351 //la cadena que pasamos al manejador
352 //ojo con los tipo String y que son Varchar en la BD: hay que encerrarlos entre comillas simples
353 //las comillas dobles se usan para unir el String de Java con las variables!
354
355 String cadena="DELETE FROM Materias WHERE Idmateria="+materia.getId();
356 UsarConexion usarLaConexion= new UsarConexion(Conectar.getConexion());
357 //el método ABM devuelve un valor entero si hubo exito sino devuelve 0
358 if( usarLaConexion.ABM(cadena) >0)
359 //mensaje de éxito al modificar
360 MensajeABM_OK();
361 else
362 MensajeABM_Error();
363
364 //habilitar el botón Agregar y buscar, deshabilitamos los otros botones
365 this.btnAgregar.setEnabled(true);
366 this.btnBuscar.setEnabled(true);
367 this.btnBorrar.setEnabled(false);
368 this.btnModificar.setEnabled(false);
369 //volvemos a habilitar el cuadro de la clave primaria
370 this.txt_IdMateria.setEnabled(true);
371
372
373 }//fin if
374 else{
375 JOptionPane.showMessageDialog(rootPane, "Debe conectarse antes al DBMS", "ERROR", 2);
376 }
377
378
379 }
Consulta: ConsuMaterias.java
158 private void btnTodosActionPerformed(java.awt.event.ActionEvent evt) {
159 // Por el tipo de consulta no necesitamos utilizar las clases base de las tablas
160 //primero chequeamos que el usuario esté conectao
161 if(Conectar.getConexion()!=null){
162 String cadena="SELECT * FROM Materias";
163
164 //mandamos la gestión de consulta a un método, así no repetimos código
165 MandarConsulta(cadena);
166 this.btnTodos.setEnabled(false);
167 this.btnExportar.setEnabled(true);
168 if(this.jTableMaterias.isVisible() == false){
169 this.jTableMaterias.setVisible(true);
Se crea la cadena SQL para borrar un registro
(para eso el WHERE es importantísimo) ya que
Java sabe de Java pero no de SQL,
necesitamos restringir con el registro que
queremos borrar
Se crea un objeto Materia lo que
implica que desde el JinternalFrame
estamos llamando a la clase base
Materia.java.
Sólo se pasa el dato del Idmateria que
ingresó el usuario ya que tenemos este
constructor en la clase base.
Se crea el objeto UsarConexion en
la línea 356 y la llamamos
usarLaConexion
En la línea 358 llamamos al método
ABM de dicho objeto pasándole la
cadena SQL anterior.
Se crea la cadena SQL para la
consulta tipo listado general.
Se llama a un método privado dentro
del JinternalFrame (ver abajo)

170 }
171
172 }
173
174 else {
175 MensajeNoConectado();
176 }
177
178
179 }
206 private void MandarConsulta(String cadena){
207 UsarConexion consulta=new UsarConexion(Conectar.getConexion());
208 consulta.Consultar(cadena);
209 modelo = consulta.getObtenerDatosJTable();
210 this.jTableMaterias.setModel(modelo);
211 }
Lo que tiene que quedar claro es que la complejidad de establecer la conexión así como el manejo de los
datos y la comunicación con el API JDBC, y por ende, las excepciones ya que las tablas son archivos, está
programado en las clases gestionadoras de la conexión del paquete javabd_mapeo.core y no al nivel
lógico de la aplicación.
Justamente, para eso sirve separar la vista de negocio de la vista de aplicación. Este código que hemos
descripto corresponde a la vista de aplicación, que llama al código del paquete CORE y que ademas las
clases de nivel superior o nivel de capa de aplicación están en otro paquete.
ver links
Se crea el objeto UsarConexion en
la línea 206 y la llamamos consulta
En la línea 2088 llamamos al método
Consultar de dicho objeto pasándole
la cadena SQL anterior.

POOABD (POO Aplicada a B Datos) - API JDBC parte 2 -2020

Más contenido relacionado

La actualidad más candente

Similar a POOABD (POO Aplicada a B Datos) - API JDBC parte 2 -2020

Último

POOABD (POO Aplicada a B Datos) - API JDBC parte 2 -2020