Live to Plant

How to Connect Java Programs to a MySQL Database

Scroll down to article
Updated: July 23, 2025

Connecting Java programs to a MySQL database is a fundamental skill for developers working on data-driven applications. Whether you are building a small project or an enterprise-level solution, understanding how to interface with a database is essential. This article provides a comprehensive guide on how to connect Java applications with MySQL, covering everything from setting up the environment to executing queries.

Introduction

MySQL is one of the most popular open-source relational database management systems (RDBMS). Java, being a versatile and widely-used programming language, often requires integration with databases like MySQL to store, retrieve, and manage data efficiently.

The process of connecting Java programs to MySQL involves several key steps:

  • Setting up the MySQL server and database
  • Adding the MySQL JDBC driver to your project
  • Writing Java code to establish a connection
  • Executing SQL queries (CRUD operations)
  • Handling exceptions and closing connections properly

Let’s dive into each of these steps in detail.

Prerequisites

Before you start, ensure you have the following installed on your development machine:

  • Java Development Kit (JDK): Version 8 or higher is recommended.
  • MySQL Server: Community edition is sufficient for development purposes.
  • MySQL Workbench or any MySQL client: To interact with your database easily.
  • An IDE (Optional): Such as IntelliJ IDEA, Eclipse, or NetBeans to write and run your code.

Step 1: Install and Setup MySQL Server

If you haven’t installed MySQL:

  1. Download the installer from MySQL official website.
  2. Follow installation instructions according to your operating system.
  3. During installation, set up a root password that you’ll remember.
  4. Once installed, start the MySQL server service.

Creating a Sample Database and Table

You can use MySQL Workbench or the command line to create a database and table for testing.

CREATE DATABASE sampledb;
USE sampledb;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Insert some sample data:

INSERT INTO users (username, email) VALUES ('alice', '[email protected]');
INSERT INTO users (username, email) VALUES ('bob', '[email protected]');

Step 2: Download MySQL Connector/J (JDBC Driver)

To connect Java with MySQL, you need the JDBC driver called MySQL Connector/J.

  • Download it from MySQL Connector/J page.
  • Choose the platform-independent ZIP archive.
  • Extract the archive and locate the mysql-connector-java-x.x.x.jar file.

Alternatively, if you’re using Maven or Gradle in your project, you can include the connector as a dependency:

Maven Dependency

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>

Gradle Dependency

dependencies {
    implementation 'mysql:mysql-connector-java:8.0.33'
}

Make sure to replace 8.0.33 with the latest stable version available.

Step 3: Write Java Code to Connect to MySQL

Here’s an example of how you can connect your Java program to your MySQL database.

Basic Connection Example

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

public class MySQLConnectionExample {
    private static final String URL = "jdbc:mysql://localhost:3306/sampledb";
    private static final String USER = "root";
    private static final String PASSWORD = "your_password";

