Conectar Java con MySQL consiste en usar JDBC, la API estándar de acceso a bases de datos de Java, junto con el driver mysql-connector-j. Con una URL jdbc:mysql://localhost:3306/nombre_bd, un usuario y una contraseña se abre la conexión, y las consultas se ejecutan con Statement y PreparedStatement.

Conectar Java con MySQL: guía paso a paso

Última actualización: agosto 2026

Contenido Rápido

• Conectar Java con MySQL usa JDBC con el driver mysql-connector-j
• La conexión se abre con una URL jdbc:mysql, un usuario y una contraseña
• Class.forName carga el driver de forma reflectiva y compila sin el jar
• Statement y PreparedStatement ejecutan las consultas con try-with-resources
• SQLException centraliza los errores y getErrorCode los identifica
• PreparedStatement protege de la inyección SQL con parámetros

Java y MySQL son una de las parejas más habituales en aplicaciones de empresa, y conectar ambos es más simple de lo que parece cuando conoces las piezas. JDBC es la API que trae la JDK para hablar con cualquier base de datos, y el driver de MySQL traduce tus llamadas Java al protocolo de MySQL. Con una URL, un usuario y una contraseña, tu programa abre la puerta a las tablas de la base de datos.

En esta guía montas la conexión desde cero: preparas el entorno, añades la dependencia del driver, abres la primera conexión y ejecutas una consulta y una inserción. Todos los fragmentos son archivos completos que compilan con javac, así que puedes copiarlos y probarlos tal cual. Para ejecutarlos contra una base de datos real solo necesitas el driver en el classpath y un MySQL levantado en tu equipo.

Qué necesitas antes de empezar

El primer requisito es un JDK instalado. Si todavía no lo tienes, sigue la guía para instalar Java y vuelve cuando el comando java -version responda. Cualquier versión moderna sirve, porque JDBC es parte de la plataforma desde la versión 1.1, como explica el tutorial de JDBC de Oracle, y no necesita configuración adicional.

El segundo es MySQL corriendo en tu máquina o en un servidor accesible. Puedes instalarlo con el instalador oficial, con Homebrew en macOS o con Docker. Lo importante es que conozcas tres datos: el host donde corre, el puerto por defecto, que es el 3306, y las credenciales de un usuario con permisos sobre la base de datos con la que vas a trabajar.

El tercero es el driver de Java, que se llama mysql-connector-j y no viene incluido en la JDK. Este archivo es el puente que implementa el protocolo de MySQL para JDBC, y es la única pieza externa que necesitas. Descargarlo es el tema del siguiente paso, porque puedes hacerlo con Maven o a mano.

La dependencia: mysql-connector-j

El driver oficial se publica como mysql-connector-j y lo mantiene Oracle. Si tu proyecto usa Maven o Gradle, lo añades como dependencia normal con la coordenada com.mysql:mysql-connector-j y la versión 8.x o 9.x según tu instalación de MySQL. Las versiones modernas del driver soportan tanto MySQL 8 como MySQL 9, y los números menores se publican con frecuencia para corregir errores.

En un proyecto sin gestor de dependencias, la alternativa es descargar el archivo .jar desde la página de descargas y añadirlo al classpath con javac y java. Para compilar usas javac -cp mysql-connector-j-x.jar TuClase.java y para ejecutar java -cp mysql-connector-j-x.jar;. TuClase en Windows, o con dos puntos como separador en macOS y Linux.

Desde JDBC 4.0 el driver se registra solo, gracias al mecanismo de ServiceLoader: con el .jar en el classpath, DriverManager lo encuentra sin que lo registres tú. Aun así, es habitual cargarlo de forma explícita con Class.forName, porque hace visible la dependencia y funciona igual en cualquier versión. El manual del MySQL Connector/J documenta las opciones de configuración al detalle.

Primer paso: cargar el driver y abrir la conexión

La conexión se abre con una URL de JDBC que describe dónde está la base de datos. Para MySQL el formato es jdbc:mysql://host:puerto/nombre_bd, así que una conexión local a una base llamada universidad queda como jdbc:mysql://localhost:3306/universidad. DriverManager recibe esa URL junto con el usuario y la contraseña, y devuelve un objeto Connection listo para usar.

Este programa carga el driver con Class.forName y abre la primera conexión. Fíjate en que la cadena con el nombre de la clase es un literal: el código compila aunque no tengas el .jar, porque no referencia ningún tipo del driver directamente.

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

