Establecimiento de conexiones

Conectores o Drivers

El API JDBC viene distribuido en dos paquetes:

  • java.sql, dentro de J2SE
  • javax.sql, extensión dentro de J2EE

Un conector o driver es un conjunto de clases encargadas de implementar las interfaces del API y acceder a la base de datos. Para poder conectarse a una base de datos y lanzar consultas, una aplicación necesita tener un conector adecuado. Un conector suele ser un fichero .jar que contiene una implementación de todas las interfaces del API JDBC. Cuando se construye una aplicación de base de datos, JDBC oculta los detalles específicos de cada base de datos, de modo que le programador se ocupe sólo de su aplicación. El conector lo proporciona el fabricante de la base de datos o bien un tercero. El código de nuestra aplicación no depende del driver, puesto que trabajamos contra los paquetesjava.sql y javax.sql. JDBC ofrece las clases e interfaces para:

  • Establecer una conexión a una base de datos.
  • Ejecutar una consulta.
  • Procesar los resultados.

Los cuatro pasos a seguir

  • Importar el paquete jar de JDBC que se necesite, en el caso de MariaDB se descarga aquí: website

    Este es el que he probado

  • Agregarlo a tu proyecto de Eclipse: enlace

  • Importar lo necesario en código fuente o registrar el driver de conexión con .forname():

try {
   Class.forName("oracle.jdbc.driver.OracleDriver");
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}
  • Crear el objeto de conexión –> se va más adelante.

Componer la URL de conexión

Antes de obtener el objeto de conexión necesitamos la información necesaria para la conexión. Para la url de la conexión a la base de datos necesitamos crear un String con las siguientes partes:

  • Protocolo: jdbc
  • Tipo de sistema gestor de base de datos: oracle, mysql, mariadb, db2 etc…
  • Servidor o hostname: localhost si estáis en local.
  • Puerto.
  • Base de datos a conectarse.

Ejemplo:

  // url para un sgbd de mysql en local utilizando el puerto 3306 y conectandose a la bd hola
  String sURL = "jdbc:mysql://localhost:3306/hola";

Hay más opciones podéis verlas en este ejemplo

Obtener objeto de conexión -> conectarse

Una vez que tenemos lista la URL a partir del método estático getConnection() de la clase DriveManager podemos obtener el objeto que utilizaremos para conectarnos a la base de datos. Tiene tres firmas el método:

  • getConnection(String url): dentro de la url viene incluido el usuario y contraseña.
  • getConnection(String url, Properties prop): a partir de un objeto Properties podemos agregar los datos necesarios.
  • getConnection(String url, String user, String password): la versión que vamos a utilizar.

Datos para usar el servidor del cesacle

  • URL: jdbc:mariadb://dbalumnos.sanclemente.local:3319
  • User: alumno
  • Password: abc123..

Indicaciones para crear tu base de datos: nombre_usuario_nombre_base_de_datos

Cerrar conexiones

Si no usamos try-with-resources la clase Connection tiene un método para cerrar close()

Comprobación

A veces es necesario comprobar si el sistema gestor de base datos está online y si tenemos conexión:

if (connection != null && !connection.isClosed()) {
        // run sql statements
    } else {
        // handle closed connection path
  }

Otra forma es validar la conexión:

if (connection.isValid(5)) {
        // run sql statements
    }
    else {
        // handle invalid connection
    }

En el anterior ejemplo espera 5 segundos de respuesta.

O realizar una consulta de prueba:

public static boolean isConnectionValid(Connection connection)
{
    try {
        if (connection != null && !connection.isClosed()) {
            // Running a simple validation query
            connection.prepareStatement("SELECT 1");
            return true;
        }
    }
    catch (SQLException e) {
        // log some useful data here
    }
    return false;
}

Ejemplo clásico

Connection con = null;
  String sURL = "jdbc:mariadb://dbalumnos.sanclemente.local:3319/test";
  try {

      con = (Connection) DriverManager.getConnection(sURL,"xxxx","xxxx");
      System.out.println ("¡Conexión exitosa!");

        } catch (Exception e) { 
     System.out.println("Error en la conexión:" + e.toString() );
  } finally {
  try {
      // Cerramos posibles conexiones abiertas
      if (con!=null) con.close();    
  } catch (Exception e) {
      System.out.println("Error cerrando conexiones: "
        + e.toString());
  } 
}

