EXPERTO EN JAVA

Módulo 2: Java SE 7 Programmer II

Unidad 12
JDBC
 Módulo 2: Unidad 12. JDBC

ÍNDICE
1. INTRODUCCIÓN ...................................................................................................................................................... 3
2. ESTRUCTURA DE ACCESO A DATOS JAVA ........................................................................................................ 3
2.1. MODELO DE OBJETOS DENTRO DE JDBC.............................................................................................................................. 4
2.1.1. DriverManager ............................................................................................................................................................................. 4
2.1.2. Conexión ........................................................................................................................................................................................... 4
2.1.3. Sentencias........................................................................................................................................................................................ 5
2.1.4. ResultSet........................................................................................................................................................................................... 6
2.1.5. ResultSetMetaData ..................................................................................................................................................................... 8
2.2. CONFIGURANDO EL ACCESO A DATOS ................................................................................................................................... 8
2.2.1. Ejemplo de consultas de acción .......................................................................................................................................... 10
2.2.2. Ejemplo de consultas de selección .................................................................................................................................... 11
2.2.3. Ejemplo consulta de MetaDatos......................................................................................................................................... 12
2.2.4. Ejemplo consultas parametrizadas.................................................................................................................................. 14
2.2.5. Ejemplo consultas a procedimientos almacenados ................................................................................................. 16
2.2.6. RowSet ............................................................................................................................................................................................ 17

EXPERTO EN JAVA 2
 Módulo 2: Unidad 12. JDBC

1. INTRODUCCIÓN
La mayoría de las aplicaciones escritas en Java giran en torno a la lectura y
actualización de información de bases de datos, independientemente del entorno para
el que hayan sido creadas. Para permitir la integración de datos en aplicaciones
distribuidas y escalables, Java utiliza una tecnología de acceso a datos
denominada JDBC
El problema es comunicar un programa o aplicación con una base de datos y, más
que comunicar, pretender que el programa o aplicación realice una serie de procesos
u operaciones con la base de datos.
Existen múltiples formas de comunicarnos y trabajar con acceso a datos, que veremos
en módulos posteriores del curso.

2. ESTRUCTURA DE ACCESO A DATOS JAVA

JDBC (Java DataBase Connectivity) es un API de Java que permite al programador el
acceso a Bases de Datos usando el lenguaje estándar SQL.
Las tres acciones principales que nos proporciona JDBC son:
• Establecer la conexión con la base de datos.
• Enviar sentencias SQL a esa base de datos.
• Procesar los resultados obtenidos de la base de datos.

Java soporta dos modelos de acceso a bases de datos:

1. Modelo de dos capas
La aplicación Java se conecta directamente a la base de datos.
Será necesario contar con el driver JDBC específico para conectarse con la base de
datos.
La propia base de datos proporcionará el driver de conexión y el driver debe estar
dentro del sistema local de nuestra aplicación de acceso a datos.
La base de datos puede estar alojada en cualquier otro equipo y accederíamos a ella
mediante una conexión de red.

EXPERTO EN JAVA 3
 Módulo 2: Unidad 12. JDBC

Esta es la configuración típica Cliente/Servidor. El programa cliente envía

instrucciones SQL a la base de datos, ésta los procesa y envía los resultados de vuelta
a la aplicación.

2. Modelo de tres capas

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
los resultados.
Los driver JDBC no tienen por qué residir en la máquina local.

2.1. Modelo de objetos dentro de JDBC

En la tecnología JDBC existen una serie de objetos que son los que nos permitirán
poder recuperar o modificar datos.
Dichos objetos son jerárquicos, es decir, dependen unos de otros para realizar el
acceso a una base de datos.
El paquete para poder acceder a datos dentro de aplicaciones java es:

El modelo de objetos JDBC incluye los siguientes elementos.

2.1.1. DriverManager
Es el objeto que será el encargado de registrar el driver en nuestra aplicación. Dicha
clase tiene métodos estáticos que nos permitirán registrar el driver de la base de datos
o nos permitirán poder crear objetos de conexión para acceder a los datos.
Para poder registrar el driver en la aplicación, será necesario que el driver esté en
nuestro proyecto, ya sea con rutas relativas o absolutas.

2.1.2. Conexión
Para poder realizar una conexión, necesitamos un objeto de la clase Connection.
La característica más importante de cualquier conexión es la cadena de acceso a la
base de datos. Dependiendo de la base de datos, la cadena de conexión variará en
función del puerto o nombre de base de datos o usuarios.
Algunos ejemplos de cadenas de conexión a las bases de datos más populares son:

EXPERTO EN JAVA 4
 Módulo 2: Unidad 12. JDBC

Cadena de conexión para Oracle

jdbc:oracle:thin:@NOMBRESERVIDOR:PUERTO:BBDD

Cadena de conexión para SQL Server

jdbc:sqlserver://SERVIDOR:PUERTO;databaseName=BBDD;user=USUARIO;password
=PASS

Cadena de conexión para MySql

Server=SERVIDOR;Port=PUERTO;Database=BBDD;Uid=USER;Pwd=PASS;

El objeto Connection es el encargado de abrir conexiones para la lectura o escritura

de datos o de las transacciones cuando realizamos consultas de acción sobre
los registros.
Para instanciar un objeto Connection, necesitamos el método getConnection() de la
clase DriverManager. Por ejemplo:

2.1.3. Sentencias
Las sentencias nos permiten realizar consultas sobre la base de datos, ya sean
consultas de selección o consultas de acción a los registros.
Una sentencia depende de una conexión. Solamente podremos crearnos sentencias
si tenemos un objeto Connection instanciado.
Existen tres tipos de objetos para realizar sentencias:
• Statement: Son consultas simples. No contienen parámetros en las consultas. La
sentencia debe estar escrita en el código.
• PreparedStatement: Sentencia para realizar consultas parametrizadas. Contiene
una serie de métodos para administrar los parámetros de las consultas y ejecutar
las sentencias. La posición de los parámetros de la consulta se realiza por orden
de izquierda a derecha.
• CallableStatement: Objeto sentencia que nos permite llamar a Procedimientos
almacenados o paquetes de la base de datos. Admite parámetros en la llamada.

EXPERTO EN JAVA 5
 Módulo 2: Unidad 12. JDBC

Independientemente del tipo de Sentencia, tenemos varios métodos para acceder a

los datos, dependiendo de si nuestras consultas son de selección o son consultas
de acción.
Los métodos más importantes de las sentencias son los métodos para
ejecutar consultas:
• Consultas de selección: Devuelven un objeto ResultSet con el contenido de
la consulta.
ObjetoSentencia.executeQuery();

• Consultas de acción: Devuelve un entero que representa el número de registros

que han sido afectados por la consulta de acción.
ObjetoSentencia.executeUpdate();

• Consultas que no devuelven ni modifican registros: Devuelve un boolean indicando

si la acción se ha llevado a cabo o no.
ObjetoSentencia.execute();

2.1.4. ResultSet
El objeto ResultSet sirve para almacenar los registros devueltos por una sentencia en
una consulta de selección.
No se puede instanciar el objeto, la forma de crear un ResultSet es mediante una
sentencia y el método executeQuery().
Un objeto ResultSet es, por defecto, un objeto Forward Only y Read Only, es decir,
solamente podemos recorrerlo hacia una dirección, si deseamos volver a leer un
registro, debemos volver a ejecutar la consulta.
El cursor se mueve una fila hacia abajo cada vez que se llama al método next().
Inicialmente se sitúa antes de la primera fila, por lo que hay que llamar al método next
para situarlo en la primera fila, convirtiéndola en la fila actual. Las filas del ResultSet
se recuperan en secuencia desde la fila más alta a la más baja, hasta que el método
next devuelve false.
Los métodos de posicionamiento del ResultSet propagan una excepción
SQLException.
• next(): Posiciona el cursor en la línea siguiente a partir de la línea actual. Devuelve
true si el cursor se ha podido situar en una fila y false si se ha posicionado después
de la última fila o si no hay filas para leer.

EXPERTO EN JAVA 6
 Módulo 2: Unidad 12. JDBC

• previous(): Posiciona el cursor en la línea anterior respecto a la actual. Devuelve

true si el cursor se ha podido colocar en una fila y false si se ha posicionado antes
de la primera fila.
• first(): Posiciona el cursor en la primera línea contenida en el objeto ResultSet.
Devuelve true si el cursor se ha podido colocar en la primera fila y false si el objeto
ResultSet no contiene ninguna fila.
• last(): Posiciona el cursor en la última fila contenida en el objeto ResultSet.
Devuelve true si el cursor se ha podido colocar en la última fila y false si el objeto
ResultSet no contiene ninguna fila.
• absolute(índice): Se posiciona el cursor en la fila establecida por el índice enviado
como parámetro. La posición de la primera fila comienza en 1.
• afterLast(): Posiciona el cursor después de la última fila que podamos leer.
• beforeFirst(): Posiciona el cursor antes de la primera fila para la lectura de
una consulta.

