Conexión a Bases de Datos

JDBC

Es el acrónimo de Java Database Connectivity, un 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.

Por tanto JDBC permite:

Conectar con una fuente de datos.
Enviar consultas y actualizaciones a la base de datos.
Procesar los resultados obtenidos de la base de datos en respuesta a una consulta
 Conexión a Bases de Datos

Podemos trabajar con diferentes sistemas de gestión de bases de datos:

ORACLE, Postgres, MySQL, etc

Sólo necesitamos una librería de conexión a esa base de datos.
ODBC es el equivalente en Microsoft.
Para poder conectarse a la BD y lanzar queries, es preciso tener
un driver adecuado para ello
Un driver suele ser un fichero .jar que contiene una implementación de todas las interfaces del
API de JDBC
 Conexión a Bases de Datos

Independencia de la BD

Idealmente, si nuestra aplicación cambia de BD, no necesitamos cambiar el código;

simplemente, necesitamos otro driver.
Sin embargo, desafortunadamente las Bds relacionales usan distintos dialectos de SQL
(a pesar de que en teoría es un estándar)
Tipos de datos: varían mucho según la BD
Generación de identificadores: secuencias, autonumerados, etc.
 Conexión a Bases de Datos

Pasos de JDBC

Siete pasos básicos en el uso de JDBC

Cargar el controlador (driver)
Definir el URL de la Conexión
Establecer la conexión
Crear un objeto Statement
Ejecutar una consulta (query)
Procesar los resultados
Cerrar la conexión
 Conexión a Bases de Datos

Cargar el driver
Para poder acceder a la base de datos...

En primer lugar, cargar el driver de conexión:

Para establecer una conexión:

Connection con = DriverManager.getConnection(url,nombreUsuario,password);
url -> ruta de acceso a los datos.
nombreUsuario -> Usuario para acceder a la base de datos.
password -> Clave de acceso.
 Conexión a Bases de Datos

Ejemplo:
 Conexión a Bases de Datos
Creación de sentencias SQL...
Utilización de executeUpdate.
Utilizamos este método con sentencias SQL que modifiquen la definición de la base de datos
(sentencias DDL = Data Definition language) o los datos (DML = Data Manipulation Language
diferentes de SELECT):
Creación de tablas.
Eliminación de tablas.
Actualización de tablas.
Inserción, borrado y actualización de datos.
Para sentencias que no supongan una modificación de los datos:
executeQuery.
SELECT.
 Conexión a Bases de Datos
Añadir datos a una tabla:
Se utiliza el objeto Statement con su método executeUpdate(SentenciaSQL).

La tabla COFFEES quedaría:

 Conexión a Bases de Datos
Recuperación de datos de las tablas.
Por ejemplo:
SELECT COF_NAME, PRICE FROM COFFEES
Lo primero que necesitamos es ejecutar la sentencia:
stm.executeQuery("SELECT COF_NAME, PRICE FROM COFFEES");
Esta sentencia devuelve un objeto de tipo ResultSet:
ResultSet set = stm.executeQuery("SELECT COF_NAME ...");
Este objeto tiene el conjunto resultante de la consulta.
Para movernos por las filas de ese conjunto resultante, utilizamos el concepto de cursor.
Para mover el cursor a lo largo de los registros, utilizamos el método next del objeto
ResultSet.
La primera vez que invocamos este método, el cursor se sitúa en la primera fila o primer
registro, sucesivas llamadas a dicho método hacen avanzar el cursor.
 Conexión a Bases de Datos
Recuperación de datos de las tablas.
Para acceder a cada uno de los campos de cada registro utilizamos métodos del tipo:
getXXXX(nombreCampo) del objeto ResultSet.
Por ejemplo, para acceder al campo COF_NAME, como es de tipo string, utilizamos
rs.getString(“COF_NAME”).
Para acceder al precio -> rs.getFloat (“PRICE”);
Por tanto para recorrer un conjunto de datos hay 2 formas:
 Conexión a Bases de Datos
Actualización de tablas

Si queremos seguir modificando datos, por ejemplo actualizando tablas:

String updateString = "UPDATE COFFEES "
+ "SET SALES = 75 “ + "WHERE COF_NAME LIKE 'Colombian%' ";
stm.executeUpdate(updateString);
En este caso, el método devuelve un valor entero que indica el número de filas actualizadas.
 Conexión a Bases de Datos
Utilizar Sentencias Prepared

La característica principal de un objeto PreparedStatement es que al contrario

que un objeto Statement, se le entrega una sentencia SQL cuando se crea. La
ventaja de esto es que en la mayoría de los casos, esta sentencia SQL se enviará al
controlador de la base de datos inmediatamente, donde será compilado. Como
resultado, el objeto PreparedStatement no sólo contiene una sentencia SQL, sino
una sentencia SQL que ha sido precompilada. Esto significa que cuando se ejecuta
la PreparedStatement, el controlador de base de datos puede ejecutarla sin tener
que compilarla primero.
 Conexión a Bases de Datos
Crear un Objeto PreparedStatement

Al igual que los objetos Statement, se crea un objeto PreparedStatement con un

objeto Connection. Utilizando nuestra conexión con abierta anteriormente, podríamos escribir
lo siguiente para crear un objeto PreparedStatement que tome dos parámetros de entrada:

PreparedStatement updateSales = con.prepareStatement(

"UPDATE COFFEES SET SALES = ? WHERE COF_NAME LIKE ?");