Ejemplo con try-with-resources y url con múltiples opciones

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

public class SQLDatabaseConnection {
    // Connect to your database.
    // Replace server name, username, and password with your credentials
    public static void main(String[] args) {
        String connectionUrl =
                "jdbc:sqlserver://yourserver.database.windows.net:1433;"
                        + "database=AdventureWorks;"
                        + "user=yourusername@yourserver;"
                        + "password=yourpassword;"
                        + "encrypt=true;"
                        + "trustServerCertificate=false;"
                        + "loginTimeout=30;";

        try (Connection connection = DriverManager.getConnection(connectionUrl);) {
            // Code here.
        }
        // Handle any errors that may have occurred.
        catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Conexión a base de datos embebidas (SQLite, H2 etc…)

Introducción

Las bases de datos embebidas, también conocidas como bases de datos integradas o bases de datos en memoria, son sistemas de gestión de datos diseñados para funcionar directamente dentro de una aplicación, sin necesidad de una instalación o configuración separada. Estas bases de datos se integran directamente en la aplicación que las utiliza y son especialmente útiles en situaciones donde se necesita un almacenamiento ligero, eficiente y de fácil acceso. Aquí hay algunas características y conceptos básicos de las bases de datos embebidas:

  • Sin servidor independiente: A diferencia de las bases de datos tradicionales que se ejecutan como servicios independientes y requieren instalación y configuración por separado, las bases de datos embebidas se incorporan directamente en la aplicación y se ejecutan dentro del mismo proceso.

  • Ligereza: Estas bases de datos están diseñadas para ser ligeras y tener una huella de memoria mínima. Esto las hace ideales para aplicaciones donde los recursos son limitados, como aplicaciones móviles o sistemas embebidos.

  • Acceso rápido: Al integrarse directamente en la aplicación, las bases de datos embebidas ofrecen un acceso muy rápido a los datos, ya que no hay necesidad de realizar operaciones de red para interactuar con un servidor externo.

  • Uso de memoria compartida: En muchos casos, las bases de datos embebidas utilizan la misma memoria que la aplicación que las utiliza, lo que puede aumentar la eficiencia y el rendimiento al eliminar la necesidad de comunicación entre procesos.

  • Persistencia de datos: A pesar de estar integradas en la aplicación, las bases de datos embebidas suelen ofrecer mecanismos para persistir los datos en el disco, lo que significa que los datos pueden sobrevivir a los reinicios de la aplicación o del sistema.

  • Soporte para múltiples modelos de datos: Aunque algunas bases de datos embebidas están diseñadas para un modelo de datos específico, como clave-valor o documentos, otras ofrecen soporte para modelos más complejos, como relaciones entre tablas.

Ejemplos comunes: Algunos ejemplos de bases de datos embebidas populares incluyen SQLite, Berkeley DB y Realm.

Conexión con SQLite

Cómo con las base de datos más clásicas necesitamos un objeto Connection con JDBC. La URL es similar, ejemplo:

Connection conex = DriverManager.getConnection("jdbc:sqlite:/Users/juan/Documents/SQLite");

Para usar en tu proyecto Maven estas dependencias en el pom.xml:

<dependency>
    <groupId>org.xerial</groupId>
    <artifactId>sqlite-jdbc</artifactId>
    <version>3.45.2.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.12</version>
</dependency>
</dependencies>

Para crear una base de dato para SQLite puedes usar el DBeaver, es muy sencillo.

Conexión con H2

La URL necesaria con esta base de datos es:

Connection conex = DriverManager.getConnection("jdbc:h2:/Users/juan/Documents/h2/Ult");

Dependencia con Maven:

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

Al crearla con DBeaver debes tener cuidado con la versión de los drivers que usa el gestor. Usando los mismos en tu proyecto Maven.

Extra: comparativa de tres sistemas de base de datos embebidas: enlace