public class CargarDriver {

    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            System.err.println("Driver no encontrado: " + e.getMessage());
            return;
        }

        String url = "jdbc:mysql://localhost:3306/universidad";
        String usuario = "root";
        String contrasena = "tu_contraseña";

        try (Connection conexion = DriverManager.getConnection(url, usuario, contrasena)) {
            System.out.println("Conexión establecida con MySQL");
        } catch (SQLException e) {
            System.err.println("Error de conexión: " + e.getMessage());
        }
    }
}

A la URL se le pueden añadir parámetros con interrogación y ampersand. Tres son los más habituales en conexiones locales: useSSL desactiva la cifra TLS cuando el servidor no la tiene configurada, allowPublicKeyRetrieval permite obtener la clave pública de autenticación, y serverTimezone alinea la zona horaria del servidor con la de la JVM. En los ejemplos de esta guía se omiten para mantenerlos legibles.

Ejemplo completo: SELECT con Statement

Con la conexión abierta, ejecutar una consulta es un proceso de tres objetos: Connection abre la vía, Statement prepara la consulta y ResultSet guarda las filas devueltas. Este programa lista los alumnos de la tabla alumnos y muestra su identificador, nombre y correo.

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

public class ConsultarAlumnos {

    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            System.err.println("Driver no encontrado: " + e.getMessage());
            return;
        }

        String url = "jdbc:mysql://localhost:3306/universidad";
        String usuario = "root";
        String contrasena = "tu_contraseña";

        String sql = "SELECT id, nombre, email FROM alumnos";

        try (Connection conexion = DriverManager.getConnection(url, usuario, contrasena);
             Statement sentencia = conexion.createStatement();
             ResultSet resultado = sentencia.executeQuery(sql)) {

            while (resultado.next()) {
                int id = resultado.getInt("id");
                String nombre = resultado.getString("nombre");
                String email = resultado.getString("email");
                System.out.println(id + " - " + nombre + " - " + email);
            }
        } catch (SQLException e) {
            System.err.println("Error al consultar: " + e.getMessage());
        }
    }
}

El bucle resultado.next() avanza fila a fila y devuelve false cuando se acaban. Dentro de cada vuelta, los métodos getInt y getString leen el valor de cada columna, ya sea por nombre o por posición. Statement es adecuado para consultas fijas que no reciben datos del usuario, porque concatenar valores en el SQL es frágil y peligroso.

Ejemplo completo: INSERT con PreparedStatement

Cuando la consulta lleva valores variables, lo correcto es PreparedStatement. Este programa inserta un alumno nuevo usando comodines en el SQL y los métodos setString y setInt para rellenarlos, de modo que los valores se envían como datos y nunca se interpretan como parte de la instrucción.

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

public class InsertarAlumno {

    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            System.err.println("Driver no encontrado: " + e.getMessage());
            return;
        }

        String url = "jdbc:mysql://localhost:3306/universidad";
        String usuario = "root";
        String contrasena = "tu_contraseña";

        String sql = "INSERT INTO alumnos (nombre, email, curso) VALUES (?, ?, ?)";

        try (Connection conexion = DriverManager.getConnection(url, usuario, contrasena);
             PreparedStatement sentencia = conexion.prepareStatement(sql)) {

            sentencia.setString(1, "Lucía García");
            sentencia.setString(2, "lucia@example.com");
            sentencia.setInt(3, 1);

            int filas = sentencia.executeUpdate();
            System.out.println("Filas insertadas: " + filas);
        } catch (SQLException e) {
            System.err.println("Error al insertar: " + e.getMessage());
        }
    }
}

executeUpdate devuelve el número de filas afectadas, que en una inserción normal es uno. PreparedStatement también se usa para update y delete, y es la primera defensa contra la inyección SQL: el usuario puede escribir lo que quiera, pero nunca se convierte en parte ejecutable de la instrucción. Cuando el volumen de operaciones crece, un ORM como Hibernate, JPA o Spring Data puede ahorrarte el JDBC manual.

Manejo de errores: SQLException

Casi todo lo que puede fallar al conectar con una base de datos lanza SQLException, una excepción comprobada que hereda de Exception. El compilador te obliga a tratarla, y el bloque catch recibe el mensaje, el código de error y el estado SQL del servidor. getErrorCode devuelve el código específico del motor, mientras que getSQLState devuelve el estándar.

