Java Tip 20: JDBC (2da parte)

Continuamos con esta serie sobre JDBC.

Como dijimos la vez anterior JDBC(Java Database Connectivity) es el estándar de conectividad de bases de datos de Java y proporciona un mecanismo para que los programas Java se conecten a las bases de datos.

En este post veremos ejemplos de su uso.

Requisitos:

• Tener nociones de Java. 
• Tener nociones de SQL (usaremos H2).
• Tener nociones de Maven.

Creando una aplicación JDBC

Crearemos una sencilla aplicación que se conecte a una BD H2 (ver tutorial).

Pasos:

1. Crearemos una tabla a la que llamaremos Cursos. La cual tendrá los siguientes campos: id, titulo, materia, instructor, fecha y hora.
2. Crear la aplicación Java usando Maven.
3. Crearemos instrucciones SQL para consultar la información, ingresar nuevos cursos, actualizar y eliminar registros.
4. Ejecutar la aplicación con Maven.

1. Creamos la tabla con sus seis campos (agregaremos los datos con la aplicación Java):

CREATE OR REPLACE TABLE CURSOS(
   id bigint auto_increment,
   titulo varchar(255) not null,
   materia varchar(255) not null,
   instructor varchar(255) not null,
   fecha date,
   hora time
);

Es importante tener H2 instalado, si no lo tienes puedes ir al sitio oficial: https://www.h2database.com/html/main.html

2. Creamos la aplicación Java con Maven (al final nos ubicamos en el directorio creado):

$ mkdir pruebasJDBC
$ cd pruebasJDBC
$ mvn archetype:generate -DgroupId=com.comunidad.cityjava -DartifactId=proyecto-jdbc -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
$ cd proyecto-jdbc

Una vez creado podemos abrirlo con un editor de código, Eclipse IDE o con Visual Studio Code. Nosotros elegiremos este último.

3. Abrimos el archivo ``pom.xml`` y agregamos la dependencia de H2:

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>2.1.210</version> 
</dependency>

Podemos mosificarlo para que pueda ejecutar la aplicación desde consola:

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.comunidad.cityjava</groupId>
  <artifactId>proyecto-jdbc</artifactId>
  <packaging>jar</packaging>
  <version>1.0</version>
  <name>proyecto-jdbc</name>
  <url>http://maven.apache.org</url>

   <properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>


  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>2.2.224</version> 
</dependency>
  </dependencies>

   <build>
    
       <plugins>
         <plugin>
          <groupId>org.codehaus.mojo</groupId>
          <artifactId>exec-maven-plugin</artifactId>
          <version>1.4.0</version>
          <configuration>
            <mainClass>com.comunidad.cityjava.App</mainClass>
          </configuration>
        </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.11.0</version>
        <configuration>
          <release>21</release>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

4. Modificar la clase ``App.java``. Incluiremos un método estático para hacer las operaciones SQL de inserción, consulta, actualización y borrado de registros.

package com.comunidad.cityjava;

import java.sql.*;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Arrays;
import java.util.List;
import com.comunidad.cityjava.model.Curso;
import static java.lang.System.out;
import static java.lang.System.err;

public class App {
    private final List<Curso> cursos;

    public App() {
        LocalDate fecha = LocalDate.now();
        LocalTime hora = LocalTime.now();
        cursos = Arrays.asList(
            new Curso(0L, "Programando con Java y H2", "Programacion Java", fecha, hora, "Pedro Alvarez"),
            new Curso(0L, "Programando con PL/SQL", "Bases de datos", LocalDate.of(2025, 9, 2), hora, "Marianna Avila"),
            new Curso(0L, "Introduccion a CISCO", "Redes y computo", LocalDate.of(2025, 3, 4), LocalTime.of(12, 30), "Jose Juan Vaquero")
        );
    }

    public static void main(String[] args) {
        try {
            conexionConH2();
        } catch (SQLException sqe) {
            err.printf("Ha ocurrido una excepción SQL: %s\n", sqe.getMessage());
            SQLException next = sqe.getNextException();
            if (next != null) err.printf("Siguiente excepción: %s\n", next.getMessage());
        } catch (Exception ex) {
            err.printf("Excepción general: %s\n", ex.getMessage());
            ex.printStackTrace();
        }
    }