    public static void main(String[] args) {
        Connection connection = null;

        try {
            // Load and register JDBC driver (optional for newer versions)
            Class.forName("com.mysql.cj.jdbc.Driver");

            // Establish connection
            connection = DriverManager.getConnection(URL, USER, PASSWORD);
            System.out.println("Connected to the database successfully!");
        } catch (ClassNotFoundException e) {
            System.out.println("MySQL JDBC Driver not found.");
            e.printStackTrace();
        } catch (SQLException e) {
            System.out.println("Connection failed!");
            e.printStackTrace();
        } finally {
            try {
                if (connection != null && !connection.isClosed()) {
                    connection.close();
                    System.out.println("Connection closed.");
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
    }
}

Explanation

  • JDBC URL: jdbc:mysql://localhost:3306/sampledb
  • localhost: Hostname where MySQL server runs.
  • 3306: Default port number for MySQL.
  • sampledb: The database name you want to connect.
  • User Credentials: Replace "root" and "your_password" with your actual username and password.

Note: Since JDBC 4.0, manually loading the driver with Class.forName() is optional if you have the driver on your classpath.

Step 4: Performing CRUD Operations Using JDBC

Once connected, you can perform Create, Read, Update, and Delete operations by executing SQL statements through Statement or PreparedStatement.

Insert Data (Create)

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

public class InsertUserExample {
    private static final String URL = "jdbc:mysql://localhost:3306/sampledb";
    private static final String USER = "root";
    private static final String PASSWORD = "your_password";

    public static void main(String[] args) {
        String insertQuery = "INSERT INTO users (username, email) VALUES (?, ?)";

        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement pstmt = connection.prepareStatement(insertQuery)) {

            pstmt.setString(1, "charlie");
            pstmt.setString(2, "[email protected]");

            int rowsAffected = pstmt.executeUpdate();
            System.out.println(rowsAffected + " row(s) inserted.");

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

Read Data (Select)

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

public class SelectUsersExample {
    private static final String URL = "jdbc:mysql://localhost:3306/sampledb";
    private static final String USER = "root";
    private static final String PASSWORD = "your_password";

    public static void main(String[] args) {

        String selectQuery = "SELECT id, username, email, created_at FROM users";

        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement stmt = connection.createStatement();
             ResultSet rs = stmt.executeQuery(selectQuery)) {

            while (rs.next()) {
                int id = rs.getInt("id");
                String username = rs.getString("username");
                String email = rs.getString("email");
                String createdAt = rs.getString("created_at");

                System.out.println(id + ": " + username + ", " + email + ", Joined on: " + createdAt);
            }

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

Update Data

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

public class UpdateUserExample {
    private static final String URL = "jdbc:mysql://localhost:3306/sampledb";
    private static final String USER = "root";
    private static final String PASSWORD = "your_password";

    public static void main(String[] args) {

        String updateQuery = "UPDATE users SET email = ? WHERE username = ?";

        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement pstmt = connection.prepareStatement(updateQuery)) {

            pstmt.setString(1, "[email protected]");
            pstmt.setString(2, "alice");

            int rowsUpdated = pstmt.executeUpdate();
            System.out.println(rowsUpdated + " row(s) updated.");

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

Delete Data

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

public class DeleteUserExample {
    private static final String URL = "jdbc:mysql://localhost:3306/sampledb";
    private static final String USER = "root";
    private static final String PASSWORD = "your_password";

    public static void main(String[] args) {

        String deleteQuery = "DELETE FROM users WHERE username = ?";

        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement pstmt = connection.prepareStatement(deleteQuery)) {

            pstmt.setString(1, "charlie");

            int rowsDeleted = pstmt.executeUpdate();
            System.out.println(rowsDeleted + " row(s) deleted.");

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

Step 5: Best Practices for Database Connectivity in Java

Use Connection Pools

For real-world applications dealing with multiple concurrent connections and requests, creating a new connection every time is inefficient. Use connection pooling libraries like HikariCP or Apache DBCP which manage connections efficiently.

Example using HikariCP:

Add Maven dependency:

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

Basic usage:

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import javax.sql.DataSource;

public class DataSourceFactory {

    public static DataSource getDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/sampledb");
        config.setUsername("root");
        config.setPassword("your_password");

        return new HikariDataSource(config);
    }
}

Then use this DataSource throughout your app for connections.

Close Resources Properly

Use try-with-resources statement introduced in Java 7 for automatic resource management:

try (Connection conn = dataSource.getConnection();
     PreparedStatement ps = conn.prepareStatement(sql);
     ResultSet rs = ps.executeQuery()) {

     // Process results here

} catch(SQLException e){
     e.printStackTrace();
}
// No need for explicit close(), it's handled automatically.

This prevents resource leaks which can cause performance issues.

Use Prepared Statements for Security

Prepared statements protect against SQL injection attacks by separating query structure from data values. Always use them instead of string concatenation when accepting user input.

Troubleshooting Common Issues

Error: com.mysql.cj.jdbc.Driver not found

Ensure that:

  • The MySQL Connector/J JAR is added correctly to your project’s classpath.
  • In IDEs like Eclipse or IntelliJ IDEA, add it as a library/dependency.
  • For Maven/Gradle projects ensure dependencies are resolved properly.

Access Denied Errors (Access denied for user)

Verify:

  • Username and password are correct.
  • User has privileges on the database.

Use MySQL commands to grant privileges if necessary:

GRANT ALL PRIVILEGES ON sampledb.* TO 'root'@'localhost' IDENTIFIED BY 'your_password';
FLUSH PRIVILEGES;

Timezone Issues (The server time zone value is unrecognized)

Append timezone info in JDBC URL:

jdbc:mysql://localhost:3306/sampledb?serverTimezone=UTC

Or replace UTC with your local timezone as needed.

Alternative Frameworks That Simplify Database Connectivity

While plain JDBC works fine for simple projects or learning purposes, many production applications use frameworks such as:

  • Hibernate: An Object Relational Mapping (ORM) framework that maps Java objects to database tables.
  • Spring Data JPA: Simplifies data access layers by providing repository abstractions on top of ORM tools.
  • MyBatis: A persistence framework that couples objects with stored procedures or SQL statements using XML or annotations.

These frameworks handle many low-level tasks like connection management and object mapping automatically and provide cleaner APIs for developers.

Conclusion

Connecting Java programs to a MySQL database involves setting up the database environment correctly and using JDBC drivers within your Java application. This article walked through downloading drivers, establishing connections using JDBC APIs, executing CRUD operations safely using prepared statements, and best practices like resource management and using connection pools.

Mastering this process will empower you to build robust applications capable of interacting efficiently with relational databases. As you grow more comfortable with basic connectivity via JDBC, consider exploring more advanced tools like ORM frameworks that can accelerate development while maintaining scalability and maintainability.

By following this guide step-by-step you can confidently connect your Java applications to a MySQL database, unlocking powerful data storage capabilities essential in modern software development.

Related Posts:

Java