La tabla resume los fallos más comunes y cómo resolverlos:

Error	Causa	Solución
Access denied for user	Credenciales o permisos incorrectos	Revisa usuario y contraseña, y el GRANT sobre la base de datos
Communications link failure	MySQL no escucha en ese host o puerto	Comprueba que el servicio está activo en el puerto 3306
Unknown database	El nombre de la base no existe	Crea la base o corrige el nombre en la URL
Driver no encontrado	El .jar no está en el classpath	Añade mysql-connector-j con Maven o con -cp
Public Key Retrieval is not allowed	El servidor pide clave pública y el parámetro no está	Añade allowPublicKeyRetrieval=true a la URL

El error más desconcertante es Communications link failure, porque suele indicar un problema de red o de configuración del servidor antes que de tu código. Prueba primero a conectar con un cliente como MySQL Workbench o la línea de comandos: si ese cliente tampoco entra, el problema está en el servidor o en el firewall, no en Java.

Cerrar conexiones: try-with-resources

Cada Connection, Statement y ResultSet ocupa recursos fuera de la JVM, así que hay que cerrarlos siempre. La forma correcta es el try-with-resources, que cierra automáticamente todo objeto que implemente AutoCloseable al salir del bloque, tanto si termina bien como si lanza una excepción. Los tres objetos se declaran en la misma línea de try y se cierran en orden inverso.

No hace falta cerrarlos a mano en un bloque finally: el try-with-resources lo hace por ti y evita el clásico error de olvidar la llamada a close. Además, cuando el bloque termina, las conexiones vuelven al pool de MySQL si tu servidor las gestiona así, y quedan listas para la siguiente petición.

La elección entre JDBC puro y una capa de abstracción depende del proyecto. Para aprender y para herramientas pequeñas, el JDBC que ves aquí es suficiente y te muestra lo que ocurre debajo. Cuando construyas una API, el camino habitual es crear una API REST con Spring Boot y su capa de datos, donde la conexión se configura y no se gestiona a mano, y los errores se tratan con el manejo de excepciones de Spring.

Todos los fragmentos de esta guía compilan en el navegador con el Java Playground de CodeJa: ejecuta Java sin instalar nada y prueba los ejemplos de JDBC. Para verlos funcionando contra una base de datos real, añade el driver mysql-connector-j al classpath y levanta MySQL en tu equipo. El resto de la ruta de aprendizaje está en la ruta para aprender Java y en los cursos de CodeJa, con ejercicios guiados dentro de la ruta de junior a senior.

Preguntas Frecuentes

¿Cómo conectar Java con MySQL paso a paso?

Se necesita el driver mysql-connector-j en el classpath y una URL jdbc:mysql://host:puerto/nombre_bd. DriverManager abre la conexión con esa URL, un usuario y una contraseña, y desde la Connection se crean Statement o PreparedStatement para ejecutar las consultas.

¿Qué es el driver mysql-connector-j?

Es el controlador oficial de MySQL para JDBC, publicado por Oracle. Implementa el protocolo de MySQL para que las clases de java.sql funcionen contra esta base de datos, y se añade al proyecto con Maven o descargando su archivo .jar.

¿Qué significa jdbc:mysql://localhost:3306?

Es la URL de conexión de JDBC para MySQL. jdbc:mysql indica el subprotocolo, localhost es el host donde corre el servidor, 3306 es el puerto por defecto de MySQL y el último segmento es el nombre de la base de datos.

¿Cuándo usar Statement en vez de PreparedStatement?

Statement sirve para consultas fijas sin valores variables, como listar todos los registros. En cuanto el SQL depende de datos del usuario, se usa PreparedStatement, que recibe los valores por separado y evita la inyección SQL.

¿Cómo arreglar el error Access denied for user?

El error significa que el usuario o la contraseña no son válidos, o que el usuario no tiene permisos sobre la base de datos. Revisa las credenciales en el código y verifica con un GRANT que el usuario pueda acceder a la base desde el host que usa la aplicación.

Artículos Relacionados

• Instalar Java: guía para empezar
• Hibernate vs JPA vs Spring Data: cuál usar
• Crear un REST API con Spring Boot
• Manejo de excepciones en una API REST con Spring
• La ruta para aprender Java