Materia: Programación III
Profesor: Mango Eduardo
Universidad Tecnológica Nacional
API JDBC
Conexión a bases de datos
1. Introducción a JDBC
JDBC (Java Database Connectivity) es una API de Java que permite la conexión y
manipulación de bases de datos relacionales. JDBC proporciona un conjunto de interfaces y
clases para interactuar con bases de datos de manera uniforme, independientemente del
proveedor del sistema de base de datos.
2. Componentes Principales de JDBC
1. DriverManager: Gestiona los drivers de bases de datos y establece conexiones.
2. Connection: Representa la conexión a la base de datos.
3. Statement: Permite ejecutar sentencias SQL estáticas.
4. PreparedStatement: Similar a Statement, pero precompilado para mayor eficiencia
y seguridad contra inyección SQL.
5. CallableStatement: Permite la ejecución de procedimientos almacenados en la
base de datos.
6. ResultSet: Representa el resultado de una consulta SQL y permite iterar sobre los
datos recuperados.
Existen cuatro tipos de controladores JDBC:
1. Driver JDBC-ODBC Bridge (Tipo 1): Usa ODBC para conectarse a la base de datos
a través de un puente entre JDBC y ODBC. Sin embargo, este enfoque introduce
una capa adicional de comunicación, lo que lo hace más lento y menos seguro.
Debido a estas limitaciones, ha sido marcado como obsoleto en versiones recientes
de Java.
2. Driver Nativo (Tipo 2): Utiliza librerías nativas del sistema operativo y del DBMS
para comunicarse con la base de datos. Este tipo de driver ofrece un mejor
rendimiento que el Tipo 1, pero requiere la instalación de librerías específicas en
cada cliente, lo que complica su portabilidad.
3. Driver de Protocolo de Red (Tipo 3): Se comunica con un servidor intermediario
(middleware), que a su vez se encarga de conectar con la base de datos. Este
enfoque facilita la conectividad en entornos distribuidos y permite mayor
escalabilidad, pero introduce una capa adicional de latencia debido a la
comunicación con el middleware.
4. Driver 100% Java (Tipo 4): Implementado completamente en Java, este driver se
conecta directamente a la base de datos a través del protocolo de red nativo del
DBMS. Es el más utilizado en aplicaciones modernas debido a su portabilidad,
rendimiento y facilidad de implementación sin necesidad de librerías externas.
3. Configuración Básica de JDBC
Ejemplo de conexión a una base de datos MySQL:
public class JDBCDemo {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/mi_base";
String usuario = "root";
String contrasena = "password";
try (Connection conexion = DriverManager.getConnection(url,
usuario, contrasena);
Statement stmt = conexion.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM usuarios"))
{
while (rs.next()) {
System.out.println("ID: " + rs.getInt("id") + " Nombre:
" + rs.getString("nombre"));
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
4. Uso de Statement, PreparedStatement y
CallableStatement
4.1 Statement
Se usa para ejecutar sentencias SQL estáticas.
Principales métodos:
● executeQuery(String sql): Ejecuta una consulta SELECT y devuelve un
ResultSet.
● executeUpdate(String sql): Ejecuta sentencias INSERT, UPDATE o DELETE
y devuelve el número de filas afectadas.
● execute(String sql): Ejecuta una consulta genérica y devuelve un booleano
indicando si hay un ResultSet.
Statement stmt = conexion.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM usuarios");
while (rs.next()) {
System.out.println("ID: " + rs.getInt("id") + " Nombre: " +
rs.getString("nombre"));
}
4.2 PreparedStatement
Se usa para consultas dinámicas y seguras contra inyección SQL.
Principales métodos:
● setInt(int parameterIndex, int value): Establece un valor entero en la
posición indicada.
● setString(int parameterIndex, String value): Establece un valor de
tipo String.
● executeQuery(): Ejecuta una consulta SELECT y devuelve un ResultSet.
● executeUpdate(): Ejecuta sentencias INSERT, UPDATE o DELETE.
String sql = "SELECT * FROM usuarios WHERE id = ?";
PreparedStatement pstmt = conexion.prepareStatement(sql);
pstmt.setInt(1, 1);
ResultSet rs = pstmt.executeQuery();
while (rs.next()) {
System.out.println("ID: " + rs.getInt("id") + " Nombre: " +
rs.getString("nombre"));
}
4.3 CallableStatement
Se usa para ejecutar procedimientos almacenados en la base de datos.
Principales métodos:
● setInt(int parameterIndex, int value): Establece un valor entero.
● setString(int parameterIndex, String value): Establece un valor String.
● registerOutParameter(int parameterIndex, int sqlType): Registra un
parámetro de salida.
● execute(): Ejecuta el procedimiento almacenado.
● getInt(int parameterIndex): Obtiene un valor de salida entero.
● getString(int parameterIndex): Obtiene un valor de salida String.
CallableStatement cstmt = conexion.prepareCall("{call
obtener_usuario(?)}");
cstmt.setInt(1, 1);
ResultSet rs = cstmt.executeQuery();
while (rs.next()) {
System.out.println("ID: " + rs.getInt("id") + " Nombre: " +
rs.getString("nombre"));
}
5. Uso de ResultSet
El ResultSet permite iterar sobre los datos devueltos por una consulta SQL.
Principales métodos:
● next(): Mueve el cursor a la siguiente fila.
● getInt(String columnLabel): Obtiene un valor entero de una columna
específica.
● getString(String columnLabel): Obtiene un valor String.
● getBoolean(String columnLabel): Obtiene un valor booleano.
while (rs.next()) {
int id = rs.getInt("id");
String nombre = rs.getString("nombre");
System.out.println("ID: " + id + ", Nombre: " + nombre);
}
6. Pool de Conexiones y HikariCP
Las conexiones a bases de datos son costosas en términos de tiempo y recursos. Para
mejorar el rendimiento, se usa un pool de conexiones, que mantiene conexiones abiertas y
las reutiliza cuando son necesarias. HikariCP es una de las implementaciones más rápidas
y eficientes.
6.1 Configuración de HikariCP en un Proyecto Java
1. Agregar la dependencia en pom.xml (si usas Maven):
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>5.0.1</version>
</dependency>
2. Configurar el pool de conexiones:
public class HikariCPDemo {
public static void main(String[] args) {
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mi_base");
config.setUsername("root");
config.setPassword("password");
config.setMaximumPoolSize(10);
HikariDataSource dataSource = new HikariDataSource(config);
try (Connection conexion = dataSource.getConnection();
Statement stmt = conexion.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM usuarios"))
{
while (rs.next()) {
System.out.println("ID: " + rs.getInt("id") + " Nombre:
" + rs.getString("nombre"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
dataSource.close();
}
}
}
7. Conclusión
JDBC es una herramienta fundamental para interactuar con bases de datos en Java. Sin
embargo, debido a la carga que implica la apertura y cierre de conexiones, es
recomendable utilizar un pool de conexiones como HikariCP para mejorar el rendimiento y
la escalabilidad de las aplicaciones.
