¿Qué es JDBC? Introducción a la conectividad de bases de datos de Java

JDBC (Java Database Connectivity) es la API de Java que administra la conexión a una base de datos, emite consultas y comandos y maneja conjuntos de resultados obtenidos de la base de datos. Lanzado como parte de JDK 1.1 en 1997, JDBC fue uno de los primeros componentes desarrollados para la capa de persistencia de Java.

JDBC se concibió inicialmente como una API del lado del cliente, lo que permite que un cliente Java interactúe con una fuente de datos. Eso cambió con JDCB 2.0, que incluía un paquete opcional que admite conexiones JDBC del lado del servidor. Cada nueva versión de JDBC desde entonces ha presentado actualizaciones tanto para el paquete del lado del cliente ( java.sql) como para el paquete del lado del servidor ( javax.sql). JDBC 4.3, la versión más actual al momento de escribir este artículo, se lanzó como parte de Java SE 9 en septiembre de 2017.

Este artículo presenta una descripción general de JDBC, seguida de una introducción práctica al uso de la API de JDBC para conectar un cliente Java con SQLite, una base de datos relacional liviana.

Cómo funciona JDBC

Desarrollado como una alternativa a la API ODBC (Open Database Connectivity) basada en C, JDBC ofrece una interfaz a nivel de programación que maneja la mecánica de las aplicaciones Java que se comunican con una base de datos o RDBMS. La interfaz JDBC consta de dos capas:

  1. La API JDBC admite la comunicación entre la aplicación Java y el administrador JDBC.
  2. El controlador JDBC admite la comunicación entre el administrador JDBC y el controlador de la base de datos.

JDBC es la API común con la que interactúa el código de su aplicación. Debajo está el controlador compatible con JDBC para la base de datos que está utilizando.

La Figura 1 es una descripción general de la arquitectura de JDBC en la capa de persistencia de Java.

JavaWorld /

Usar JDBC para conectarse a una base de datos

Uno de los hechos afortunados de la programación en el ecosistema de Java es que probablemente encontrará un conector de base de datos JDBC estable para cualquier base de datos que elija. En este tutorial usaremos SQLite para conocer JDBC, principalmente porque es muy fácil de usar.

Los pasos para conectarse a una base de datos con JDBC son los siguientes:

  1. Instale o ubique la base de datos a la que desea acceder.
  2. Incluya la biblioteca JDBC.
  3. Asegúrese de que el controlador JDBC que necesita esté en su classpath.
  4. Utilice la biblioteca JDBC para obtener una conexión a la base de datos.
  5. Utilice la conexión para emitir comandos SQL.
  6. Cierre la conexión cuando haya terminado.

Repasaremos estos pasos juntos.

Encontrar un controlador JDBC

Para encontrar un controlador para la base de datos que desea utilizar, simplemente haga una búsqueda web para su base de datos y JDBC. Por ejemplo, al escribir " mysql jdbc driver" aparecerá un controlador para MySQL. ¡Lo desafío a encontrar una base de datos compatible con Java sin un controlador JDBC!

Paso 1. Descargue e instale SQLite

SQLite es una base de datos muy compacta. No está diseñado para uso en producción, pero es una excelente opción para probar cosas rápidamente. SQLite utiliza un archivo como base de datos funcional, sin requerir ningún servicio o instalación de demonios.

Para comenzar con esta demostración, descargue la base de datos de muestra SQLite. Descomprima el .dbarchivo y guárdelo en un lugar que no olvidará.

Este archivo contiene una base de datos funcional basada en archivos y un esquema y datos de muestra que podemos usar.

SQL y JDBC

NoSQL se ha vuelto popular durante la última década, pero las bases de datos relacionales siguen siendo el tipo de almacén de datos más común en uso. Una base de datos relacional es un repositorio estructurado que consta de tablas con columnas y filas. SQL (Structured Query Language) es el lenguaje que utilizan los arquitectos de datos para hacer cosas como crear, leer, actualizar y eliminar nuevos registros en una base de datos relacional. JDBC es una capa adaptadora de Java a SQL: brinda a los desarrolladores de Java una interfaz común para conectarse a una base de datos, emitir consultas y comandos y administrar respuestas.

Paso 2. Importe JDBC a su aplicación Java

Podríamos hacer nuestra codificación en un IDE, pero codificar directamente en un editor de texto demostrará mejor la simplicidad de JDBC. Para comenzar, necesitará tener una instalación JDK compatible para su sistema operativo.