Además de los métodos de posicionamiento en filas de consulta, tenemos métodos

para preguntar la posición del cursor.
• isAfterLast(): Indica si el cursor está posicionado después de la última fila.
• isBeforeFirst(): Indica si el cursor está posicionado antes de la primera fila.
• isFirst(): Devuelve true si el cursor está posicionado en la primera fila.
• isLast(): Devuelve true si el cursor está en la última fila.
• getRow(): Devuelve un índice que representa la posición de la fila en la que está
situado el cursor.

Dentro del ResultSet podemos recuperar datos de la consulta Select enviada. Los
datos se recuperan mediante métodos GET, una vez que el cursor se ha posicionado
en una fila determinada.
Podemos recuperar el dato a partir del nombre de la columna o a partir del índice de
la columna, sabiendo que el primer índice de la columna de una consulta es 1.
Existe un método get para cada tipo de dato. Su sintaxis sería getTipoDato(), es decir,
getString(), getBoolean(), getInt(), getDouble()…
Un objeto ResultSet no verifica el valor del dato que recupera, si puede convertirlo,
realizará la conversión de forma automática, es decir, si recuperamos una columna de
tipo Date con el método getString(), se convierte el dato recuperado a la clase String.

EXPERTO EN JAVA 7
 Módulo 2: Unidad 12. JDBC

El método para terminar de leer una consulta es el método close().

Otra de las características que nos puede devolver un ResultSet es la información de
los metadatos de una consulta, es decir, los datos relativos a las columnas o los tipos
de datos que contienen dichas columnas. El método para recuperar la información
metadata es getResultSetMetaData().

2.1.5. ResultSetMetaData
Es una clase que nos permite acceder a la información de las columnas de una
consulta Select. Entre la información que podemos extraer del objeto podemos
destacar el nombre de las columnas, el tipo de dato de las columnas o el número de
columnas de una consulta.
La forma de instanciar un objeto ResultSetMetaData es mediante un objeto ResultSet
y su método getResultSetMetaData().
Los métodos más importantes de la clase son:
• getColumnCount(): Devuelve el número de columnas de la consulta de
una sentencia.
• getColumnName(indice): Devuelve el nombre de la columna que corresponde con
un índice, comenzando dicho índice en 1.
• getColumnTypeName(índice): Devuelve un String que representa el tipo de dato
de una columna que corresponde con el índice indicado.

2.2. Configurando el acceso a datos

Para poder realizar acceso a datos, necesitamos el driver de la base de datos. En
nuestros ejemplos utilizaremos la base de datos Oracle Express, es gratuita y
podemos descargarla de la siguiente dirección:
http://www.oracle.com/technetwork/database/database-technologies/express-
edition/overview/index.html

Para descargarnos el último driver de acceso a Oracle debemos conectarnos a la

siguiente dirección:
http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-
090769.html

EXPERTO EN JAVA 8
 Módulo 2: Unidad 12. JDBC

Vamos a configurar un entorno de desarrollo para poder acceder a datos. Nuestro

usuario en Oracle es SYSTEM (no diferencia mayúscula de minúsculas) y nuestro
password será java.
Usuario: SYSTEM
Password: java
Lo primero será crearnos un nuevo proyecto del tipo Java Application al que
llamaremos JDBC.
A continuación, copiaremos a la carpeta de nuestro proyecto el driver para
conectarnos, el archivo ojdbc14.jar. Lo haremos mediante el sistema de archivos de
nuestro sistema operativo.

Una vez que hemos copiado el driver, debemos irnos al IDE de NetBeans y agregar a
nuestro proyecto el archivo jar.
En nuestro proyecto, sobre la carpeta Libraries, seleccionamos la opción Add
JAR/Folder.

EXPERTO EN JAVA 9
 Módulo 2: Unidad 12. JDBC

Seleccionamos el driver de la carpeta de nuestro proyecto y deberíamos de ver

seleccionada la opción Relative Path.

Ahora que tenemos nuestro proyecto configurado, podemos crear la primera

aplicación de acceso a datos.

2.2.1. Ejemplo de consultas de acción

Nos creamos una clase llamada ConsultasAccion.java que insertará un nuevo registro
en la tabla DEPT.

EXPERTO EN JAVA 10
 Módulo 2: Unidad 12. JDBC

Y el resultado es:

2.2.2. Ejemplo de consultas de selección

Nos creamos una clase llamada ConsultasSeleccion.java que se encargará de leer
todos los apellidos de la tabla empleados, mostrándolos por pantalla.