updateSales.setInt(1, 75);
updateSales.setString(2, "Colombian");
Ejemplo.
PreparedStatement updateSales = con.prepareStatement(
"UPDATE COFFEES SET SALES = ? WHERE COF_NAME LIKE ? ");
updateSales.setInt(1, 75);
updateSales.setString(2, "Colombian");
updateSales.executeUpdate();
 Conexión a Bases de Datos
Valores de retorno del método executeUpdate.

Siempre que executeQuery devuelve un objeto ResultSet que contiene los

resultados de una petición al controlador de la base datos, el valor devuelto por
executeUpdate es un int que indica cuántas líneas de la tabla fueron actualizadas.
Por ejemplo, el siguiente código muestra el valor de retorno de executeUpdate
asignado a la variable n:

updateSales.setInt(1, 50);
updateSales.setString(2, "Espresso");
int n = updateSales.execute Update();
// n = 1 ya que únicamente una línea se ha cambiado.
 Conexión a Bases de Datos
import java.sql.*;
public class ConexionBDMySQL_1 {
public static void main(String args[]){
try {
//Cargar clase de controlador de base de datos
Class.forName(” com.mysql.jdbc.Driver”);

//Crear el objeto de conexion a la base de datos

Connection conexion = DriverManager.getConnection(
”jdbc:mysql://localhost/ejemplo?user=root&password=”);

//Crear objeto Statement para realizar queries a la base de datos

Statement instruccion = conexion.createStatement();

//Un objeto ResultSet, almacena los datos de resultados de una consulta

ResultSet tabla = instruccion.executeQuery(”SELECT cod , nombre FROM datos”);
System.out.println(”Codigo\tNombre”);

while(tabla.next())
System.out.println(tabla.getInt(1)+”\t”+tabla.getString(2));
}
catch(ClassNotFoundException e){ System.out.println(e);
}
catch(SQLException e) { System.out.println(e);
}
catch(Exception e){ System.out.println(e);
}
}
}
 Conexión a Bases de Datos
CallableStatement

El objeto de tipo CallableStatement se utiliza para ejecutar procedimientos almacenados

(stored procedures) SQL. La API de JDBC provee una sintaxis para que todos los
procedimientos almacenados sean llamados de la misma manera en los diferentes sistemas
manejadores de bases de datos. Dicha sintaxis provee una manera que incluye un parámetro
de resultado y otra manera que no incluye dicho parámetro. Si el parámetro es utilizado, debe
ser registrado como un parámetro OUT. Los parámetros restantes pueden ser utilizados para
entrada, salida o ambos. Los parámetros son referenciados a través de un número secuencial,
empezando por 1. Las sintaxis son:
{?= call <nombre_del_procedimiento_almacenado>[<arg1>,<arg2>, ...]}
{call < nombre_del_procedimiento_almacenado >[<arg1>,<arg2>, ...]}

Los valores de los parámetros IN (de entrada) están establecidos por los métodos setXXX()
heredados de PreparedStatement. Los tipos de todos los parámetros OUT (de salida) deben
ser registrados ejecutando el procedimiento almacenado, sus valores son recuperados
después de la ejecución a través de los métodos getXXX() que provee CallableStatement.

Un objeto CallableStatement también puede regresar un objeto ResultSet o múltiples objetos

ResultSet. En este último caso, los múltiples objetos ResultSet son manejados por métodos
heredados de Statement.
 Conexión a Bases de Datos
CallableStatement

1-Preparamos el callablestatement usando Connection.prepareCall().

CallableStatement cStmt = conn.prepareCall("{call demoSp(?, ?)}");

cStmt.setString(1, "abcdefg");

2-Registramos los parámetros de salida (si existen)

cStmt.registerOutParameter(2, Types.INTEGER);
cStmt.registerOutParameter("inOutParam", Types.INTEGER);

3-Especificamos los parámetros de entrada (si existen)

cStmt.setString(1, "abcdefg");
cStmt.setString("inputParameter", "abcdefg");
cStmt.setInt(2, 1);
cStmt.setInt("inOutParam", 1);
 Conexión a Bases de Datos
CallableStatement

4-Ejecutamos CallableStatement , y recibimos cualquier conjunto de resultados o parámetros

de salida.

cStmt.execute();
final ResultSet rs = cStmt.getResultSet();

while (rs.next()) {
...
}

int outputValue = cStmt.getInt(1);

outputValue = cStmt.getInt("inOutParam");
 Conexión a Bases de Datos
CallableStatement (Cursor)

String getDBUSERCursorSql = "{call getDBUSERCursor(?,?)}";

try {
dbConnection = getDBConnection(); callableStatement = dbConnection.prepareCall(getDBUSERCursorSql);
callableStatement.setString(1, "mkyong");
callableStatement.registerOutParameter(2, OracleTypes.CURSOR);

callableStatement.executeUpdate();

ResultSet rs = (ResultSet) callableStatement.getObject(2);

` while (rs.next()) {

String userid = rs.getString("USER_ID");

String userName = rs.getString("USERNAME");
String createdBy = rs.getString("CREATED_BY");
String createdDate = rs.getString("CREATED_DATE");

System.out.println("UserName : " + userid);

System.out.println("UserName : " + userName);
System.out.println("CreatedBy : " + createdBy);
System.out.println("CreatedDate : " + createdDate);

}
} catch (SQLException e) {
System.out.println(e.getMessage());
}