Suponiendo que tenga instaladas las herramientas de desarrollo de la plataforma Java, podemos comenzar creando un programa Java simple. En su editor de texto, pegue el código que se muestra en el Listado 1. Llame a este archivo WhatIsJdbc.java.

Listado 1. Un programa Java simple

 class WhatIsJdbc{ public static void main(String args[]){ System.out.println("Hello JavaWorld"); } } 

Ahora compilar el código introduciendo el comando: javac WhatIsJdbc.java. La compilación generará el WhatIsJdbc.classarchivo. Ejecutar este archivo desde la línea de comandos con la llamada: java WhatIsJdbc.

[Consulte "¿Qué es el JDK? Introducción al Java Developer Kit" para obtener más información sobre cómo interactuar con el JDK en la línea de comandos.]

Una vez que tenga un programa Java básico, puede incluir las bibliotecas JDBC. Pegue el código del Listado 2 al comienzo de su programa Java simple.

Listado 2. Importaciones de JDBC

 import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.ResultSet; import java.sql.Statement; 

Cada una de estas importaciones proporciona acceso a una clase que facilita la conexión estándar de la base de datos Java:

  • Connection representa la conexión a la base de datos.
  • DriverManagerobtiene la conexión a la base de datos. (Otra opción es DataSourceutilizar para la agrupación de conexiones).
  • SQLException maneja los errores de SQL entre la aplicación Java y la base de datos.
  • ResultSety Statementmodelar los conjuntos de resultados de datos y las declaraciones SQL.

Veremos cada uno de estos en acción en breve.

Paso 3. Agregue el controlador JDBC a su classpath

A continuación, agregará el controlador SQLite a su classpath. Un controlador JDBC es una clase que implementa la API JDBC para una base de datos específica.

Descargue el controlador SQLite de GitHub. Asegúrese de obtener el .jararchivo más reciente y guárdelo en un lugar que recuerde.

The next time you execute your Java program, you will pull that .jar file in via the classpath. There are several ways to set the classpath. Listing 3 shows how to do it using a command-line switch.

Listing 3. Executing SQLite driver on the Java classpath

 java.exe -classpath /path-to-driver/sqlite-jdbc-3.23.1.jar:. WhatIsJdbc 

Notice that we've set the classpath to point at the driver and the local directory; this way Java will still find our class file.

Step 4. Obtain a database connection

The classpath now has access to the driver. Now, change your simple Java application file to look like the program in Listing 4.

Listing 4. Using the JDBC Connection class to connect to SQLite

 import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.ResultSet; import java.sql.Statement; class WhatIsJdbc{ public static void main(String[] args) { Connection conn = null; try { String url = "jdbc:sqlite:path-to-db/chinook/chinook.db"; conn = DriverManager.getConnection(url); System.out.println("Got it!"); } catch (SQLException e) { throw new Error("Problem", e); } finally { try { if (conn != null) { conn.close(); } } catch (SQLException ex) { System.out.println(ex.getMessage()); } } } } 

Compile and execute this code. Assuming all goes well, you will get an affirming message.

No suitable driver found?

If you've received an error that looks like "No suitable driver found for jdbc:sqlite," then you need to revisit the classpath and make sure it points to the driver you downloaded. Failed driver connection is the most common stumbling block for beginners using JDBC. Don't sweat it; just fix it.

Now we're ready for some SQL commands.

Step 5. Query the database

With the live connection object in hand, we can do something useful, like querying the database. Listing 5 shows how to query SQLite using the JDBC Connection and Statement objects.

Listing 5. Querying the database with JDBC

 import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.ResultSet; import java.sql.Statement; class WhatIsJdbc{ public static void main(String[] args) { Connection conn = null; try { String url = "jdbc:sqlite:path-to-db-file/chinook/chinook.db"; conn = DriverManager.getConnection(url); Statement stmt = null; String query = "select * from albums"; try { stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(query); while (rs.next()) { String name = rs.getString("title"); System.out.println(name); } } catch (SQLException e ) { throw new Error("Problem", e); } finally { if (stmt != null) { stmt.close(); } } } catch (SQLException e) { throw new Error("Problem", e); } finally { try { if (conn != null) { conn.close(); } } catch (SQLException ex) { System.out.println(ex.getMessage()); } } } } 

In Listing 5 we use our Connection object to obtain a Statement object: conn.createStatement(). We then use this object to execute an SQL query: stmt.executeQuery(query).