EXPERTO EN JAVA 11
 Módulo 2: Unidad 12. JDBC

Veremos el resultado al ejecutar la aplicación:

2.2.3. Ejemplo consulta de MetaDatos

Nos crearemos una clase llamada MetaDatos.java y mostraremos la información de
una consulta que mostrará todos los datos de la tabla HOSPITAL.

EXPERTO EN JAVA 12
Módulo 2: Unidad 12. JDBC

EXPERTO EN JAVA 13
 Módulo 2: Unidad 12. JDBC

Y el resultado lo podremos comprobar en pantalla:

2.2.4. Ejemplo consultas parametrizadas

Para realizar consultas con parámetros se utiliza un objeto PreparedStatement.
Cada parámetro en la consulta está representado por un símbolo de interrogación.
El orden de los parámetros comienza en 1 y se establece de izquierda a derecha
según aparezcan los parámetros en la consulta. Los parámetros se añaden al objeto
PreparedStatement mediante el método setTipoDato(), que nos pedirá la posición y el
valor del parámetro en la cabecera del método.
Por ejemplo, si tenemos la siguiente consulta:

La posición de los parámetros será:

ObjetoPreparedStatement.setString(1, “VALOR CAMPO 1”);
ObjetoPreparedStatement.setString(2, “VALOR CAMPO 2”);
Para visualizar mejor sus características, nos crearemos una clase que se encargará de
modificar los datos de una persona de la tabla PLANTILLA.
Nos crearemos una clase llamada ConsultaParametrizada.java

EXPERTO EN JAVA 14
Módulo 2: Unidad 12. JDBC

EXPERTO EN JAVA 15
 Módulo 2: Unidad 12. JDBC

2.2.5. Ejemplo consultas a procedimientos almacenados

Para realizar una consulta a un procedimiento almacenado, necesitamos un objeto de
la clase CallableStatement.
La sintaxis para llamar a un procedimiento es la siguiente:

Las interrogaciones representan los parámetros que tiene un

procedimiento almacenado.
Vamos a realizar un procedimiento almacenado que incrementará el salario de la
plantilla de un hospital. Dicho procedimiento recibirá dos parámetros, uno para el
código del hospital y otro para el incremento.
Abrimos Oracle y creamos el siguiente procedimiento almacenado:

Ahora nos crearemos una clase en Java llamada ProcedimientosAlmacenados.java.

EXPERTO EN JAVA 16
 Módulo 2: Unidad 12. JDBC

Y el resultado será:

Nota: Aunque ponga que los salarios incrementados han sido 0, el procedimiento ha
podido modificar filas. Los procedimientos almacenados en la base de datos Oracle
Express no devuelven el conjunto de resultados afectados por la consulta de acción.

2.2.6. RowSet
Son elementos desconectados dentro de la tecnología JDBC.
La nueva API hereda de ResultSet y Connection, un RowSet contiene una mezcla de
los dos, administra las conexiones y las sentencias en un único objeto.
Su funcionalidad está en las consultas de selección, aunque también puede realizar
consultas de acción.
El objeto ROWSET es la interfaz que hereda del ResultSet.

EXPERTO EN JAVA 17
 Módulo 2: Unidad 12. JDBC

Gestionan la conexión automáticamente.

Se recorren igual que un ResultSet. (NEXT, ABSOLUTE, FIRSTROW, LASTROW)
El método POPULATE de ResultSet podría cargar los datos en un RowSet.
Todas las implementaciones de RowSet permiten el movimiento por las filas y las
posiciones de la consulta por defecto.
Para realizar una instancia de un objeto RowSet se utiliza la clase RowSetProvider.
El registro del driver debe ser exactamente igual, lo que cambia es la creación de la
conexión, que está interna dentro del RowSet.

El paquete para los objetos RowSet está dentro de javax.sql.rowset.*;

Ejemplo de creación de un objeto RowSet:

Para establecer la conexión con la base de datos para ejecutar consultas se realiza
de la siguiente forma:

Mediante el método setCommand() se cargan las consultas dentro del objeto.

Mediante el método execute(), se realiza la carga de los datos en un objeto RowSet.
Vamos a realizar un ejemplo que llamaremos LecturaRowSet.java en la que leeremos
todos los registros de la tabla DOCTOR, mostrando su apellido y su especialidad.

EXPERTO EN JAVA 18
Módulo 2: Unidad 12. JDBC

EXPERTO EN JAVA 19
 Módulo 2: Unidad 12. JDBC

Y veremos el resultado de la aplicación:

EXPERTO EN JAVA 20