UP | HOME

Aplicaciones Java que acceden a bases de datos

Índice

En este apartado vamos a entrar de lleno en la programación de aplicaciones escritas en Java que hacen uso de bases de datos.

Vamos a usar el SGBD SQLite por ser una base de datos en fichero que nos permite ir directos al grano y no necesitamos configurar un servidor de base de datos como en los casos de MariaDB o MySQL, por ejemplo.

A lo largo de esta sección vamos a explicar los pasos para poner en marcha una aplicación con una base de datos sencilla. Esta aplicación consiste en un TODO list, es decir una aplicación para la gestión de una lista de tareas por hacer.

La base de datos se va a llamar todolist.db, sin más.

SQLite: base de datos en un fichero

¿Qué significa que SQLite es una base de datos en un fichero? Pues como intuyes, significa que toda la base de datos se encuentra almacenada en un fichero.

Tenemos que decidir dónde va a estar alojado este fichero. Como vamos a usar proyectos de Gradle una buena localización o lugar donde dejar la base de datos, el fichero, es app/data. Dado que la base de datos se va a llamar todolist.db, la vamos a dejar en el fichero app/data/todoslist.db.

DB Browser para SQLite

dbbrowser.png

Vamos a usar el programa DB Browser para SQLite que nos permite acceder por medio de una aplicación gráfica a bases de datos SQLite. Basta con abrir el fichero de la base de datos para poder gestionarla desde la aplicación así como visualizar datos.

Base de datos a usar en este apartado/ejemplo

Así, antes de dar comienzo con la aplicación TODO List puedes abrir DB Browser y crear la base de datos con una única tabla llamada tasks cuyo Modelo Relacional será el siguiente:

tasks(id, description, done)
    PK: id
    VNN: id, description, done

Es decir, la tabla, como ya se ha comentado se llama tasks y los campos:

  • id es la clave primaria, autoincremental de tipo numérico.
  • description de tipo text y no puede ser nulo.
  • done de tipo numérico (0 = tarea no hecha; 1 = tarea hecha) y no puede ser nulo. Valo por defecto 0.

Creando el proyecto de Gradle: driver SQLite

Una vez creado el proyecto de Gradle, recuerda: gradle init, tenemos que añadir como dependencia el driver de SQLite. La forma de hacerlo se divide en dos partes:

  1. Añadir la información de la dependencia al fichero gradle/libs.versions.toml:
[versions]
sqlite = "3.53.4.0"

[libraries]
sqlite = { module = "org.xerial:sqlite-jdbc", version.ref = "sqlite" }
  1. Incluir la dependencia en app/build.gradle.kts haciendo alusión a la versión añadida al fichero anterior:
dependencies {
    implementation(libs.sqlite)
}

En clase escribiremos el proyecto completo. Aquí os muestro el código base para poder trabajar con bases de datos en Java.

Conexión a una base de datos SQLite

Lo primero que se debe hacer para trabajar con una base de datos es conectarse a ella. Cuando se termine se tiene que cerrar al base de datos.

Antiguamente, e includo todavía lo verás en código moderno, se usaba la clase DriverManager para establecer la conexión con una base de datos. Nosotros vamos a usar la interfaz DataSource. Dado que vamos a usar SQLite, usaremos la clase SQLiteDataSource que implementa DataSource de la librería org.sqlite.

El código está comentado y faltan los import siguientes:

  • import java.sql.SQLException;
  • import java.sql.Connection;
  • import org.sqlite.SQLiteDataSource;
// Se crea un objeto SQLiteDataSource
SQLiteDataSource dataSource = new SQLiteDataSource();

// Se configura la URL de la base de datos.
// Dado que es una base de datos SQLite solo hay que indicar la ruta relativa
// al fichero de la base de datos: data/todolist.db.
dataSource.setUrl("jdbc:sqlite:data/todolist.db");

// Conectamos usando un try-with-resource para liberar la conexión
// de format automática.
try (Connection conn = dataSource.getConnection()) {
    // resto del código
} catch (SQLException e) {
    // tratamiento de la excepción
}

Insertar, eliminar y actualizar registros en una base de datos

Tanto para insertar (INSERT), como para eliminar (DELETE) y actualizar (UPDATE) se utiliza la misma estructura. En clase se proporcionarán los detalles y se aclararán los conceptos.

El código que ves a continuación es de un INSERT y parte del código del apartato anterior. Se comentan las líneas con el código nuevo:

SQLiteDataSource dataSource = new SQLiteDataSource();
dataSource.setUrl("jdbc:sqlite:data/todolist.db");

try (Connection conn = dataSource.getConnection()) {

    // Creamos un String con la sentencia INSERT SQL.
    // Fíjate que se usan los comodines y marcadores ? donde irán los valores.
    // En clase se explica por qué es necesario usar sentencia preparadas.
    String sql = "INSERT INTO tasks (description, done) VALUES (?, ?)";

    // Con un try-with-resource nos evitamos tener que liberar los recurso de la
    // sentencia preparada.
    try (PreparedStatement pstmt = conn.prepareStatement(sql)) {

        // Los valores de descripción y hecho que vamos a insertar vienen de
        // la línea de comandos, por eso están en el array args habitual.
        String desc = args[0];
        boolean done = Boolean.valueOf(args[1]);

        // Tenemos dos marcadores o comodines ?, en el primero ponemos la
        // descripción y en el segundo el valor booleano de hecho.
        pstmt.setString(1, desc);
        pstmt.setBoolean(2, done);

        // Con la sentencia preparada lista, pasamos a ejecutarla.
        // Se usa método executeUpdate para sentencias insert, delete y update
        // de SQL.
        int result = pstmt.executeUpdate();

        // Una sentencia ejecutada con executeUpdate devuelve el número de
        // registros insertados, eliminados o actualizados.
        // Lo imprimimos por pantalla.
        System.out.println("Se han insertado " + result + " registros a la base de datos");
    }

} catch (SQLException e) {
    e.printStackTrace();
}

Ejecutar SELECT y manejar ResultSet

En clase se darán detalles de lo que ves aquí pero, básicamente, cuando se hace una consulta SELECT para recabar información de una base de datos se obtienen los resultados en un objeto de tipo ResultSet que es un puntero a los registros obtenidos. Este puntero se mueve o desplaza de registro a registro con el método next() como ves en el siguiente ejemplo:

SQLiteDataSource dataSource = new SQLiteDataSource();
dataSource.setUrl("jdbc:sqlite:data/todolist.db");

try (Connection conn = dataSource.getConnection()) {

    String sql = "SELECT id, description, done FROM tasks";

    // Aquí vamos a usar Statement en vez de PreparedStatement.
    // Para crear la Statement lo hacemos con el Connection también.
    try (Statement stmt = conn.createStatement()) {

        // Ahora se ejecuta la query y se obtiene el objeto ResultSet
        ResultSet result = stmt.executeQuery(sql);

        System.out.println("Lista de tareas a realizar:");

        // Vamos moviendo el "puntero" result para recorrer los registros
        // obtenidos como resultado de la SELECT.
        while (result.next()) {
            int id = result.getInt(1);
            String desc = result.getString(2);
            boolean done = result.getBoolean(3);

            System.out.println("- " + id + ": " + desc + " [" + done + "]");
        }
    }

} catch (SQLException e) {
    e.printStackTrace();
}

Autor: Román Ginés Martínez Ferrández

Created: 2026-10-28 mié 20:28

Validate