INTRODUCCIÓN
Primero descargar el controlador
JDBC.
Java Database Connectivity, más conocida por sus siglas JDBC, es una API que permite la ejecución de
operaciones sobre bases de datos desde el lenguaje de programación Java,
independientemente del sistema operativo donde se ejecute o de la base de datos
a la cual se accede, utilizando el dialecto SQL del modelo de base de datos que
se utilice.
Tenemos dos versiones para
descargar, un .exe y otro .tar.gz, ambos son iguales solo que él .exe se
extraerá automáticamente al darle clic.
Una vez lo tengamos lo
descomprimimos y guardamos en una carpeta de nuestra preferencia.
Para que el código
funcione debemos añadir el jdbc que descargamos a nuestro proyecto java.
Hecho esto solo nos falta un paso, debemos habilitar la dll sqljdbc_auth que se encuentra en la carpeta auth x86, x64 según nos convenga.
Lo que debemos hacer es colocar esta dll en
la ruta del sistema para que pueda ser utilizada, hay varias formas para hacer
esto pero la más rápida y sencilla es copiar la dll y pegarla en el directorio
raíz de nuestro proyecto.
Para que esté listo debemos configurar sql server para que admita conexiones remotas, para ello ejecutamos el administrador de configuraciones de sql server, habilitamos TPC/IP y en las propiedades cambiamos el puerto a 1433, deshabilitamos los puertos dinámicos.
Para que esté listo debemos configurar sql server para que admita conexiones remotas, para ello ejecutamos el administrador de configuraciones de sql server, habilitamos TPC/IP y en las propiedades cambiamos el puerto a 1433, deshabilitamos los puertos dinámicos.
Con esto al ejecutar
el programa veremos el mensaje conectado si todo ha salido bien.
Conectividad de Bases de
Datos de Java (JDBC)
Se considera el primer
producto estándar de Java con DBMS, creado y ofrecido por primera vez en marzo
de 1996.
Crea una interfaz con un
nivel de programación que le permite comunicarse con las bases de datos
mediante un concepto similar al de componentes ODBC, el cual se ha convertido
en el estándar que se utiliza en computadoras personales o en redes locales.
El estándar de JDBC está
basado en un nivel de interfaz con instrucciones SQL X/Open, que es básicamente
lo mismo que en ODBC.
Las clases de objetos para
iniciar la transacción con la base de datos, están escritas completamente en
Java, lo cual permite mantener la seguridad, robustez y portabilidad de este
ambiente.
El puente JDBC-ODBC manipula
la traducción de llamadas JDBC a aquellas que puedan ser entendidas por el
cliente ODBC a un nivel de lenguaje C.
JDBC vs. ODBC
“ODBC (Open DataBase
Connectivity:Conectividad abierta de BD) es la interface para conectarse con BD
relacionales más usada por los programadores de aplicaciones”. Nos
preguntaremos qué significado tiene entonces JDBC si ya existe una interficie
popular que supuestamente hace lo mismo. La respuesta es que usaremos JDBC por
diferentes razones:
- ODBC usa una interface escrita con el
lenguaje de programación C. Por lo tanto como que C no es un lenguaje
portable las aplicaciones JAVA perderían también automáticamente su
portabilidad.
- ODBC se ha de instalar manualmente en
cada máquina, en cambio los drivers de JDBC como están escritos en JAVA
son automáticamente instalables, portables y seguros.
Hay que decir también, que
existen drivers puente entre JDBC-ODBC. Estos drivers traducen las llamadas de
JDBC a ODBC permitiendo comunicarse con BD propietarias que no tienen ni idea
de que existe JAVA. De esta manera por ejemplo podemos trabajar con una BD
Access de Microsoft que usa ODBC, con el lenguaje JAVA.
PUENTE JDBC/OBDC
JDBC es la API estándar de
acceso a Bases de Datos con Java, y se incluye con el Kit de Desarrollo de Java
(JDK) a partir de la versión 1.1. Sun optó por crear una nueva API, en lugar de
utilizar APIs ya existentes, como ODBC, con la intención de obviar los
problemas que presenta el uso desde Java de estas APIs, que suelen ser de muy
bajo nivel y utilizar características no soportadas directamente por Java, como
punteros, etc. Aunque el nivel de abstracción al que trabaja JDBC es alto en
comparación, por ejemplo, con ODBC, la intención de Sun es que sea la base de
partida para crear librerías de más alto nivel, en las que incluso el hecho de
que se use SQL para acceder a la información sea invisible.
Para trabajar con JDBC es
necesario tener controladores (drivers) que permitan acceder a las distintas
Bases de Datos: cada vez hay más controladores nativos JDBC. Sin embargo, ODBC
es hoy en día la API más popular para acceso a Bases de Datos: Sun admite este
hecho, por lo que, en colaboración con Intersolv (uno de principales
proveedores de drivers ODBC) ha diseñado un puente que permite utilizar la API
de JDBC en combinación con controladores ODBC. Un último detalle: algunos
fabricantes, como Microsoft, ofrecen sus propias APIs, en lugar de JDBC, como
RDO, etc. Aunque estas APIs pueden ser muy eficientes, y perfectamente
utilizables con Java, su uso requiere tener muy claras las consecuencias, sobre
todo la pérdida de portabilidad.
JDBC-ODBC bridge plus ODBC
driver (tipo 1): este driver fue desarrollado entre Sun e Intersolv y permite
al programador acceder a fuentes de datos ODBC existentes mediante JDBC. El
JDBC-ODBC Bridge (puente JDBC-ODBC) implementa operaciones JDBC traduciéndolas
a operaciones ODBC, se encuentra dentro del paquete sun.jdbc.odbc (que se
encuentra incluido dentro del JDK a partir de la versión 1.1) y contiene
librerías nativas para acceder a ODBC. Se debe señalar que en cada máquina
cliente que utilice el driver es necesaria una configuración previa, es decir,
deberemos definir la fuente de datos utilizando para ello el gestor de drivers
ODBC que los podemos encontrar dentro del Panel de Control de Windows. Debido a
esta configuración en las máquinas clientes, este tipo de driver no es adecuado
para utilizarlo dentro de applets, su utilización está más encaminada a
aplicaciones Java dentro de pequeñas intranets en las que la instalaciones en
los clientes no sean un gran problema o para aplicaciones Java que pueden
actuar de capa intermedia dentro de un modelo de tres capas, como se veía
anteriormente. Además debido a que el puente JDBC-ODBC contiene parte de código
nativo, no es posibible utilizarlos dentro de applets, debido a las
restricciones de seguridad de éstos. Desde Javasoft (una división de Sun) nos
sugieren que el uso del puente JDBC-ODBC se limite al tiempo que tarden en
aparecer drivers JDBC de otro tipo para la base de datos a la que queremos
acceder, esta advertencia es debida a que muchos drivers ODBC no están
programados teniendo en cuanta la programación multiproceso (multithreading),
por lo que se pueden producir problemas a la hora de utilizar el puente
JDBC-ODBC.
Preparación del entorno de
desarrollo
A continuación se va abordar
la creación de una fuente de datos ODBC, a través de la cuál accederemos a una
Base de Datos Interbase. Hemos escogido este modo de acceso en lugar de utilizar
un driver JDBC nativo para Interbase porque ello nos permitirá mostrar el uso
de drivers ODBC: de este modo, aquél que no disponga de Interbase, podrá crear
una Base de Datos Access, BTrieve o de cualquier otro tipo para el que sí tenga
un driver ODBC instalado en su sistema, y utilizar el código fuente incluido
con el diskette que acompaña a la revista.
El Listado
A muestra el SQL utilizado para crear nuestra pequeña Base de Datos de
ejemplo, incluida en el diskette. Nótese que el campo ID de la tabla CONTACTOS
es del tipo contador o autoincremento, y requiere de la definición de un
trigger y un contador en Interbase: otros sistemas de Base de Datos pueden
tener soporte directo para este tipo de campo, lo que hará innecesario parte
del código SQL del Listado A.
/* No se hace commit
automatico de sentencias de definicion de datos, DDL */
SET AUTODDL OFF;
/********** Creacion de la
base de datos **********/
/* Necesario USER y PASSWORD
si no se ha hecho login previo */
CONNECT
"h:\work\artículos\jdbc\1\fuente\agenda.gdb"
USER "SYSDBA"
PASSWORD "masterkey";
/* Eliminación de la Base de
datos */
DROP DATABASE;
CREATE DATABASE
"h:\work\artículos\jdbc\1\fuente\agenda.gdb"
USER "SYSDBA"
PASSWORD "masterkey";
CONNECT
"h:\work\artículos\jdbc\1\fuente\agenda.gdb"
USER "SYSDBA"
PASSWORD "masterkey";
/***** Creación de la tabla
de Contactos *****/
CREATE TABLE CONTACTOS (
ID INTEGER NOT NULL,
NOMBRE CHAR(30) NOT NULL,
EMPRESA CHAR(30),
CARGO CHAR(20),
DIRECCION CHAR(40),
NOTAS VARCHAR(150),
PRIMARY KEY( ID )
);
CREATE INDEX I_NOMBRE ON
CONTACTOS( NOMBRE );
/* Creamos un contador para
CONTACTOS.ID */
CREATE GENERATOR
CONTACTOS_ID_Gen;
SET GENERATOR
CONTACTOS_ID_Gen TO 0;
/* Creamos trigger para
insertar código del contador en CONTACTOS */
SET TERM !! ;
CREATE TRIGGER
Set_CONTACTOS_ID FOR CONTACTOS
BEFORE INSERT AS
BEGIN
New.ID = GEN_ID(
CONTACTOS_ID_Gen, 1);
END !!
SET TERM ; !!
/**** Creación de la tabla
de teléfonos de contactos ****/
CREATE TABLE TELEFONOS (
CONTACTO INTEGER NOT NULL,
TELEFONO CHAR(14) NOT NULL,
NOTAS VARCHAR(50),
PRIMARY KEY( CONTACTO,
TELEFONO )
);
/* Se hace COMMIT */
EXIT;
Listado A: SQL utilizado
para crear la Base de Datos de ejemplo, AGENDA.GDB, con Interbase.
El primer paso,
evidentemente, será crear la Base de Datos, que en nuestro caso se llama
AGENDA.GDB. Una vez hecho esto, debemos crear una fuente de datos ODBC: para
ello, se debe escoger en el Panel de Control el icono "32bit ODBC",
correspondiente al gestor de fuentes de datos ODBC, y hacer click sobre el
botón "Add..." de la página "User DSN", con lo que
aparecerá la ventana de la Figura A.
Figura A: Ventana del gestor
de fuentes de datos ODBC utilizada para añadir nuevas fuentes de datos.
Hecho esto, queda configurar
la fuente de datos, indicando el nombre que le vamos a dar (que utilizaremos a
la hora de conectarnos a la Base de Datos), así como otros datos.
La Figura B muestra la ventana de configuración de una fuente de
datos Interbase, utilizando un driver de Visigenic.
Data Source Name es el
nombre que utilizaremos para identificar la fuente de datos, y en nuestro caso
será JDBC_AGENDA. Description es un texto explicativo optativo,
y Database específica cómo se llama y dónde se encuentra la Base de
Datos que vamos a acceder a través de esta fuente de datos. Para poder utilizar
los programas de ejemplo, deberemos introducir aquí el directorio donde
copiemos los ejemplos, seguido del nombre de la Base de Datos, AGENDA.GDB. En
mi caso, Database es h:\work\artículos\jdbc\1\fuente\AGENDA.GDB.
El hecho de que para acceder
una Base de Datos mediante ODBC se utilice el nombre de la fuente de datos, en
lugar del nombre de la Base de Datos, nos permite cambiar la ubicación e
incluso el nombre de la misma sin tener que modificar el código fuente de
nuestros programas, ya que estos utilizarán el nombre de la fuente de datos
para identificarla.
En cuanto a los demás
parámetros de la fuente de datos, se debe escoger como Network Protocolo la
opción <local>. El nombre de usuario (User name) y la contraseña
(Password), se indicarán manualmente desde dentro de nuestro programa: no suele
ser aconsejable especificarlo en la misma fuente de datos, dado que esto daría
acceso a la Base de Datos a cualquier programa que acceda a la misma a través
de la misma.
Figura B: Ventana de
configuración de una fuente de datos ODBC.
Como último paso, no debemos
olvidar arrancar el servidor de Base de Datos, si utilizamos un gestor que
incluye uno, como sucede con Interbase.
El primer programa con JDBC
Como es lógico, la API JDBC
incluye varias clases que se deben utilizar para conseguir acceso a una Base de
Datos. La Tabla A muestra la lista de clases e interfaces más
importantes que JDBC ofrece, junto con una breve descripción. Estas clases se
encuentran en el paquetejava.sql.
Clase/Interface
|
Descripción
|
Driver
|
Permite conectarse a una
Base de Datos: cada gestor de Base de Datos requiere un Driver distinto.
|
DriverManager
|
Permite gestionar todos
los Drivers instalados en el sistema.
|
DriverPropertyInfo
|
Proporciona diversa
información acerca de un Driver.
|
Connection
|
Representa una conexión
con una Base de Datos. Una aplicación puede tener más de una conexión a más
de una Base de Datos.
|
DatabaseMetadata
|
Proporciona información
acerca de una Base de Datos, como las tablas que contiene, etc.
|
Statement
|
Permite ejecutar sentencias
SQL sin parámetros.
|
PreparedStatement
|
Permite ejecutar
sentencias SQL con parámetros de entrada.
|
CallableStatement
|
Permite ejecutar
sentencias SQL con parámetros de entrada y salida, típicamente procedimientos
almacenados.
|
ResultSet
|
Contiene las filas o
registros obtenidos al ejecutar un SELECT.
|
ResultSetMetadata
|
Permite obtener
información sobre un ResultSet, como el número de columnas, sus nombres, etc.
|
Tabla A: Clases e interfaces
definidos por JDBC.
El mejor modo de comenzar a
estudiar la API de JDBC es empezar con un pequeño programa. El Listado
B corresponde a un programa que carga el driver utilizado para conectarnos
a bases de datos utilizando controladores ODBC.
// Importamos el paquete que
da soporte a JDBC, java.sql
import java.sql.*;
import java.io.*;
class jdbc1 {
public static void main(
String[] args ) {
try {
// Accederemos a la fuente
de datos
// ODBC llamada JDBC_AGENDA
String urlBD =
"jdbc:odbc:JDBC_AGENDA";
String usuarioBD =
"SYSDBA";
String passwordBD =
"masterkey";
// Cargamos la clase que
implementa
// el puente JDBC=>ODBC
Class.forName(
"sun.jdbc.odbc.JdbcOdbcDriver" );
// Establecemos una conexion
con la Base de Datos
System.out.println(
"Estableciendo conexión con " +
urlBD + "..." );
Connection conexion =
DriverManager.getConnection(
urlBD, usuarioBD, passwordBD
);
System.out.println(
"Conexión establecida." );
conexion.close();
System.out.println("Conexión
a " + urlBD " cerrada.");
}
catch( Exception ex ) {
System.out.println( "Se
produjo un error." );
}
}
}
Listado B: Código básico
para llevar a cabo la conexión con una Base de Datos a través de ODBC.
Establecer una conexión con
una Base de Datos mediante JDBC es sencillo: en primer lugar, registramos
el Driver a utilizar (que en nuestro caso es el puente JDBC/ODBC), mediante
el código
Class.forName(
"sun.jdbc.odbc.JdbcOdbcDriver" );
Si no se registra este
driver, se producirá un error intentar la conexión. A continuación, se lleva a
cabo la conexión a la Base de Datos mediante el código
Connection conexion =
DriverManager.getConnection( urlBD, usuarioBD, passwordBD );
La
clase DriverManager gestiona los Drivers registrados en el
sistema: al llamar a getConnection, recorre la lista
de Drivers cargados hasta encontrar uno que sea capaz de gestionar la
petición especificada por urlBD, que en nuestro ejemplo es
"jdbc:odbc:JDBC_AGENDA". Los parámetros usuarioBD y passwordBD
corresponden al nombre del usuario y su contraseña, necesarios la mayor parte
de las veces para acceder a cualquier Base de Datos.
Cómo se especifica la Base
de Datos a utilizar depende del Driver utilizado: en nuestro caso, en
que utilizamos el puente ODBC/JDBC, todas las peticiones serán de la forma
"jdbc:odbc:NOMBRE_FUENTE_DATOS".
La cadena utilizada para
indicar la Base de Datos siempre tiene tres partes, separadas por el carácter
":". La primera parte es siempre "jdbc". La segunda parte
indica el subprotocolo, y depende del Sistema de Gestión de Base de Datos
utilizado: en nuestro caso, es "odbc", pero paraSQLAnyware, por
ejemplo, es "dbaw". La tercera parte identifica la Base de Datos
concreta a la que le deseamos conectar, en nuestro caso la especificada por la
fuente de datos ODBC llamada "JDBC_AGENDA". Aquí también se pueden
incluir diversos parámetros necesarios para establecer la conexión, o cualquier
otra información que el fabricante del SGBD indique.
Siguiendo con
el Listado B, a continuación se establece una conexión con la Base de
Datos, mediante el código
Connection conexion =
controlador.connect( urlBD, usuarioBD, passwordBD );
Acto seguido cerramos la
conexión, con
conexión.close();
Es conveniente cerrar las
conexiones a Bases de Datos tan pronto como dejen de utilizarse, para liberar
recursos rápidamente. Sin embargo, ha de tenerse en cuenta que establecer una
conexión es una operación lenta, por lo que tampoco se debe estar abriendo y
cerrando conexiones con frecuencia.
Consultas en JDBC
Un programa que realice una
consulta y quiera mostrar el resultado de la misma requerirá del uso de varias
clases: la primera es DriverManager, que permitirá llevar a cabo una conexión
con una Base de Datos, conexión que se representa mediante un objeto que
soporta el interface Connection. También será necesario además ejecutar
una sentencia SELECT para llevar a cabo la consulta, que se representará por un
objeto que soporte el interface Statement (o PreparedStatement,
o CallableStatement, que estudiaremos más adelante). Una sentencia SELECT
puede devolver diversos registros o filas: esta información es accesible
mediante un objeto que soporte el interface ResultSet.
El Listado
C muestra el código fuente correspondiente a un pequeño programa que
muestra los nombres de todos los contactos que hemos almacenado en la Base de
Datos AGENDA.GDB, y que utiliza las clases anteriormente mencionadas.
import java.sql.*;
import java.io.*;
class jdbc2 {
public static void main(
String[] args ) {
try {
// Accederemos al alias ODBC
llamado JDBC_DEMO
String urlBD =
"jdbc:odbc:JDBC_AGENDA";
String usuarioBD =
"SYSDBA";
String passwordBD =
"masterkey";
// Cargamos el puente
JDBC=>ODBC
Class.forName
("sun.jdbc.odbc.JdbcOdbcDriver");
// Intentamos conectarnos a
la base de datos JDBC_DEMO
Connection conexion =
DriverManager.getConnection (
urlBD, usuarioBD, passwordBD
);
// Creamos una sentencia SQL
Statement select =
conexion.createStatement();
// Ejecutamos una sentencia
SELECT
ResultSet resultadoSelect =
select.executeQuery(
"SELECT * FROM
CONTACTOS ORDER BY NOMBRE" );
// Imprimimos el nombre de
cada contacto encontrado
// por el SELECT
System.out.println(
"NOMBRE" );
System.out.println(
"------" );
int col =
resultadoSelect.findColumn( "NOMBRE" );
boolean seguir =
resultadoSelect.next();
// Mientras queden
registros...
while( seguir ) {
System.out.println(
resultadoSelect.getString(
col ) );
seguir =
resultadoSelect.next();
};
// Liberamos recursos
rápidamente
resultadoSelect.close();
select.close();
conexion.close();
}
catch( SQLException ex ) {
// Mostramos toda la
informaci¢n sobre
// el error disponible
System.out.println(
"Error: SQLException" );
while (ex != null) {
System.out.println
("SQLState: " +
ex.getSQLState ());
System.out.println
("Mensaje: " +
ex.getMessage ());
System.out.println
("Vendedor: " +
ex.getErrorCode ());
ex = ex.getNextException();
System.out.println
("");
}
}
catch( Exception ex ) {
System.out.println( "Se
produjo un error inesperado" );
}
}
}
Listado C: Ejecución de una
sentencia SELECT e impresión de los resultados con java.
Echemos un vistazo al código
en el Listado C. El código para registrar el controlador (Driver) a
utilizar es el mismo del Listado B. A continuación se crea una sentencia
SQL (Statement), y se ejecuta, obteniendo seguidamente el resultado de la misma
(ResultSet), para lo que se utiliza el siguiente código:
// Creamos una sentencia SQL
Statement select =
conexion.createStatement();
// Ejecutamos una sentencia
SELECT
ResultSet resultadoSelect =
select.executeQuery(
"SELECT * FROM
CONTACTOS ORDER BY NOMBRE" );
Además del
método executeQuery, utilizado para ejecutar sentencias
SELECT, Statement también proporciona otros métodos: executeUpdateejecuta
una sentencia UPDATE, DELETE, INSERT o cualquier otra sentencia SQL que no
devuelva un conjunto de registros, y retorna el número de registros afectados
por la sentencia (o -1 si no los hubo). El
método getResultSet devuelve el ResultSet de la sentencia,
si lo tiene, mientras que getUpdateCount devuelve el mismo valor
que executeUpdate.
Es posible limitar el número
máximo de registros devuelto al hacer
un executeQuery mediante setMaxRows, y averiguar dicho número
mediante getMaxRows. Es posible también obtener el último aviso generado
al ejecutar una sentencia, mediante getWarning, así como limitar el tiempo
en segundos que el controlador esperará hasta que el SGBD devuelva un
resultado, mediante setQueryTimeout. Por último, el método close libera
los recursos asociados a la sentencia.
El
interface ResultSet es el que encapsula el resultado de una sentencia
SELECT. Para recuperar la información es necesario acceder a las distintas
columnas (o campos), y recuperarla mediante una serie de métodos getString, getFloat, getInt,
etc. Al utilizar estos métodos debe indicarse el número correspondiente a la
columna que estamos accediendo: si lo desconocemos, podemos averiguar el número
correspondiente a una columna, dado el nombre, mediante findColumn. Por último,
dado que un ResultSet puede contener más de un registro, para ir
avanzando por la lista de registros que contiene deberemos utilizar el
método next, que devuelve un valor booleano indicando si existe otro
registro delante del actual. El uso de los métodos anteriores se ilustra en
el Listado C, que recorre la lista de contactos en la Base de Datos,
obteniendo el valor del campo (o columna) "NOMBRE", e imprimiéndolo,
mediante un bucle en el que se llama repetidamente al métodonext y
a getString.
Además de estos
métodos, ResultSet también cuenta con getWarnings, que devuelve
el primer aviso obtenido al manipular los registros, así como wasNull, que
indica si el contenido de la última columna accedida es un NULL SQL. Por
último, el método close libera los recursos asociados
al ResultSet.
Excepción
|
Descripción
|
SQLException
|
Error SQL.
|
SQLWarning
|
Advertencia SQL.
|
DataTruncation
|
Producida cuando se
truncan datos inesperadamente, por ejemplo al intentar almacenar un texto
demasiado largo en un campo.
|
Tabla B: Excepciones que
puede generar la API de JDBC
Al utilizar la API JDBC es
posible obtener diversos errores debido a que se ha escrito incorrectamente una
sentencia SQL, a que no se puede establecer una conexión con la Base de Datos
por cualquier problema, etc.
El
paquete java.sql proporciona tres nuevas excepciones, listadas en
la Tabla A. En el Listado C se muestra un ejemplo de uso de las
excepciones del tipo SQLException: es posible que se encadenen varias
excepciones de este tipo, motivo por el que esta clase proporciona el
método getNextException.
La
excepción SQLWarning es silenciosa, no se suele elevar: para
averiguar si la Base de Datos emitió un aviso se debe utilizar el
métodogetWarnings de Statement y otras clases, que devuelve
excepciones de esta clase. Dado que es posible que se obtengan varios avisos
encadenados, esta clase proporciona el método getNextWarning, que devuelve
el siguiente aviso, si lo hay.
Por último, las excepciones
del tipo DataTruncation se producen cuando se trunca información
inesperadamente, ya sea al leerla o al escribirla.
Connection
Un objeto Connection representa una conexión a
una base de datos. Una sesión con una conexión incluye las sentencias SQL que
son ejecutadas y los resultados que son devueltos a través de dicha conexión.
Una misma aplicación puede tener una o más conexiones con una sola base de
datos o puede tener conexiones con varias bases de datos diferentes. La forma
estándar de establecer una conexión con una base de datos es llamando al método
DriverManager.getConnection. Este método toma como parámetro una cadena de
caracteres que contiene una URL. La clase DriverManage trata de localizar el
driver que pueda conectar con la base de datos representada por esa URL. El
siguiente código ejemplifica cómo abrir una conexión a una base de datos
localizada en la URL
“jdbc:odbc:wombat”: String url =
jdbc:odbc:wombat;
Connection con =
DriverManager.getConnection(url);
Una URL de JDBC facilita una
forma de identificar una base de datos de forma que el driver apropiado la
reconozca y establezca una conexión con ella. La sintaxis estándar para URLs de
JDBC es la siguiente:
Jdbc:<subprotocolo>:<subnombre>
Una URL de JDBC tiene tres
partes separadas por dos puntos: jdbc es el protocolo. El protocolo en una URL
JDBC es siempre jdbc.
<subprotocolo> es
usualmente el driver o el mecanismo de conectividad de la base de datos, el
cual debe ser soportado por uno o más drivers. Un ejemplo de un subprotocolo es
odbc, que ha sido reservado para URLs que especifican fuentes de datos de ODBC.
Por ejemplo, para acceder a una base de datos a través del Puente JDBC-ODBC se
usará una URL como la siguiente:
Jdbc:odbc:fred
donde el subprotocolo es
odbc y el subnombre es fred, una fuente de datos ODBC.
<subnombre>es una
forma de identificar la base de datos. Puede variar dependiendo del
subprotocolo y puede tener un subsubnombre con cualquier sintaxis interna que
el programador del driver haya elegido. La función del <subnombre>es dar
la suficiente información para localizar la base de datos.
Statement
Un objeto Statement se usa
para enviar sentencias SQL a una base de datos. Una vez que se ha establecido
una conexión con una base de datos particular, esa conexión puede ser usada
para enviar sentencias SQL. La
interfase Statement suminstra métodos básicos para ejecutar sentencias y
devolver resultados. La interfase PreparedStatement añade métodos para trabajat
con los parámetros IN; y la interfase CallableStatement añade métodos para
trabajar con parameters OUT.
Creación de objetos Statement
Una vez establecida la conexión con una base de
datos particular, esta conexión puede usarse para enviar sentencias SQL. Un
objeto Statement se crea mediante el método de Connection createStatement, como
podemos ver en el siguiente fragmento de código.
Connection con =
DriverManager.getConnection(url);
Statement stmt = con.createStatement();
La sentencia SQL que será
enviada a la base de datos es proporcionada como argumento a uno de los métodos
para ejecutar un objeto Statement:
ResultSet rs = stmt.executeQuery(SELECT
a, b, c FROM Table2);
ResultSet
Un ResultSet contiene todos
los registros (filas) que satisfacen las condiciones impuestas en una sentencia
SQL y proporciona acceso a los datos en dichos registros a través de un
conjunto de métodos get que permiten acceder a los diferentes campos o
atributos (columnas) del registro actual. Un ResultSet mantiene un cursor que
apunta al registro actual. El método ResultSet.next() se usa para moverse al
siguiente registro del ResultSet, haciendo el siguiente registro el registro
actual. Los métodos getXXX proporcionan los medios para obtener los valores de
los campos, atributos o columnas del registro actual. Para cada registro, los
valores de las columnas pueden ser obtenidos en cualquier orden, pero para la
mayor portabilidad, se debe hacer de izquierda a derecha y leer el valor de la
columna sólo una vez. Tanto el nombre de la columna como el número de esta pueden
ser usados para designar la columna de la cual se quiere obtener el valor. Si
en el ejemplo anterior la columna “a” es de tipo entero, la “b” del tipo cadena
de caracteres y la “c” de tipo coma flotante, la siguiente porción de código
imprimiría los valores de todos los registros:
int i = rs.getInt(″a″);
String s =
rs.getString(″b″);
Float f = rs.getFloat(″c″);
System.out.println(″ROW= ″ +i+ ″ ″ +s+ ″ ″ + f); }
EJEMPLOS
Ejemplo
#1 del Topic: Programación Gráfica en Java, en el
cual explicaré sobre cómo conectarnos a una base de datos cualquiera desde
Java, manteniendo una misma estructura.
Para
realizar la conexión a base de datos desde java necesitamos hacer uso de JDBC.
Las bases de datos que deseemos conectar deberán proveernos el driver JDBC en
un empaquetado JAR para añadirlo a las librerías del proyecto.
Deberemos
conseguir la librería de acuerdo a la versión de la Base de Datos al cual deseemos
conectarnos. Es posible que su IDE reconozca la existencia del driver si la
base de datos ha sido instalada en el mismo ordenador junto con sus librerías,
solo haría falta añadirlo a la lista de librerías que se usarán en el proyecto,
por ejemplo en NetBeans se podría ir al directorio Libraries del Proyecto,
hacer clic derecho sobre el y elegir Add Library y en la lista podría
encontrase la que necesitemos, o si queremos agregarla manualmente Add
JAR/Folder y seleccionar desde la dirección donde lo tenemos almacenado.
Add JAR/Folder:
Una vez
agregada la librería, vamos a realizar el código de conexión, el cual nos debe
presentar una clase con 2 métodos que a mi parecer no deberían faltar. Debería
existir una función (Las funciones retornan datos) que nos retorne un
CachedRowSet que es algo similar al ResultSet que no podemos retornar mientras
el Statement esté sin cerrar, pero es obvio que por seguridad deberemos tener
todas las conexiones cerradas, por eso no retornamos directamente el ResultSet
y hacerlo sin cerrar las conexiones sería de muy mala práctica. En cambio, el
CachedRowSet almacena todos los registros y podemos manipularla con las
conexiones cerradas, cosa que no podemos hacer con los ResultSets, ya que éstos
necesitan al Statement Abierto, y el Statement a su vez necesita la conexión
abierta. Por otro lado deberíamos tener un procedimiento (No retorna ningún
dato), no retorna nada ya que se encargará de realizar operaciones
unidireccionales.
En conclusión, usamos la Función cuando
usemos Sentencias DML SELECT incluyendo las
Funciones y usar el Procedimiento cuando usemos INSERT, DELETE O UPDATE, incluyendo
los StoreProcedures(Procedimientos Almacenados); aunque podemos conocer algunas
bases de datos que permitan retornar datos desde StoreProcedures, lo ideal sería
hacerlo desde funciones, manteniendo cada uno para su propósito. Del mismo
modo, habrá podido darse cuenta que ambos métodos reciben una variable String
como parámetro, ésta es nada menos que la Sentencia DML que deseamos ejecutar.
package beastieux.gui;
import java.sql.Connection;
import
java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import
javax.sql.rowset.CachedRowSet;
import com.sun.rowset.CachedRowSetImpl;
/**
*
* @author beastieux
*/
public class Ejm1_ConectarDataBase
{
public
CachedRowSet Function(String sql)
{
try
{
Class.forName("Driver");
String
url = "jdbc:motor:servidor:puerto/basededatos";
Connection
con = DriverManager.getConnection(url,
"usuario","contraseña");
Statement
s = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_READ_ONLY);
ResultSet
rs= s.executeQuery(sql);
CachedRowSet
crs = new CachedRowSetImpl();
crs.populate(rs);
rs.close();
s.close();
con.close();
return
crs;
}
catch(Exception
e)
{
System.out.println(e.getMessage());
}
return
null;
}
public
void StoreProcedure(String sql)
{
try
{
Class.forName("Driver");
String
url = "jdbc:motor:servidor:puerto/basededatos";
Connection
con = DriverManager.getConnection(url,
"usuario","contraseña");
Statement
s = con.createStatement();
s.execute(sql);
s.close();
con.close();
}
catch(Exception
e)
{
System.out.println(e.getMessage());
}
}
}
Como
habrán podido apreciar en el código, el manejo de excepciones es relativamente
sencilla, lo ideal sería especificar las excepciones por cada conexion,
statement y resultset para de esa manera asegurarnos que permanezcan cerradas
al finalizar la ejecución o aun cuando existieran errores; de igual manera
sería muy útil obligar a cerrar las conexiones desde dentro de una clausula
finally anexada al try – catch.
Por
último la url de conexión “jdbc:motor:servidor:puerto/basededatos”,
variará a continuación de jdbc, según el motor de base de datos al que deseemos
conectarnos (PostgreSQL, MySQL, Oracle, Derby, etc) , la dirección IP del
servidor, el puerto y finalmente el nombre de la base de datos al que queramos
acceder.
RESUMEN
Conectividad de Bases de
Datos de Java (JDBC)
Crea una interfaz con un nivel de programacion que
le permite comunicarse con las bases de datos mediante un concepto similar al
de componentes ODBC, el cual se ha convertido en el estandar que se utiliza en
computadoras personales o en redes locales.
JDBC vs OBDC
JDBC vs OBDC
ODBC se ha de instalar manualmente en cada máquina,
en cambio los drivers de JDBC como están escritos en JAVA son automáticamente
instalables, portables y seguros.
Estos drivers traducen las llamadas de JDBC a ODBC
permitiendo comunicarse con BD propietarias que no tienen ni idea de que existe
JAVA. De esta manera por ejemplo podemos trabajar con una BD Access de
Microsoft que usa ODBC, con el lenguaje JAVA.
PUENTE JDBC/OBDC
Sun opto por crear una nueva API, en lugar de
utilizar APIs ya existentes, como ODBC, con la intencion de obviar los
problemas que presenta el uso desde Java de estas APIs, que suelen ser de muy
bajo nivel y utilizar caracteristicas no soportadas directamente por Java, como
punteros, etc. Aunque el nivel de abstraccion al que trabaja JDBC es alto en
comparacion, por ejemplo, con ODBC, la intencion de Sun es que sea la base de
partida para crear librerias de mas alto nivel, en las que incluso el hecho de
que se use SQL para acceder a la informacion sea invisible.
Sin embargo, ODBC es hoy en dia la API mas popular
para acceso a Bases de Datos: Sun admite este hecho, por lo que, en
colaboracion con Intersolv ha disenado un puente que permite utilizar la API de
JDBC en combinacion con controladores ODBC. JDBC-ODBC bridge plus ODBC driver :
este driver fue desarrollado entre Sun e Intersolv y permite al programador
acceder a fuentes de datos ODBC existentes mediante JDBC.
Hemos escogido este modo de acceso en lugar de
utilizar un driver JDBC nativo para Interbase porque ello nos permitirá mostrar
el uso de drivers ODBC: de este modo, aquel que no disponga de Interbase, podrá
crear una Base de Datos Access, BTrieve o de cualquier otro tipo para el que si
tenga un driver ODBC instalado en su sistema, y utilizar el código fuente
incluido con el diskette que acompaña a la revista.
Una vez hecho esto, debemos crear una fuente de
datos ODBC: para ello, se debe escoger en el Panel de Control el icono 32bit
ODBC , correspondiente al gestor de fuentes de datos ODBC, y hacer click sobre
el boton Add...
El hecho de que para acceder una Base de Datos
mediante ODBC se utilice el nombre de la fuente de datos, en lugar del nombre
de la Base de Datos, nos permite cambiar la ubicación e incluso el nombre de la
misma sin tener que modificar el código fuente de nuestros programas, ya que
estos utilizaran el nombre de la fuente de datos para identificarla.
Driver Permite conectarse a una Base de Datos: cada
gestor de Base de Datos requiere un Driver distinto.
SUMMARY
Database Connectivity Java (JDBC)
Create an interface with a level of programming
that allows you to communicate with databases using ODBC similar to components,
which has become the standard used in personal computers or local networks
concept.
JDBC vs OBDC
ODBC must manually install on each machine, instead
of JDBC drivers are written in JAVA and are automatically installable, portable
and secure.
These drivers translate JDBC calls to ODBC allowing
owners to communicate with BD who have no idea that there JAVA. Thus for
example we can work with a Microsoft Access DB using ODBC, with the Java
language.
BRIDGE JDBC / ODBC
Sun chose to create a new API, instead of using
existing APIs such as ODBC, with the intention to overcome problems posed by
the use from Java of these APIs, which are usually very low and use features
not supported directly by Java, as pointers, etc. Although the level of
abstraction to working JDBC is high compared, for example, with ODBC, the
intention of Sun is to be the starting point for creating libraries highest
level, where even the fact that SQL is used to access the information is
invisible.
However, ODBC is nowadays the most popular API for
accessing databases: Sun admits this fact, so, in collaboration with Intersolv
has designed a bridge that allows you to use the JDBC API in combination with
ODBC drivers. JDBC-ODBC bridge plus ODBC driver: This driver was developed
between Sun and Intersolv and allows the programmer to access existing ODBC
data sources through JDBC.
We have chosen this mode of access instead of using
a JDBC driver native to Interbase because it will allow us to demonstrate the
use of ODBC drivers: in this way, one that does not have Interbase, you can
create a Database Access, Btrieve or any another type for which if have an ODBC
driver installed on your system, and use the source code included with the disk
that accompanies the magazine.
Once this is done, we must create an ODBC data source:
To do this, you should choose in the Control Panel corresponding to manager
ODBC data sources 32bit ODBC icon, and click on the Add button ...
The fact that access a database through ODBC name
of the data source is used, instead of the name of the database allows us to
change the location and even the name of it without having to modify the code
source of our programs, as these will use the name of the data source to
identify it.
Driver Connect to a Database: each database manager
requires a different driver
RECOMENDACIONES
En Java existen ciertas
reglas de codificación que son comúnmente utilizadas por los programadores.
Conviene conocer y seguir estas reglas.
·
Los nombres de las clases deben empezar por
mayúscula.
·
Los atributos y métodos de las clases deben
empezar por minúsculas y si están formadas por varias palabras, se escriben sin
espacios y la primera letra de cada palabra en mayúscula.
·
Las instancias de las clases siguen la misma recomendación
que los métodos y atributos.
·
Las constantes se escriben en mayúsculas.
·
Para que exista un enlace remoto con la Base
de Datos, la aplicación no debe de conectarse directamente a la Base de Datos,
sino que mediante los drivers JDBC - ODBC.
CONCLUSIONES
Qué difícil resulta dar por
concluido un trabajo cuando se habla de proyectos de ingeniería. La dificultad
se ve incrementada si el proyecto está relacionado con el mundo del software,
dónde siempre será posible introducir alguna mejora a un trabajo terminado.
Los drivers JDBC y ODBC
establecen la estructura para el diseño y generación de conexiones y accesos a
Base de Datos remotas; por lo que facilita el desarrollo de nuevas aplicaciones
que la Universidad desee implementar en un futuro, orientados con este fin.
Además la API JDBC utilizada
por Java para ofrecer acceso a bases de datos, sino que proporciona una nueva
capa de software que posibilita no sólo mantener replicada la información, sino
que además, permite que nuevos servidores se incorporen al sistema sin
necesidad de detener la actividad del mismo.
APRECIACION DEL EQUIPO
En el transcurso del desarrollo del trabajo hemos
venido descubriendo que Java es un tema muy importante para todo estudiante de
Sistemas, Además en un lenguaje de muy fácil entendimiento que para toda
aquella persona que quiera practicarlo lo será muy fácil ya que nos permite
crear tablas, insertar datos, conectar nuestra base de datos que nos permita
realizar una base de datos con objetos que hemos visto durante el desarrollo
del trabajo como son CONNECTION, RESULSET, STATEMENT, por medio del JDBC O
ODBC.
GLOSARIO
DE TÉRMINOS
API: Una API nos permite implementar las funciones y
procedimientos que engloba en nuestro proyecto sin la necesidad de programarlas
de nuevo. En términos de programación, es una capa de abstracción.
ODBC: (Open
DataBase Connectivity). es un estándar de acceso a las bases de datos desarrollado
por SQL Access Group (SAG) en 1992.
GLP: Es la
licencia más ampliamente usada en el mundo del software y
garantiza a los usuarios finales (personas, organizaciones, compañías) la
libertad de usar, estudiar, compartir (copiar) y modificar el software.
DBO: Siglas de Database Owner,
se refiere al propietario de una base de datos, al usuario que la creó.
DDL: Data Definition Language,
dentro del SQL es un vocabulario usado para crear y modificar la estructura de
las tablas, ejemplos: CREATE, ALTER o DROP.
DML: Data Manipulation Language,
igualmente dentro del SQL es un vocabulario usado para gestionar los datos,
ejemplos: SELECT, INSERT, UPDATE.
HTML: Siglas de Hypertext Markup
Language, lenguaje usado para realizar páginas web.
SQL: Structured Query Language,
lenguaje informático para el tratamiento de base de datos.
LINCOGRAFIA
VIDEO: para mayor entendimiento acá les dejo un link para ver vídeo espero sea de su agrado
Acá el link de las diapositivas para facilitarle un poco mas su investigación
http://es.slideshare.net/ErlinDarwinHerreraCieza/java-con-base-de-datos-66434539
espero sea de ayuda lo que nosotros los ofrecemos gracias por su visita.
