MySQL with Java (JDBC)

Introduction

So far you have written SQL directly against a MySQL server using a client tool. In real applications, though, SQL is usually issued from application code — a web server, a desktop program, or a backend service. Java is one of the most common languages used for exactly this, and JDBC is the standard bridge between Java code and a database like MySQL.

In this lesson you will learn what JDBC is, how to connect a Java program to a MySQL database, how to run queries and read the results back, and — critically — how to do this safely using PreparedStatement so your application is not vulnerable to SQL injection.

What is JDBC?

JDBC stands for Java Database Connectivity. It is the standard Java API for connecting to relational databases and sending them SQL. JDBC itself does not know anything about MySQL specifically — it defines a common set of interfaces (Connection, Statement, ResultSet, and so on) that any database vendor can implement.

To actually talk to MySQL, your project needs the MySQL JDBC driver — a library that implements those JDBC interfaces for MySQL's specific network protocol. Because your code is written against the generic JDBC interfaces, the same code pattern works for MySQL, PostgreSQL, or any other JDBC-supported database, with only the driver and connection URL changing.

Adding the MySQL JDBC Driver

The MySQL JDBC driver is distributed as a library called mysql-connector-j. If you are using Maven, add it as a dependency in your pom.xml.

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.3.0</version>
</dependency>

If you are using Gradle instead, the equivalent dependency line looks like this.

implementation 'com.mysql:mysql-connector-j:8.3.0'

Connecting to MySQL

A connection is opened using DriverManager.getConnection(), passing a JDBC URL, a username, and a password. The URL identifies the database server, port, and database name.

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

public class ConnectExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/school";
        String user = "app_user";
        String password = "secret123";

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            System.out.println("Connected to MySQL successfully!");
        } catch (SQLException e) {
            System.out.println("Connection failed: " + e.getMessage());
        }
    }
}

Connected to MySQL successfully!

The URL format jdbc:mysql://host:port/database tells the driver which server and database to connect to. Here, localhost:3306 is the default MySQL server address and port, and school is the target database.

Running a Query with Statement

Once connected, a Statement object lets you send SQL to the server. Running a SELECT returns a ResultSet, which you step through one row at a time with next().

import java.sql.*;

public class QueryExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/school";

        try (Connection conn = DriverManager.getConnection(url, "app_user", "secret123");
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT id, name, marks FROM students")) {

            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int marks = rs.getInt("marks");
                System.out.println(id + " - " + name + " - " + marks);
            }
        } catch (SQLException e) {
            System.out.println("Query failed: " + e.getMessage());
        }
    }
}

1 - Alex - 78
2 - Sam - 65
3 - Priya - 91

rs.next() advances the cursor to the next row and returns false once there are no more rows, which is why it works perfectly as a while-loop condition. The getXxx() methods then read a specific column from the current row, either by name or by position.

Using PreparedStatement

A plain Statement becomes dangerous the moment you build SQL by concatenating user input directly into the string, because an attacker can inject extra SQL. PreparedStatement solves this by using placeholders (?) for values, which the driver sends separately from the SQL itself — the database never confuses user input with SQL syntax.

import java.sql.*;

public class PreparedStatementExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/school";
        int minMarks = 60;

        String sql = "SELECT name, marks FROM students WHERE marks >= ?";

        try (Connection conn = DriverManager.getConnection(url, "app_user", "secret123");
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setInt(1, minMarks);

            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    System.out.println(rs.getString("name") + " - " + rs.getInt("marks"));
                }
            }
        } catch (SQLException e) {
            System.out.println("Query failed: " + e.getMessage());
        }
    }
}

Alex - 78
Priya - 91

Inserting Data Safely

PreparedStatement is not just for SELECT — it is the standard way to run any parameterized statement, including INSERT, UPDATE, and DELETE. Use executeUpdate() for statements that modify data rather than return rows.

import java.sql.*;

public class InsertExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/school";
        String sql = "INSERT INTO students (name, marks) VALUES (?, ?)";

        try (Connection conn = DriverManager.getConnection(url, "app_user", "secret123");
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, "Jordan");
            pstmt.setInt(2, 88);

            int rowsInserted = pstmt.executeUpdate();
            System.out.println(rowsInserted + " row(s) inserted.");
        } catch (SQLException e) {
            System.out.println("Insert failed: " + e.getMessage());
        }
    }
}

1 row(s) inserted.

Closing Connections Properly

Every Connection, Statement, and ResultSet holds real resources on both the Java side and the MySQL server side, so each one must be closed when you are done with it. Forgetting to close connections is a common cause of an application slowly running out of available database connections.

The try-with-resources syntax used in every example above handles this automatically: Connection, Statement, and ResultSet all implement AutoCloseable, so they are closed the moment the try block ends — even if an exception is thrown.

Connection conn = null;
try {
    conn = DriverManager.getConnection(url, user, password);
    // ... use the connection ...
} catch (SQLException e) {
    System.out.println("Error: " + e.getMessage());
} finally {
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) {
            System.out.println("Failed to close connection: " + e.getMessage());
        }
    }
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

JDBC gives Java applications a standard, portable way to talk to MySQL. You open a connection with DriverManager, run queries through Statement or, far more safely, through PreparedStatement, read results row by row from a ResultSet, and close everything properly with try-with-resources.

In this lesson, you connected to MySQL from Java, ran a query and read back its results, and learned why PreparedStatement is the correct way to handle any value coming from outside your code. Next, you will do the same thing from Node.js, using the mysql2 package.