I. JDBC
1. Contenido
§ Capa de Acceso de Datos, Creación
La información contenida en un servidor de bases de
datos es normalmente el bien más preciado dentro de una empresa. La API JDBC
ofrece a los desarrolladores Java un modo de conectar con dichas bases de
datos. Utilizando la API JDBC, los desarrolladores pueden crear un cliente que
pueda conectar con una base de datos, ejecutar instrucciones SQL y procesar el
resultado de esas instrucciones.
La API proporciona conectividad y acceso a datos en
toda la extensión de las bases de datos relacionales. JDBC generaliza las
funciones de acceso a bases de datos más comunes abstrayendo los detalles
específicos de una determinada base de datos. El resultado es un conjunto de
clases e interfaces, localizadas en el paquete java.sql, que pueden ser
utilizadas con cualquier base de datos que disponga del driver JDBC apropiado.
La utilización de este driver significa que, siempre y cuando una aplicación
utilice las características más comunes de acceso a bases de datos, dicha
aplicación podrá utilizarse con una base de datos diferente cambiando
simplemente a un driver JDBC diferente.
Acceso
de JDBC a Bases de Datos El API JDBC soporta dos modelos diferentes de acceso
a Bases de Datos, los modelos de dos y tres capas.
Modelo
de dos capas: Este
modelo se basa en que la conexión entre la aplicación Java o el applet que se
ejecuta en el navegador, se conectan directamente a la base de datos.
Esto significa que el driver
JDBC específico para conectarse con la base de datos, debe residir en el
sistema local. La base de datos puede estar en cualquier otra máquina y se
accede a ella mediante la red. Esta es la configuración de típica
Cliente/Servidor: el programa cliente envía instrucciones SQL a la base de
datos, ésta las procesa y envía los resultados de vuelta a la aplicación.
Modelo
de tres capas: En este
modelo de acceso a las bases de datos, las instrucciones son enviadas a una
capa intermedia entre Cliente y Servidor, que es la que se encarga de enviar
las sentencias SQL a la base de datos y recoger el resultado desde la base de
datos. En este caso el usuario no tiene contacto directo, ni a través de la
red, con la máquina donde reside la base de datos
Este modelo presenta la
ventaja de que el nivel intermedio mantiene en todo momento el control del tipo
de operaciones que se realizan contra la base de datos, y además, está la
ventaja adicional de que los drivers JDBC no tienen que residir en la máquina
cliente, lo cual libera al usuario de la instalación de cualquier tipo de
driver.
ACCESO A BASES DE DATOS CON JDBC
Una vez incorporado el driver
como librería de la aplicación, se deben seguir los siguientes pasos para
acceder a una base de datos:
1. Importar los paquetes: Normalmente es suficiente con la
sentencia import java.sql.*;
2. Cargar el driver: El driver se debe cargar para poder
utilizarlo. Esto lo realiza el método estático forName() de la
clase Class.
Class.forName(String driver);
Driver JDBC para MySQL:
Class.forName("com.mysql.jdbc.Driver");
Lanza una
excepción ClassNotFoundException
3. Crear la conexión: Esto lo realiza el método estático getConnection() de
la clase DriveManager.
DriverManager.getConnection(String url);
url es un String que nos permite
localizar la base de datos.
Normalmente se compone de tres
campos:
jdbc:tipoBD:datos_de_conexion
Para MySQL, el formato es:
"jdbc:mysql://ordenador_donde_está_la_base_de_datos/base_de_datos".
Deberemos indicar el nombre o IP
del ordenador en el que se encuentra el servidor de base de datos y a
continuación el nombre de la base de datos.
Una sobrecarga del método
getConnection acepta, además de la url, el usuario y contraseña de la base de
datos.
Este método devuelve un objeto
que implementa la interfaz Connection.
Por ejemplo, si tenemos corriendo en nuestro ordenador el
servidor de bases, de datos, y nos queremos conectar a una base de datos llamadaprueba que
tiene un usuario root y contraseña 1daw escribiremos:
Connection conexion =
DriverManager.getConnection("jdbc:mysql://localhost/prueba","root","1daw");
4. Ejecutar una consulta: Las consultas se manejan mediante un objeto que
implementa la interface Statement.
Antes de poder ejecutar una
consulta debemos crear el objeto.
El objeto se crea utilizando el
método createStatement() de Connection.
Statement s =
conexion.createStatement();
Una vez creado podemos utilizar
algunos de los métodos de Statement para enviar la consulta a la BD.
Algunos de estos métodos son:
boolean
execute(String sentenciaSQL);
|
Si es
una consulta de acción (Insert, Delete, Update) devuelve false indicando que
no se generan resultados. Si es una consulta de selección (Select) devuelve
true.
|
int
executeUpdate(String sentenciaSQL);
|
Envía
una consulta de acción. Devuelve el número de registros afectados por dicha
acción.
|
ResultSet
executeQuery(String sentenciaSQL);
|
Envía
una consulta de selección. Devuelve un objeto ResultSet con los datos
obtenidos de la consulta.
|
Por ejemplo, si en la base de datos tenemos una tabla llamada persona,
una consulta de todos los registros de la tabla sería:
ResultSet
rs = s.executeQuery("select * from persona");
5. Manipular el resultado de la
consulta: El objeto de tipo
ResultSet devuelto por la consulta de selección dispone de un cursor para
desplazarse por los registros y de métodos para acceder al valor de cada campo.
Desplazarse por los registros de
un ResultSet
Una vez obtenido, su cursor se
sitúa justo antes del primer registro obtenido.
Por defecto, un ResultSet
es un objeto de sólo avance y solo lectura. El recorrido se
hará siempre desde el principio hacia delante y los campos no podrán ser
modificados. Se pueden crear también ResultSets desplazables de
lectura/escritura.
El método next() permite desplazarnos por los
registros. Una llamada a este método desplaza el cursor al siguiente registro.
Devuelve false si se ha llegado al final y true en caso contrario.
while (rs.next()) {
.....
}
Acceder a los campos del
resultado de una consulta
Los campos del registro apuntado
por el cursor se pueden acceder mediante dos grupos de métodos. xxx es
cualquier tipo de dato básico Java más String, Date y Object. Se deberá
utilizar el método adecuado al tipo de dato que contiene el campo. Si no
conocemos el tipo de dato podemos utilizar getObject().
xxx
getXxx(int posición);
|
Obtiene
el valor del campo que ocupa la posición indicada. La primera posición es la
1.
|
xxx
getXxx(String nombreCampo);
|
Obtiene
el valor del campo que coincide con el nombre indicado.
|
Por ejemplo, si la tabla persona contiene 3 campos en este
orden: id de tipo int, nombre de tipo String y fecha de tipo Date:
while
(rs.next()) {
System.out.println(rs.getInt("Id")
+ " " + rs.getString(2) + " " + rs.getDate(3));
}
Además de estos métodos, la
interfaz ResultSet proporciona una gran cantidad de métodos para acceder y
manejar los resultados de la consulta entre ellos:
boolean isFirst() que devuelve true si el cursor apunta al primer
registro.
boolean isLast() que devuelve true si el cursor apunta al
último.
int getRow() que devuelve la posición del registro actual,
siendo 1 la posición del primer registro, etc.
6. Desconexión de la base de
datos: Permite liberar recursos de
memoria y CPU. El cierre de una conexión se realiza mediante el métodoclose() de
la interfaz Connection.
conexion.close();
La interfaz Statement también
dispone de un método close() para liberar los recursos utilizados por el
objeto. Esto debe hacerse antes de cerrar la conexión.
Cuando se cierra una conexión
todos los objetos Statement se cierran automáticamente.
La mayoría de métodos usados el
la API JDBC lanzan una excepción de tipo SQLException que se
debe capturar.
§ Configuración de Conexión BD con Netbeans
NetBeans es una
plataforma para el desarrollo de aplicaciones de escritorio usando Java y a un
Entorno integrado de desarrollo (IDE) desarrollado usando la Plataforma
NetBeans.
Si eres un programador y desarrollas tus aplicaciones en Java seguramente necesitarás conectar una base de datos tipo MySQL a este entorno algún día, bueno, si lo necesitas ahora, he aquí una explicación paso a paso de cómo conectar ambas herramientas.
Obtener lo necesario:
·
Primero
que nada necesitas tener un servidor MySQL instalado en tu equipo o en su
defecto en la máquina que actuará como servidor de bases de datos. Recuerda que
MySQL es gratuito y puedes obtenerlo desde aquí.
·
El
proceso de instalación es algo en lo que no entraré en detalle, para cualquier
duda puedes consultar la documentación oficial que se
encuentra en su sitio web.
·
Asimismo,
debes de tener el NetBeans instalado, de preferencia su última versión estable
(al momento de esta publicación es la 5.5.1) que viene con el Java Development
Kit (JDK) 1.6, lo anterior puedes obtenerlo desde aquí.
·
Una vez
que tengas ambas herramientas instaladas necesitaras el driver o conector a la
base de datos de MySQL que puedes obtener desde aquí.
Copiar lo necesario:
Una vez que tengas el NetBeans y
el MySQL Server instalado lo que vas a necesitar es copiar el driver que
descargaste, en mi caso el mysql-connector-java-3.1.11-bin.jar dentro
de la carpeta del JDK, en mi caso es la siguiente ruta:
C:\Archivos de programa\Java\jdk1.6.0_01\jre\lib\ext
*NOTA: Debes tener el conector dentro de la carpeta
anterior antes de ejecutar el NetBeans, en caso de que esté abierto ciérralo y
vuélvelo a abrir.
Ya que lo hayas copiado ahora sí abre el NetBeans y espera a que cargue.
Configurar NetBeans:
Una vez que hayas abierto el NetBeans localiza la sección de Runtime o Tiempo de ejecución que se localiza en el lado izquierdo de la pantalla, como se muestra a continuación:
Al expandir la sección de Databases o Bases
de datos debe de aparecer el MySQL (Connector/J driver), en caso
contrario debes de agregarlo manualmente como se describe a continuación:
2.
En la
ventana que aparece da clic en el botón de Add o Agregar y
busca el archivo .jar que descargaste anteriormente, el mismo que copiaste
dentro de la carpeta del JDK.
3.
Una vez
hecho lo anterior da clic en el botón de Ok o Aceptar.
Cuando realices los pasos
anteriores debe de aparecer un elemento nuevo en la sección de Drivers dentro
de Databases de nombre MySQL (Connector/J driver).
Crear y probar una conexión:
Dentro de la sección de Runtime o Tiempo de ejecución > Databases o Bases de datos >Drivers da un clic derecho sobre MySQL (Connector/J driver) y selecciona Connect Usingo Conectar usando... para que aparezca la pantalla de configuración de la conexión como se muestra a continuación:
Crear y probar una conexión:
Dentro de la sección de Runtime o Tiempo de ejecución > Databases o Bases de datos >Drivers da un clic derecho sobre MySQL (Connector/J driver) y selecciona Connect Usingo Conectar usando... para que aparezca la pantalla de configuración de la conexión como se muestra a continuación:
En la sección de Name o Nombre selecciona MySQL (Connector/J driver), en la
sección Database URL cambia la parte indicada por por la dirección del
servidor de bases de datos, si es la misma computadora escribe localhost, en la parte
de establece el puerto que definiste al instalar el servidor MySQL , por
defecto es el 3306, en
la sección de escribe el nombre de la base de datos a la cual te quieres conectar.
Posteriormente escribe el nombre de usuario para accesar a la base de datos y la contraseña respectivamente.
Da un clic en el checkbox inferior para que NetBeans recuerde la contraseña durante la conexión.
Si todo se realizó correctamente podrás ver un nuevo elemento debajo del Driver con las especificaciones de la conexión actual, si das un clic en el símbolo '+' que aparece de lado izquierdo del mismo podrás ver las tablas de la base de datos y realizar consultas hacia la misma.
Posteriormente escribe el nombre de usuario para accesar a la base de datos y la contraseña respectivamente.
Da un clic en el checkbox inferior para que NetBeans recuerde la contraseña durante la conexión.
Si todo se realizó correctamente podrás ver un nuevo elemento debajo del Driver con las especificaciones de la conexión actual, si das un clic en el símbolo '+' que aparece de lado izquierdo del mismo podrás ver las tablas de la base de datos y realizar consultas hacia la misma.
Implementar el código:
Hasta aquí ya hemos establecido la conexión a la base de datos y probado su funcionamiento desde el NetBeans, sin embargo, nos hace falta implementar el código directamente en una aplicación. Para este ejemplo crearemos una clase de nombre Conexion que se podrá reutilizar las veces que sea necesario en cualquier tipo de aplicación Java que requiera conectarse y realizar consultas a una base de datos en MySQL.
Empecemos por el principio.
Hasta aquí ya hemos establecido la conexión a la base de datos y probado su funcionamiento desde el NetBeans, sin embargo, nos hace falta implementar el código directamente en una aplicación. Para este ejemplo crearemos una clase de nombre Conexion que se podrá reutilizar las veces que sea necesario en cualquier tipo de aplicación Java que requiera conectarse y realizar consultas a una base de datos en MySQL.
Empecemos por el principio.
1.
Da un
clic en el menú de File o Archivo que se localiza en la
esquina superior izquierda de la ventana de NetBeans.
2.
Selecciona
la opción de Nuevo Proyecto o New Project, posteriormente en la
sección de Categories o Categorías selecciona General y en Projects o Proyectos seleccionaJava Application o Aplicación Java y da un clic
en Siguiente.
*NOTA: La clase que crearemos funciona con cualquier tipo de proyecto, para fines de este ejemplo utilizamos una aplicación java convencional.
*NOTA: La clase que crearemos funciona con cualquier tipo de proyecto, para fines de este ejemplo utilizamos una aplicación java convencional.
3. Posteriormente
damos un nombre a la aplicación y definimos su ubicación, una vez hecho esto
damos clic en el botón de Finish o Finalizar.
4. En este
momento aparece del lado izquierdo en la pestaña de Projects o Proyectosuna
especie de árbol jerárquico en el cual tenemos 4 carpetas, al dar clic en el
símbolo '+' de la carpeta Source Packages o Paquetes
Fuente nos desplegará el único paquete con el cual cuenta nuestra
aplicación hasta este punto, dentro de él se crea la clase Main.
5. Ahora
debemos de dar un clic derecho sobre Source Packages o Paquetes
Fuente y dar un nombre al paquete, en mi caso es database. Este
paquete contendrá la clase desde la cual estaremos realizando todas las
consultas a la base de datos.
6. Posteriormente
damos un clic derecho sobre el paquete recién creado y seleccionamosNueva o New > Java
Class. Posteriormente le damos el nombre de Conexion y
damos clic en el botón de Finalizar o Finish.
7.
Dentro de
la clase Conexion importamos algunas librerías con el
siguiente código:
1
2
3
4
5
|
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
|
8.
Una vez
que tenemos las librerías creamos los métodos a utilizar descritos a
continuación:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
/**
* Método utilizado para
recuperar el valor del atributo conexion
* @return conexion contiene el
estado de la conexión
*
*/
public Connection getConexion()
{
return
conexion;
}
/**
* Método utilizado para
establecer la conexión con la base de datos
* @return estado regresa el
estado de la conexión, true si se estable
ció la conexión,
* falso en caso contrario
*/
public boolean crearConexion()
{
try {
Class.forName("com.mysql.jdbc.Driver");
conexion
= DriverManager.getConnection("jdbc:mysql://host:puerto/
"usuario","contraseña");
} catch
(SQLException ex) {
ex.printStackTrace();
return
false;
} catch
(ClassNotFoundException ex) {
ex.printStackTrace();
return
false;
}
return true;
}
/**
*
*Método utilizado para realizar
las instrucciones: INSERT, DELETE y UPDATE
*@param sql Cadena que contiene
la instrucción SQL a ejecutar
*@return estado regresa el
estado de la ejecución, true(éxito) o false(error)
*
*/
public boolean
ejecutarSQL(String sql)
{
try {
Statement
sentencia = conexion.createStatement();
sentencia.executeUpdate(sql);
} catch
(SQLException ex) {
ex.printStackTrace();
return false;
}
return true;
}
/**
*
*Método utilizado para realizar
la instrucción SELECT
*@param sql Cadena que contiene
la instrucción SQL a ejecutar
*@return resultado regresa los
registros generados por la consulta
*
*/
public ResultSet
ejecutarSQLSelect(String sql)
{
ResultSet
resultado;
try {
Statement
sentencia = conexion.createStatement();
resultado
= sentencia.executeQuery(sql);
} catch
(SQLException ex) {
ex.printStackTrace();
return
null;
}
return
resultado;
}
|
9.
Finalmente
compilamos el archivo localizándolo en el árbol jerárquico del lado izquierdo
dando un clic derecho sobre él y seleccionando la opción de Compilar o Compile. Podrás
utilizar la clase en cualquier parte de tu proyecto creando una instancia de la
misma en el momento que sea necesario.
*TIP: Crea únicamente una vez la conexión con el método crearConexion() desde la clase Main y pasa tu conexión como parámetro a todas las ventanas y módulos de la aplicación que la utilicen.
*TIP: Crea únicamente una vez la conexión con el método crearConexion() desde la clase Main y pasa tu conexión como parámetro a todas las ventanas y módulos de la aplicación que la utilicen.
Una vez realizado lo anterior
estarás listo para conectarte a bases de datos en MySQL desde NetBeans, la
clase Conexión y el driver para MySQL puedes descargarlos este vínculo en un archivo comprimido tipo rar, este manual se
encuentra en formato PDF desde este vínculo.
§ Definición JDBC
JDBC es una API de Java para ejecutar sentencias SQL. (Como punto de interés, JDBC es
nombre de una marca registrada y no es un acrónimo, a pesar de todo, JDBC es a menudo interpretado
como “Java DataBase Connectivity”). Consta de un conjunto
de
clases e interfaces
escrito
en
lenguaje
de programación
Java.
Usando JDBC es fácil enviar sentencias SQL a virtualmente cualquier
base de datos relacional. En otras
palabras,
con
la API JDBC no es necesario escribir un programa para acceder a una base de datos tipo Access, otro programa para acceder a una base
de datos tipo Oracle y así para cada tipo de base de datos. Uno puede escribir un solo programa usando la API JDBC y el programa será capaz de enviar sentencias
SQL a la base de datos apropiada. Y, con una
aplicación escrita en Java, uno
no
tiene por qué preocuparse por escribir diferentes programas
para diferentes plataformas. La combinación de
JDBC permite al programador escribir una vez y ejecutar en cualquier sitio.
Java, siendo robusto, seguro, fácil de usar, fácil de entender, y automáticamente descargable en una red, es un excelente lenguaje base para aplicaciones con bases de datos. Lo que es necesario es una forma
para que las aplicaciones Java
puedan entenderse con bases de datos de diferentes tipos. JDBC es el
mecanismo para hacer esto.
JDBC extiende
lo
que puede hacerse
con
Java. Por ejemplo,
con
Java y la API de JDBC, es posible
publicar una página web que usa información obtenida de una base de datos remota. O una compañía puede usar JDBC para conectar todos sus empleados (incluso si estos están usando un conglomerado
de máquinas Windows, Macintosh y UNÍS) a una o más bases de datos internas vía una intranet.
De una forma simple, JDBC posibilita hacer tres cosas:
• Establecer una conexión con una base de
datos
• Enviar sentencias SQL
• Procesar los resultados
§ Tipos de conectores JDBC
Los conectores o drivers
JDBC, se pueden dividir en cuatro tipos principalmente:
Tipo 1. JDBC-ODBC bridge
más driver ODBC: “BRIDGE”
Permite el acceso a Base de
Datos JDBC mediante un driver ODBC. Cada máquina cliente que use el puente,
debe tener librerías clientes de ODBC(dll propias del S.O)
Ventajas: Buena forma de aprender JDBC. También
puede ser buena idea usarlo, en sistemas donde cada máquina cliente tenga ya
instalado los drivers ODBC. También es posible que sea la única forma de
acceder a ciertos motores de Bases de Datos.
Inconvenientes: No es buena idea usar esta solución
para aplicaciones que exijan un gran rendimiento, ya que la transformación
JDBC-ODBC es costosa. Tampoco es buena solución para aplicaciones con alto
nivel de escalabilidad.
Tipo
2. Driver Java parciales: “NATIVE”
Traducen las llamadas al API
de JDBC Java en llamadas propias del motor de Base de Datos (Oracle,
Informix…). Al igual que el tipo anterior, exige en las máquinas clientes
código binario propio del cliente de la Base de datos específica y del sistema
operativo
Ventajas: Mejor rendimiento que el anterior.
Quizá puede ser buena solución para entornos controlados como intranets.
Ejemplo OCI oracle.
Inconvenientes: Principalmente la escalabilidad,
ya que estos drivers exigen que en la máquina cliente librerías del cliente de
la Base de Datos.
Tipo
3. Driver JDBC a través de Middleware: “NETWORK”
Traduce las llamadas al API
JDBC en llamadas propias del protocolo específico del broker. Éste se encargará
de traducirlas de nuevo en sentencias propias del motor de Base de Datos de
cada caso.
Ventajas: Buena solución cuando necesitamos
acceder a Bases de Datos distintas y se quiere usar un único driver JDBC para
acceder a las mismas. Al residir la traducción en el servidor del middleware,
los clientes no necesitan librerías específicas, tan solo el driver.
Inconvenientes: La desventaja principal reside en la configuración
del servidor donde se encuentra el middleware. Necesitará librerías específicas
para cada motor de base de datos distinto, etc.
Tipo
4: Driver java puro (acceso directo a Base de Datos): “THIN”.
Convierte o traduce las
llamadas al API JDBC en llamadas al protocolo de red usado por el motor de
bases de datos, lo que en realidad es una invocación directa al motor de bases
de datos.
Ventajas: 100 % portable. Buen rendimiento. El
cliente sólo necesita el driver.
Inconvenientes: Al ser independiente de la plataforma,
no aprovecha las características específicas del S.O
§
APLICACIONES
TestConnection.java : Aplicación que permite comprobar si se puede establecer
una conexión exitosa con la base de datos
Appl_01.java :
Aplicación que permite visualizar las tablas existentes dentro de la base de
datos.
Appl_02.java :
Aplicación que visualiza los discos e intérpretes dentro de la base de datos.
Appl_03.java :
Aplicación que permite crear una tabla con tres campos en la base de datos.
Appl_04.java :
Aplicación que permite agregar nuevo registro a la nueva tabla creada
anteriormente con Appl_03.java
La
clase DriverManager
|
La clase DriverManager implementa la
capa de gestión de JDBC, y trabaja como intermediaria entre el usuario y los
drivers. Guarda la lista de los drivers que están disponibles y establece la
conexión entre la base de datos y el driver apropiado. Además la clase
DriverManager se ocupa de cosas cómo gestionar los límites de tiempo de
‘login’ en el driver y de la salida de los mensajes de traza y log.
Para aplicaciones simples, el único
método en esta clase que necesita un programador general para su uso
directamente es DriverManager.getConnection. Como su nombre indica, este
método establece una conexión con la base de datos. JDBC permite al usuario
llamar a los métodos de DriverManager getDriver, getDrivers y registerDriver
así como al método de Driver connect, pero en la mayoría de los casos es
preferible dejar que la clase DriverManager gestione los detalles al
establecer la conexión.
Mantenimiento de la lista de drivers
disponibles.
La clase DriverManager mantiene una
lista de clases disponibles que han sido registrados mediante el método
DriverManager.registerDriver. Todas las clases Driver deben escribirse con
una sección estática que cree una instancia de la clase y luego la registre
en la clase DriverManager cuando se cargue. Además el usuario normalmente no
debería llamar a DriverManager.registerDriver directamente; debería llamarse
automáticamente por el driver cuando esté se carga,. Una clase Driver se
carga, y por tanto se registra, de dos formas diferentes:
1 Mediante una llamada al método
Class.forName. Este carga explícitamente la clase driver. Dado que no depende
de ningún ‘setup’ externo, esta forma de cargar drivers es la recomendada. El
siguiente código carga la clase acme.db.Driver:
Class.forName("acme.db.Driver");
Si acme.db.Driver se ha escrito para
que al cargar produzca una instancia y llame al método
DriverManager.registerDriver con esta instancia como argumento (es lo que
debería hacer), entonces este estará en la lista de drivers disponibles para
efectuar la conexión.
2 Mediante la adición del driver a la
propiedad jdbc.drivers de java.lang.System- Esta es una lista de nombres de
clases de drivers, separadas por dos puntos, que es la que carga la clase
DriverManager. Cuando la clase DriverManager se inicializa, mira en la
propiedad jdbc.drivers, y si el usuario ha introducido uno o más drivers, la
clase DriverManager intenta cargarlos. El siguiente código ilutsra como un
programador debería introducir estas tres clases en ~/.hotjava/properties
jdbc.drivers=foo.bah.Driver:wombat.sql.Driver:bad.test.ourDriver;
La primera llamada a el método
DriverManager hará que estos drivers se carguen automáticamente.
Notese que en esta segunda manera de
cargar los drivers es necesario una preparación del entorno que es
persistente. Si existe alguna duda sobre esto es preferible y más seguro
llamar al método Class.forName para cargar explicitamente cada driver. Este
es también el método que se usa para traer un driver particular puesto que
una vez que la clase DriverManager ha sido inicializada no chequeará la lista
de propiedades jdbc.drivers.
En ambos casos, es responsabilidad de
la clase Driver recién cargada registrarse a si misma mediante una llamada a
DriverManager.registerDriver. Como se ha mencionado anteriormente, esto
debería hacerse automáticamente al cargar la clase.
Por razones de seguridad, la capa de
gestión de JDBC guardará traza de que clases de cargadores provee cada
driver. Entonces cuando la clase DriverManager abre una conexión solo usará
los drivers que vienen desde el sistema de ficheros local o desde las mismas
clases cargadoras como el código que solicita la conexión.
Establecer una conexión
Una vez que la clase Driver ha sido
cargada y registrada con la clase DriverManager, se está en condiciones de
establecer la conexión con la base de datos. La solicitud de la conexión se
realiza mediante una llamada al método DriverManager.getConnection, y
DriverManager testea los drivers regsitrados para ver si puede establecer la
conexión.
A veces puede darse el caso de que más
de un driver JDBC pueda establecer la conexión para una URL dada. Por
ejemplo, cuando conectamos con una base de datos remota, podría ser posible
usar un driver puente JDBC-ODBC, o un driver JDBC de protocolo genérico de red,
o un driver suministrado por el vendedor.
En tales casos, el orden en que los driver son testeados es significante porque DriverManager usará el primer driver que encuentre que pueda conectar con éxito a la base de datos.
Primero DriverManager intenta usar
cada driver en el orden en que ha sido registrado ( los drivers listados en
la propiedad jdbc.drivers son siempre los registrados primero). Saltará
cualquier driver con código ‘untrusted’, a menos que se cargue desde el mismo
código fuente que el código que intenta abrir la conexión.
Testea los drivers mediante la llamada
al método Driver.connect cada uno por turno, pasándole como argumento la URL
que el usuario ha pasado originalmente al método DriverManager.getConnection.
El primer driver que reconozca la URL realiza la conexión.
Una primera ojeda puede parecer
insuficiente, pero son necesarias solo unas pocas llamadas a procedimientos y
comparaciones de cadena por conexión puesto que no es probable que haya
docenas de drivers se carguen concurrentemente.
El siguiente código es un ejemplo de
todo lo necesario normalmente para establecer una conexión con un driver
puente JDBC-ODBC:
lass.forName("sun.jdbc.odbc.JdbcOdbcDriver");
//loads the driver
String url = "jdbc:odbc:fred"; DriverManager.getConnection(url, "userID", "passwd"); |
§ Ejemplos
Ejemplos de acceso a bases de datos MySQL con Java y JDBC
Para
realizar los siguientes ejemplos de acceso a una base de datos supondremos lo
siguiente:
El
servidor de base de datos debe estar arrancado y suponemos que utiliza el
puerto por defecto (3306)
La base
de datos que vamos a utilizar se llama prueba con un
usuario root y contraseña 1daw.
La base
de datos tiene una tabla persona con tres campos:
id: smallint auto_increment primary key
nombre: varchar(60)
nacimiento: date
Ejemplo 1: Conexión a una base de datos MySQL y consulta de una tabla.
import java.sql.*;
public class EjemploAccesoBD1 {
public static void main(String[]
args) {
Connection
conexion = null;
try {
//
Cargar el driver
Class.forName("com.mysql.jdbc.Driver");
//
Se obtiene una conexión con la base de datos.
//
En este caso nos conectamos a la base de datos prueba
//
con el usuario root y contraseña 1daw
conexion = DriverManager.getConnection("jdbc:mysql://localhost/prueba",
"root", "1daw");
//
Se crea un Statement, para realizar la consulta
Statement
s = conexion.createStatement();
//
Se realiza la consulta. Los resultados se guardan en el ResultSet rs
ResultSet
rs = s.executeQuery("select * from persona");
//
Se recorre el ResultSet, mostrando por pantalla los resultados.
while
(rs.next()) {
System.out.println(rs.getInt("Id")
+ " " + rs.getString(2) + " " + rs.getDate(3));
}
} catch
(SQLException e) {
System.out.println(e.getMessage());
} catch
(ClassNotFoundException e) {
System.out.println(e.getMessage());
} finally
{ // Se cierra la conexión con la base de datos.
try
{
if
(conexion != null) {
conexion.close();
}
}
catch (SQLException ex) {
System.out.println(ex.getMessage());
}
}
}
}
Ejemplo 2: Crear una tabla e insertar datos.
Crearemos la tabla contactos dentro de la base de datos
prueba.
import java.sql.*;
public class EjemploAccesoBD2 {
public static void main(String[]
args) {
Connection
conexion = null;
try {
//
Cargar el driver
Class.forName("com.mysql.jdbc.Driver");
//
Se obtiene una conexión con la base de datos.
conexion =
DriverManager.getConnection("jdbc:mysql://localhost/prueba",
"root", "1daw");
//
Se crea un Statement, para realizar el query
Statement
s = conexion.createStatement();
//se
crea una tabla nueva
s.executeUpdate("CREATE
TABLE contacto (id INT AUTO_INCREMENT,
PRIMARY
KEY(id), nombre VARCHAR(20),
apellidos
VARCHAR(20), telefono VARCHAR(20))");
//Los
datos que vamos a insertar los tenemos en 3 arrays
String
nombres[] = {"Juan", "Pedro", "Antonio"};
String
apellidos[] = {"Gomez", "Lopez", "Alvarez"};
String
telefonos[] = {"987452154", "989654125",
"985321478"};
//se
insertan datos en la tabla
for
(int i = 0; i < nombres.length; i++) {
s.executeUpdate("INSERT
INTO contacto (nombre, apellidos, telefono)
VALUES
('" + nombres[i] + "','" + apellidos[i] + "','" +
telefonos[i] + "' )");
}
//
Se realiza una consulta sobre la tabla contacto.
ResultSet
rs = s.executeQuery("select * from contacto");
//
Se recorre el ResultSet, mostrando por pantalla los resultados.
while
(rs.next()) {
System.out.println(rs.getInt(1)
+ " " + rs.getString(2) + " " +
rs.getString(3)
+ " " + rs.getString(4));
}
} catch
(SQLException e) {
System.out.println(e.getMessage());
} catch
(ClassNotFoundException e) {
System.out.println(e.getMessage());
} finally {
// Se cierra la conexión con la base de datos.
try
{
if
(conexion != null) {
conexion.close();
}
}
catch (SQLException ex) {
System.out.println(ex.getMessage());
}
}
}
}
En la instrucción:
s.executeUpdate("INSERT INTO contacto (nombre,
apellidos, telefono)
VALUES
('" + nombres[i] + "','" + apellidos[i] + "','" +
telefonos[i] + "' )");
Las variables de tipo String que corresponden a los datos
de tipo VARCHAR de la tabla deben ir entre comillas simples.
Si la instrucción se hiciera con datos fijos sería:
INSERT INTO contacto (nombre, apellidos, telefono) VALUES
('Juan', 'Gomez', '987452154');
Las comillas no se escriben para datos numéricos.
Ejemplo 3: Modificar el teléfono del primer contacto de la tabla persona
con nombre Juan.
import java.sql.*;
public class EjemploAccesoBD3 {
public static void main(String[]
args) {
Connection
conexion = null;
int id;
try {
//
Cargar el driver
Class.forName("com.mysql.jdbc.Driver");
//
Se obtiene una conexión con la base de datos.
conexion =
DriverManager.getConnection("jdbc:mysql://localhost/prueba",
"root", "1daw");
//
Se crea un Statement, para realizar el query
Statement
s = conexion.createStatement();
//
Se realiza la consulta
//
Queremos obtener el id del primer contacto con nombre Juan
ResultSet
rs = s.executeQuery("SELECT id FROM contacto WHERE nombre='Juan'");
if(rs.next()){ //Si
rs.next() devuelve true significa que al menos hay un registro
id
= rs.getInt("id"); //se obtienen su id
//se
actualiza el registro
s.executeUpdate("UPDATE
contacto SET telefono='987654321' WHERE id="+id);
}
} catch
(SQLException e) {
System.out.println(e.getMessage());
} catch
(ClassNotFoundException e) {
System.out.println(e.getMessage());
} finally {
// Se cierra la conexión con la base de datos.
try
{
if
(conexion != null) {
conexion.close();
}
}
catch (SQLException ex) {
System.out.println(ex.getMessage());
}
}
}
}
2.
Resumen
Capa de Acceso de Datos, Creación
La API proporciona conectividad y acceso a datos en
toda la extensión de las bases de datos relacionales. JDBC generaliza las
funciones de acceso a bases de datos más comunes abstrayendo los detalles
específicos de una determinada base de datos. El resultado es un conjunto de
clases e interfaces, localizadas en el paquete java.sql, que pueden ser
utilizadas con cualquier base de datos que disponga del driver JDBC apropiado.
Acceso
de JDBC a Bases de Datos El API JDBC soporta dos modelos diferentes de acceso
a Bases de Datos, los modelos de dos y tres capas.
Modelo
de dos capas: Este
modelo se basa en que la conexión entre la aplicación Java o el applet que se
ejecuta en el navegador, se conectan directamente a la base de datos.
Modelo
de tres capas: En este
modelo de acceso a las bases de datos, las instrucciones son enviadas a una
capa intermedia entre Cliente y Servidor, que es la que se encarga de enviar
las sentencias SQL a la base de datos y recoger el resultado desde la base de
datos.
1. Importar los paquetes: Normalmente es suficiente con la
sentencia import java.sql.*;
2. Cargar el driver: El driver se debe cargar para poder
utilizarlo. Esto lo realiza el método estático forName() de la
clase Class.
Class.forName(String driver);
Driver JDBC para MySQL:
Class.forName("com.mysql.jdbc.Driver");
Lanza una
excepción ClassNotFoundException
3. Crear la conexión: Esto lo realiza el método estático getConnection() de
la clase DriveManager.
DriverManager.getConnection(String url);
url es un String que nos permite
localizar la base de datos.
Normalmente se compone de tres
campos:
jdbc:tipoBD:datos_de_conexion
Para MySQL, el formato es:
"jdbc:mysql://ordenador_donde_está_la_base_de_datos/base_de_datos".
4. Ejecutar una consulta: Las consultas se manejan mediante un objeto que
implementa la interface Statement.
Antes de poder ejecutar una
consulta debemos crear el objeto.
El objeto se crea utilizando el
método createStatement() de Connection.
Statement s =
conexion.createStatement();
Una vez creado podemos utilizar
algunos de los métodos de Statement para enviar la consulta a la BD.
5. Manipular el resultado de la
consulta: El objeto de tipo
ResultSet devuelto por la consulta de selección dispone de un cursor para
desplazarse por los registros y de métodos para acceder al valor de cada campo.
Desplazarse por los registros de
un ResultSet
Una vez obtenido, su cursor se
sitúa justo antes del primer registro obtenido.
Por defecto, un ResultSet
es un objeto de sólo avance y solo lectura. El recorrido se
hará siempre desde el principio hacia delante y los campos no podrán ser
modificados. Se pueden crear también ResultSets desplazables de
lectura/escritura.
El método next() permite desplazarnos por los
registros. Una llamada a este método desplaza el cursor al siguiente registro.
Devuelve false si se ha llegado al final y true en caso contrario.
while (rs.next()) {
.....
}
Acceder a los campos del
resultado de una consulta
Los campos del registro apuntado
por el cursor se pueden acceder mediante dos grupos de métodos. xxx es
cualquier tipo de dato básico Java más String, Date y Object.
6. Desconexión de la base de
datos: Permite liberar recursos de
memoria y CPU. El cierre de una conexión se realiza mediante el métodoclose() de
la interfaz Connection.
conexion.close();
§ Definición JDBC
JDBC es una API de Java para ejecutar sentencias SQL. (Como punto de interés, JDBC es
nombre de una marca registrada y no es un acrónimo, a pesar de todo, JDBC es a menudo interpretado
como “Java DataBase Connectivity”). Consta de un conjunto
de
clases e interfaces
escrito
en
lenguaje
de programación
Java.
§ Tipos de conectores JDBC
Los conectores o drivers
JDBC, se pueden dividir en cuatro tipos principalmente:
Tipo 1. JDBC-ODBC bridge
más driver ODBC: “BRIDGE”
Permite el acceso a Base de
Datos JDBC mediante un driver ODBC. Cada máquina cliente que use el puente,
debe tener librerías clientes de ODBC(dll propias del S.O)
Tipo
2. Driver Java parciales: “NATIVE”
Traducen las llamadas al API
de JDBC Java en llamadas propias del motor de Base de Datos (Oracle,
Informix…). Al igual que el tipo anterior, exige en las máquinas clientes
código binario propio del cliente de la Base de datos específica y del sistema
operativo
Tipo
3. Driver JDBC a través de Middleware: “NETWORK”
Traduce las llamadas al API
JDBC en llamadas propias del protocolo específico del broker. Éste se encargará
de traducirlas de nuevo en sentencias propias del motor de Base de Datos de
cada caso
Tipo
4: Driver java puro (acceso directo a Base de Datos): “THIN”.
Convierte o traduce las
llamadas al API JDBC en llamadas al protocolo de red usado por el motor de
bases de datos, lo que en realidad es una invocación directa al motor de bases
de datos.
§
APLICACIONES
TestConnection.java : Aplicación que permite comprobar si se puede
establecer una conexión exitosa con la base de datos
Appl_01.java :
Aplicación que permite visualizar las tablas existentes dentro de la base de
datos.
Appl_02.java :
Aplicación que visualiza los discos e intérpretes dentro de la base de datos.
Appl_03.java :
Aplicación que permite crear una tabla con tres campos en la base de datos.
Appl_04.java :
Aplicación que permite agregar nuevo registro a la nueva tabla creada
anteriormente con Appl_03.java
La
Clase DriverManager
La clase DriverManager implementa la
capa de gestión de JDBC, y trabaja como intermediaria entre el usuario y los
drivers. Guarda la lista de los drivers que están disponibles y establece la
conexión entre la base de datos y el driver apropiado. Además la clase
DriverManager se ocupa de cosas cómo gestionar los límites de tiempo de ‘login’
en el driver y de la salida de los mensajes de traza y log.
3. Summary
Data Access Layer, Creation
The API provides connectivity
and data access throughout the extent of relational databases. Generalizes JDBC
database access functions most common data abstracting the specifics of a
particular database. The result is a set of classes and interfaces, located in
the java.sql package, which can be used with any database that has the
appropriate JDBC driver.
Access to Databases JDBC The
JDBC API supports two different models of access to databases, models two and
three layers.
Two-layer model: This model is
based on the connection between the Java application or applet that runs in the
browser, connect directly to the database.
Three-layer model: In this
model of access to databases, the instructions are sent
to an intermediate
layer between client and server, which is what is responsible
for sending SQL
statements to the database and collect the result from the database.
1. Import packages
2. Load the driver
3. Create the connection
4. Run a query
5. Manipulate the query result
6. Disconnect from the database
§ Definition JDBC
JDBC is a Java API for executing SQL statements. (As a point of interest,
JDBC is a trademark name and is not an acronym, nevertheless, JDBC
is often interpreted as "Java DataBase Connectivity"). It consists of a set
of classes and interfaces written in the Java programming language.
§ Types of JDBC connectors
Connectors or JDBC drivers, can be mainly divided into four types:
Type 1 JDBC-ODBC bridge plus ODBC driver: "BRIDGE"
It allows access to JDBC database through an ODBC driver.
Each client machine that use the bridge, you must have ODBC client libraries (dll own S.O)
Type 2 Driver partial Java: "NATIVE"
JDBC Type 3 Driver through Middleware: "NETWORK"
Type 4: Pure Java Driver (Direct Access to Database): "THIN".
§ APPLICATIONS
TestConnection.java: Application that lets you check whether you can establish a successful
connection to the database
Appl_01.java: Application to visualize existing tables within the database.
Appl_02.java: An application that displays the disks and interpreters within the database.
Appl_03.java: Application that lets you create a table with three fields in the database.
Appl_04.java: An application that allows you to add new record to the new table created earlier with Appl_03.java
The DriverManager Class
The DriverManager class implements the JDBC management layer, and works as an intermediary
between the user and the drivers. Save the list of drivers that are available and establishes the connection
between the database and the appropriate driver. In addition, the DriverManager class deals with things how
to manage time limits 'login' in the driver and output of trace and log messages.
4.Recomendaciones
Ø 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.
Ø Conocemos la forma de conectar mysql o alguna base de datos como lo es Sql Server,
Oracle, PosgreSQL a java perousando lis driversManager una forma visual muy práctica
pero muy compleja a la hora de mandar la aplicación a alguna otra computadora, para
olvidarnos de esto y no tener un desorden de codificaciones visuales en el form crearemos
una clase de conexión, en ella realizaremos un métodos para la conexión y otros dos para
hacer las consultas y operaciones de insert y update a la base de datos.
Ø Antes de pensar siquiera en cómo implementar la nueva API, se optó por desarrollar
un caso de estudio que permitiese distinguir los verdaderos problemas asociados a la
creación de una aplicación distribuida del tipo propuesto. En este sentido, se planteó el
desarrollo de la aplicación Bank, una aplicación a la que se quería dotar de tolerancia a
fallos y continuidad en el servicio.
5.Conclusiones
Ø En una primera fase, el trabajo consistió, por un
lado, en documentar las técnicas que se utilizan a la hora de ofrecer
replicación en sistemas tolerantes a fallos, y por otro, en investigar cómo es
posible ofrecer tolerancia a fallos utilizando herramientas para comunicación
en grupo como JavaGroups.
Ø 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.
Ø Este estudio nos ha llevado a la creación de una
nueva API (javagroups.sql) capaz de ofrecer acceso distribuido a bases de datos
replicadas en múltiples servidores MySQL. Sin embargo, está nueva librería no
sustituye 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.
6.Apreciacion del Equipo
Ø Nuestra opinion en base del tema jdbc(Java Data Base Conectivy) es una aplicación que nos ofrece
muchas ventajas por otro lado tenemos a JDBC que nos brinda total libertad de hacer lo que queramos
sin ningún tipo de limitación explotando al máximo las características de la base datos. JDBC nos permite
realizar consultas nativas para cada base de datos lo que ayuda mucho a la velocidad de respuesta y los
resultados son devueltos en un ResultSet los cuales podemos extraer solamente los datos que requerimos
y no toda la Entity como en el caso de JPA o Hibernate.
7.Glosario
ResultSet: Los ResultSet son cursores de base de datos rápidos que admiten el enlace de datos
de interfaz de usuario, el desplazamiento hacia delante y hacia atrás, y la actualización de datos en
la base de datos. Como modelo de conexión permanente,ResultSet mantienen una conexión activa
a la base de datos.
Drivers: Un controlador de dispositivo o manejador de dispositivo (en inglés: device driver,
o simplemente driver)es unprograma informático que permite al sistema operativo interaccionar
con un periférico, haciendo una abstracción delhardware y proporcionando una interfaz
(posiblemente
estandarizada) para utilizar el dispositivo.
Protocolo: Conjunto de reglas de formalidad
que rigen los actos y ceremonias diplomáticos y oficiales. Conjunto de reglas
de cortesía que se siguen en las relaciones sociales y que han sido
establecidas por costumbre.
Interfaces: Interfaz es lo que conocemos en inglés como interface (“superficie de contacto”).
En informática se utiliza para nombrar a la conexión funcional entre dos sistemas o dispositivos
de cualquier tipo dando una comunicación entre distintos niveles. Su plural es interfaces.
Servidor: Un servidor, como la misma palabra indica, es un ordenador o máquina informática
que está al “servicio” de otras máquinas, ordenadores o personas llamadas clientes y que le
suministran a estos, todo tipo de información. A modo de ejemplo, imaginemos que estamos
en nuestra casa, y tenemos una despensa.
Método estático: También puede crear métodos estáticos que, como los atributos estáticos,
trabajan para la clase como un todo en lugar de para un objeto particular de la clase. En lugar
de hacer una función global que viva en y «contamine» el espacio de nombres global o local,
puede incluir el método dentro de la clase.
Usuario root : Muy sencillo, porque rootear implica que nosotros, como usuarios, nos hacemos
responsable de todo lo que ocurra en el teléfono. Es más las cuentas root no fueron diseñadas
para ser usadas como una cuenta de usuario normal si no para momentos puntuales para realizar
modificaciones en el sistema.
Plataforma: Superficie horizontal plana, descubierta y elevada, construida sobre una armazón
en el suelo u otra superficie mayor, que sirve de apoyo o base para algo.
Entorno integrado: Entorno de Desarrollo Integrado (IDE). Un entorno de desarrollo integrado,
es un entorno de programación que ha sido empaquetado como un programa de aplicación,
es decir, consiste en un editor de código, un compilador, un depurador y un constructor de interfaz
gráfica.
Java convencional: un programa convencional que se invoca desde el intérprete de comandos.
8.LINKOGRAFIA
https://kalistog.wordpress.com/jdbc/
Presentacion bien desarrollada.Trabajo bien elaborado.Ilustrar el trabajo. Proponga un foro de discusión sobre el tema.Defina bien las recomendaciones y conclusiones. Muchas gracias por su investigación. Gracias. Saludos
ResponderEliminar