The executeQuery command returns a ResultSet object, which we then use to iterate over the data with while (rs.next()). In this example, you should see the album titles we've queried on as output.

Notice that we also closed the connection, via a call to conn.close().

Network connections with JDBC

The database connection string in Listing 5 is for a local connection: jdbc:sqlite:path-to-db-file/chinook/chinook.db. To access the database via a network, the connection string would need to include the network URL and (usually) credentials for accessing it.

Doing more with JDBC

So far we've covered the basics of using JDBC to connect to a database and issue SQL commands. While Statementss and ResultSets work well for common scenarios, you'll likely need additional options for larger or more complex applications. Fortunately, the JDBC library continues evolving to meet most database access needs.

PreparedStatements

One easy way to increase the flexibility of your code is to replace the Statement class with PreparedStatement, as shown in Listing 6.

Listing 6. Using JDBC PreparedStatements

 String prepState = "insert into albums values (?, ?);"; PreparedStatement prepState = connection.prepareStatement(sql); prepState.setString(1, "Uprising"); prepState.setString(2, "Bob Marley and the Wailers "); int rowsAffected = preparedStatement.executeUpdate(); 

PreparedStatement replaces Statement's hard-coded values with question marks (?). Using PreparedStatements optimizes your code for reuse: a PreparedStatement is compiled only once, and can then be reused with a variety of parameters. As your code base grows, you simply insert new values into the statement, instead of hacking the string object itself.

Batch updates

Whenever an application has several updates to issue, doing them in batches can greatly benefit performance. The essence of batching is to take the multiple updates and collect them together, then issue them all at once. Listing 7 uses JDBC's batch methods to perform a batch update of several PreparedStatements.

Listing 7. Batching with PreparedStatement

 prepState.setString(1, "Uprising"); prepState.setString(2, "Bob Marley and the Wailers"); preparedStatement.addBatch(); prepState.setString(1, "Wildflowers"); prepState.setString(2, "Tom Petty and the Heartbreakers"); preparedStatement.addBatch(); int[] rowsAffected = preparedStatement.executeBatch(); 

JDBC transactions

Transactions in relational databases allow for a set of updates to be wrapped in an interaction that either succeeds or fails altogether. The basics of using a transaction via JDBC are to tell the system to turn off auto-commit, and then manually tell the system to commit when you are done. By default, auto-commit is on, which means whenever an executeUpdate or executeInsert is run, the command is committed.

Listing 8 shows a small slice of a JDBC transaction.

Listing 8. JDBC transactions

 connection.setAutoCommit(false); // Use executeUpdate multiple times connection.commit(); 

When connection.commit() is encountered, all the updates wrapped inside will be attempted, and if any fail, they all will be rolled back.

There are many more features in JDBC 4.3 worth exploring, including using CallableStatement for stored procedures, using DataSource objects for improved application performance (especially via connection pooling), and converting a JDBC ResultSet to a Java Stream.

Database-specific features

Although every JDBC-compliant database offers the same core features for connecting and interacting with a database via SQL, some databases do more than others. As an example, Oracle DB offers result caching, which is not required by the JDBC specification. Here's an example:

 conn.prepareStatement ("select /*+ result_cache */ * from employees where employee_id < : 1"); 

This example is taken from the documentation for Oracle's JDBC OCI Driver.

Conclusion

JDBC is one of Java's oldest APIs, providing an easy-to-use solution for one of the perennial needs of Java application development. Knowing just the few JDBC calls demonstrated in this article will get you started using JDBC to connect to virtually any database. Once you've got those commands down, you can begin to explore some of the more sophisticated options that have been built into JDBC.

Si bien JDBC es suficiente para aplicaciones más simples, la mayoría de los desarrolladores eventualmente buscarán la API de persistencia de Java (JPA) para desarrollar una capa de acceso a datos más formal. JPA requiere más trabajo inicial y una comprensión más sofisticada de la arquitectura de la aplicación, pero le proporciona una capa de acceso a datos más consistente, aislada y bien definida. Consulte el complemento de este artículo, "¿Qué es JPA? Introducción a la API de persistencia de Java" para obtener más información sobre el desarrollo de la capa de persistencia de datos para sus aplicaciones Java.

Esta historia, "¿Qué es JDBC? Introducción a la conectividad de bases de datos de Java" fue publicada originalmente por JavaWorld.