    public static void conexionConH2() throws SQLException, ClassNotFoundException {
        Class.forName("org.h2.Driver");

        try (Connection connect = DriverManager.getConnection("jdbc:h2:~/test", "sa", "")) {
            out.println("\t 1. Insertamos datos a la tabla cursos.");
            String insertData = "INSERT INTO CURSOS(titulo, materia, instructor, fecha, hora) VALUES (?,?,?,?,?)";
            try (PreparedStatement psInsert = connect.prepareStatement(insertData)) {
                for (Curso item : new App().cursos) {
                    psInsert.setString(1, item.getTitulo());
                    psInsert.setString(2, item.getMateria());
                    psInsert.setString(3, item.getInstructor());
                    psInsert.setObject(4, item.getFecha());
                    psInsert.setObject(5, item.getHora());
                    psInsert.executeUpdate();
                }
            }

            out.println("\t 2. Consultamos la tabla cursos.");
            String selectData = "SELECT id, titulo, materia, instructor, fecha, hora FROM CURSOS";
            try (Statement st = connect.createStatement();
                 ResultSet rs = st.executeQuery(selectData)) {
                while (rs.next()) {
                    out.printf("ID: %d | Título: %s | Materia: %s | Instructor: %s | Fecha: %s | Hora: %s\n",
                        rs.getInt("id"),
                        rs.getString("titulo"),
                        rs.getString("materia"),
                        rs.getString("instructor"),
                        rs.getObject("fecha"),
                        rs.getObject("hora"));
                }
            }

            out.println("\t 3. Actualizamos un registro de la tabla cursos.");
            String updateData = "UPDATE CURSOS SET instructor = ? WHERE instructor = ?";
            try (PreparedStatement psUpdate = connect.prepareStatement(updateData)) {
                psUpdate.setString(1, "Marianna Avila Malvaez");
                psUpdate.setString(2, "Marianna Avila");
                psUpdate.executeUpdate();
            }

            out.println("\t 4. Borramos un registro de la tabla cursos.");
            String deleteData = "DELETE FROM CURSOS WHERE id = ?";
            try (PreparedStatement psDelete = connect.prepareStatement(deleteData)) {
                psDelete.setInt(1, 1);
                psDelete.executeUpdate();
            }

            out.println("\t Hecho.");
        }
    }
}

¿Qué podemos notar en este código?

• Hemos usado la clase ``Connection`` para la conexión a la BD H2. 
• Hemos usado la clase ``DriverManager`` la cual roporciona el método getConnection() para establecer la conexión JDBC. 
• Hemos usado la clase ``PreparedStatement`` la cual permite ejecutar sentencias SQL parametrizadas (INSERT, UPDATE, DELETE). 
• Hemos usado la clase ``Statement`` la cual ejecuta sentencias SQL simples (SELECT). 
• Hemos usado la clase ``ResultSet`` la cual contiene los resultados de una consulta SQL (SELECT). 
• Hemos usado la clase ``SQLException`` que maneja errores relacionados con operaciones SQL.

Todas del paquete java.sql.  Cabe notar que todas las conexiones se auto cierran al terminar la ejecución del código. Y así cumplimos las 4 fases anteriormente dichas en el post anterior.

5. Compilar y ejecutamos la aplicación:

$ mvn clean install 
$ mvn exec:java

Salida:

         1. Insertamos datos a la tabla cursos.
         2. Consultamos la tabla cursos.
ID: 1 | Título: Programando con Java y H2 | Materia: Programacion Java | Instructor: Pedro Alvarez | Fecha: 2025-10-12 | Hora: 13:45:29
ID: 2 | Título: Programando con PL/SQL | Materia: Bases de datos | Instructor: Marianna Avila | Fecha: 2025-09-02 | Hora: 13:45:29
ID: 3 | Título: Introduccion a CISCO | Materia: Redes y computo | Instructor: Jose Juan Vaquero | Fecha: 2025-03-04 | Hora: 12:30:00
         3. Actualizamos un registro de la tabla cursos.
         4. Borramos un registro de la tabla cursos.
         Hecho.

JDBC es una alternativa a las conexiones a BD con Java. Sin embargo, existen otras que son más modernas como el uso de Hibernate, MyBatis, Spring Data, etc.

Enlaces:

https://comunidadcityjavamex.blogspot.com/2024/09/java-tip-17-jdbc-1era-parte.html
https://www.h2database.com/
https://www.arquitecturajava.com/jdbc-prepared-statement-y-su-manejo/
https://www.tutorialspoint.com/h2_database/h2_database_jdbc_connection.htm