Most real-world applications need a database.

A shopping application needs to store products and orders. A banking application needs to store accounts and transactions. Even a simple user-management application needs somewhere to save user information.

But how does a Java application actually communicate with a database?

That’s where JDBC comes in.

JDBC (Java Database Connectivity) is a standard Java API that allows Java applications to connect to databases, send SQL queries, retrieve results, and perform operations such as inserting, updating, and deleting data.

In this guide, we’ll learn JDBC from the ground up with simple examples.

We’ll cover:

• What JDBC is
• How JDBC works
• JDBC architecture
• JDBC drivers
• Connecting to a database
• Connection
• Statement
• PreparedStatement
• ResultSet
• CRUD operations
• Transactions
• Exception handling
• Try-with-resources
• Best practices

Let’s get started.

---

What Is JDBC?

JDBC stands for Java Database Connectivity.

It is a Java API that provides a standard way for Java applications to communicate with relational databases.

Instead of creating completely different database code for every database system, Java provides common JDBC interfaces.

For example, your application might connect to:

• MySQL
• PostgreSQL
• Oracle Database
• Microsoft SQL Server
• H2

The basic idea looks like this:

Java Application
       ↓
      JDBC
       ↓
  JDBC Driver
       ↓
    Database

The JDBC API provides the common programming interface, while the database-specific JDBC driver handles communication with the particular database.

---

Why Do We Need JDBC?

Imagine your Java application needs to retrieve users from a database.

Without a standard API, you would need database-specific programming approaches for different database systems.

JDBC provides a common interface.

Your Java code can work with interfaces such as:

Connection
PreparedStatement
ResultSet

The JDBC driver handles the database-specific details.

This makes database access more consistent across different relational database systems.

---

How Does JDBC Work?

A simplified JDBC flow looks like this:

Java Application
       ↓
JDBC API
       ↓
JDBC Driver
       ↓
Database
       ↓
SQL Query
       ↓
Result
       ↓
Java Application

For example:

Java Code
   ↓
SELECT * FROM users
   ↓
JDBC Driver
   ↓
Database
   ↓
Rows Returned
   ↓
ResultSet

Your Java application can then process those rows.

---

JDBC Architecture

Let’s look at the main components.

┌─────────────────────┐
│   Java Application  │
└──────────┬──────────┘
           ↓
┌─────────────────────┐
│     JDBC API        │
└──────────┬──────────┘
           ↓
┌─────────────────────┐
│    JDBC Driver      │
└──────────┬──────────┘
           ↓
┌─────────────────────┐
│      Database       │
└─────────────────────┘

The major pieces you’ll work with are:

• Driver
• Connection
• Statement
• PreparedStatement
• ResultSet

Let’s understand them one by one.

---

What Is a JDBC Driver?

A JDBC driver is software that allows Java’s JDBC API to communicate with a specific database.

For example, if you’re using PostgreSQL, you need the PostgreSQL JDBC driver.

If you’re using MySQL, you need the MySQL JDBC driver.

Conceptually:

Java
 ↓
JDBC API
 ↓
Database Driver
 ↓
MySQL / PostgreSQL / Oracle

The driver translates JDBC calls into commands that the database understands.

---

Adding a JDBC Driver

If you’re using Maven, you add the appropriate database driver as a dependency.

For example, for PostgreSQL:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
</dependency>

For MySQL:

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

The exact driver version should be managed according to your project’s dependency configuration.

---

Connecting Java to a Database

Once the JDBC driver is available, you can create a database connection.

A basic example looks like this:

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

public class DatabaseExample {

    public static void main(String[] args)
            throws Exception {

        String url =
            "jdbc:postgresql://localhost:5432/shopdb";

        String username = "app_user";
        String password = "your_password";

        Connection connection =
            DriverManager.getConnection(
                url,
                username,
                password
            );

        System.out.println(
            "Database connected successfully!"
        );

        connection.close();
    }
}

The important method here is:

DriverManager.getConnection(...)

It creates a connection between your Java application and the database.

---

Understanding the JDBC URL

A JDBC URL tells the driver how to locate the database.

For PostgreSQL, a common format is:

jdbc:postgresql://localhost:5432/shopdb

Let’s break it down:

jdbc
 ↓
JDBC protocol

postgresql
 ↓
Database type

localhost
 ↓
Database server

5432
 ↓
Port

shopdb
 ↓
Database name

A MySQL URL might look like:

jdbc:mysql://localhost:3306/shopdb

The exact URL format depends on the database and JDBC driver.

---

What Is Connection?

The Connection interface represents an active connection between your Java application and the database.

For example:

Connection connection =
    DriverManager.getConnection(
        url,
        username,
        password
    );

Once you have a connection, you can use it to:

• Create statements
• Execute SQL
• Manage transactions
• Commit changes
• Roll back changes

Think of it as the communication channel between your application and database.

---

What Is Statement?

Statement allows you to execute SQL statements.

For example:

Statement statement =
    connection.createStatement();

Then:

ResultSet result =
    statement.executeQuery(
        "SELECT * FROM users"
    );

This works, but you should be careful when SQL contains values supplied by users.

For dynamic values, PreparedStatement is generally the better choice.

---

What Is PreparedStatement?

PreparedStatement is one of the most important JDBC classes.

It allows you to create parameterized SQL queries.

For example:

String sql =
    "SELECT * FROM users WHERE email = ?";

PreparedStatement statement =
    connection.prepareStatement(sql);

statement.setString(
    1,
    "alex@example.com"
);

ResultSet result =
    statement.executeQuery();

The ? is a placeholder.

You provide the actual value separately:

statement.setString(1, email);

---

Why Use PreparedStatement?

There are several reasons.

1. Better Security

Parameterized queries help protect against SQL injection when used correctly.

Avoid building SQL like this:

String sql =
    "SELECT * FROM users WHERE email = '"
    + email
    + "'";

Instead, use:

String sql =
    "SELECT * FROM users WHERE email = ?";

PreparedStatement statement =
    connection.prepareStatement(sql);

statement.setString(1, email);

2. Cleaner Code

Parameters are separated from SQL structure.

3. Better Reusability

Prepared statements can be useful when executing the same SQL structure with different values.

---

What Is ResultSet?

When you execute a query that returns rows, JDBC commonly gives you a ResultSet.

For example:

ResultSet result =
    statement.executeQuery(
        "SELECT * FROM users"
    );

You can iterate through the returned rows:

while (result.next()) {

    String name =
        result.getString("name");

    String email =
        result.getString("email");

    System.out.println(name);
    System.out.println(email);
}

The ResultSet acts like a cursor over the query results.

---

Reading Different Data Types

JDBC provides methods for reading different column types.

For example:

result.getString("name");

result.getInt("age");

result.getLong("id");

result.getDouble("price");

result.getBoolean("active");

You can also retrieve values using column indexes:

result.getString(1);

Using column names is often easier to read and maintain.

---

Reading Data from a Database

Let’s build a complete example.

Suppose our database contains:

users
--------------------------------
id | name   | email
--------------------------------
1  | Emma   | emma@example.com
2  | Oliver | oliver@example.com

Java code:

String sql =
    "SELECT id, name, email FROM users";

try (
    Connection connection =
        DriverManager.getConnection(
            url,
            username,
            password
        );

    PreparedStatement statement =
        connection.prepareStatement(sql);

    ResultSet result =
        statement.executeQuery()
) {

    while (result.next()) {

        long id =
            result.getLong("id");

        String name =
            result.getString("name");

        String email =
            result.getString("email");

        System.out.println(
            id + " " + name + " " + email
        );
    }
}

This is a much safer and cleaner approach because resources are automatically closed.

---

What Is Try-With-Resources?

JDBC objects such as:

• Connection
• PreparedStatement
• ResultSet

use resources that should be closed.

Java provides try-with-resources to make this easier.

For example:

try (
    Connection connection =
        DriverManager.getConnection(
            url,
            username,
            password
        )
) {

    // Database operations

}

When the try block finishes, Java automatically closes the resource.

This is generally preferable to manually writing:

connection.close();

everywhere.

---

INSERT Operation with JDBC

Now let’s insert a new user.

String sql =
    "INSERT INTO users (name, email) " +
    "VALUES (?, ?)";

try (
    Connection connection =
        DriverManager.getConnection(
            url,
            username,
            password
        );

    PreparedStatement statement =
        connection.prepareStatement(sql)
) {

    statement.setString(1, "Sophia");
    statement.setString(
        2,
        "sophia@example.com"
    );

    int rows =
        statement.executeUpdate();

    System.out.println(
        rows + " row inserted."
    );
}

The executeUpdate() method is commonly used for:

• INSERT
• UPDATE
• DELETE

It returns the number of affected rows.

---

UPDATE Operation with JDBC

Suppose we want to update a user’s email.

String sql =
    "UPDATE users " +
    "SET email = ? " +
    "WHERE id = ?";

try (
    Connection connection =
        DriverManager.getConnection(
            url,
            username,
            password
        );

    PreparedStatement statement =
        connection.prepareStatement(sql)
) {

    statement.setString(
        1,
        "newemail@example.com"
    );

    statement.setLong(2, 1L);

    int rows =
        statement.executeUpdate();

    System.out.println(
        rows + " row updated."
    );
}

---

DELETE Operation with JDBC

Deleting data works similarly.

String sql =
    "DELETE FROM users WHERE id = ?";

try (
    Connection connection =
        DriverManager.getConnection(
            url,
            username,
            password
        );

    PreparedStatement statement =
        connection.prepareStatement(sql)
) {

    statement.setLong(1, 2L);

    int rows =
        statement.executeUpdate();

    System.out.println(
        rows + " row deleted."
    );
}

---

JDBC CRUD Operations

At this point, we can summarize JDBC CRUD operations:

CREATE → INSERT
READ   → SELECT
UPDATE → UPDATE
DELETE → DELETE

The typical JDBC methods are:

SELECT
 ↓
executeQuery()

INSERT / UPDATE / DELETE
 ↓
executeUpdate()

---

What Is executeQuery()?

Use:

executeQuery()

when your SQL statement returns a result set.

For example:

String sql =
    "SELECT * FROM users";

ResultSet result =
    statement.executeQuery();

It returns:

ResultSet

---

What Is executeUpdate()?

Use:

executeUpdate()

for statements that modify data.

For example:

INSERT
UPDATE
DELETE

Example:

int rows =
    statement.executeUpdate();

The returned value tells you how many rows were affected.

---

What Is execute()?

JDBC also provides:

execute()

This is a more general method that can execute SQL when you don’t know in advance whether the result will be a ResultSet or an update count.

For everyday CRUD operations, executeQuery() and executeUpdate() are usually clearer.

---

Handling SQL Exceptions

Database operations can fail for many reasons.

For example:

• Database is unavailable
• Credentials are incorrect
• SQL syntax is invalid
• Constraint is violated
• Network connection fails

JDBC commonly uses:

SQLException

to represent database access errors.

Example:

try {
    // JDBC operations

} catch (SQLException exception) {

    System.out.println(
        "Database error: "
        + exception.getMessage()
    );
}

In production applications, you would typically use structured logging and appropriate exception handling rather than simply printing the message.

---

JDBC Transactions

Sometimes multiple database operations need to succeed or fail together.

Imagine transferring money between two accounts.

You might need to:

1. Deduct money from Account A
2. Add money to Account B

If the first operation succeeds but the second fails, the database could become inconsistent.

This is where transactions are useful.

---

Starting a Transaction

By default, JDBC connections commonly use auto-commit mode.

You can disable it:

connection.setAutoCommit(false);

Then perform multiple operations.

If everything succeeds:

connection.commit();

If something goes wrong:

connection.rollback();

Conceptually:

Start Transaction
       ↓
Operation 1
       ↓
Operation 2
       ↓
Everything Successful?
    ↙       ↘
  Yes        No
   ↓          ↓
 Commit     Rollback

---

JDBC Transaction Example

try (
    Connection connection =
        DriverManager.getConnection(
            url,
            username,
            password
        )
) {

    connection.setAutoCommit(false);

    try {
        // Operation 1
        // Operation 2

        connection.commit();

    } catch (SQLException exception) {

        connection.rollback();

        throw exception;
    }
}

This ensures that either the transaction is committed or the changes are rolled back when an error occurs.

---

What Is Connection Pooling?

Creating a new database connection can be relatively expensive.

Imagine a web application receiving hundreds of requests.

If every request creates a completely new database connection:

Request
  ↓
Create Connection
  ↓
Query Database
  ↓
Close Connection

doing this repeatedly can add unnecessary overhead.

A connection pool keeps a collection of reusable database connections.

Conceptually:

              Connection Pool
          ┌──────┬──────┬──────┐
          │ Conn │ Conn │ Conn │
          └──────┴──────┴──────┘
             ↑
             │
          Application

The application borrows a connection, uses it, and returns it to the pool.

This is common in server-side Java applications.

---

JDBC in Spring Boot

If you’re learning Spring Boot, you may wonder:

“Do I still need JDBC?”

Yes.

Spring provides higher-level abstractions around database access, but JDBC remains an important foundation.

For example, Spring’s JdbcTemplate simplifies many JDBC tasks.

Instead of manually managing a lot of JDBC boilerplate, you can write:

String sql =
    "SELECT name FROM users WHERE id = ?";

String name =
    jdbcTemplate.queryForObject(
        sql,
        String.class,
        userId
    );

Spring handles much of the repetitive JDBC work for you.

---

JDBC vs JPA

Both JDBC and JPA can be used to interact with relational databases, but they operate at different abstraction levels.

JDBC

You work directly with:

SQL
Connection
PreparedStatement
ResultSet

You have more direct control over SQL and database interaction.

JPA

JPA provides an object-relational mapping approach.

You work more with:

Java Objects
Entities
Repositories
Relationships

and the framework handles much of the SQL generation and mapping.

A simplified comparison:

JDBC
Java → SQL → Database


JPA
Java Object → ORM → SQL → Database

Neither is universally “better.”

The right choice depends on the application and requirements.

---

Common JDBC Mistakes

1. Building SQL with String Concatenation

Avoid:

String sql =
    "SELECT * FROM users WHERE id = "
    + userId;

Prefer:

String sql =
    "SELECT * FROM users WHERE id = ?";

PreparedStatement statement =
    connection.prepareStatement(sql);

statement.setLong(1, userId);

This helps prevent SQL injection and keeps the query cleaner.

---

2. Not Closing Resources

Leaving database resources open can eventually cause resource exhaustion.

Use try-with-resources:

try (
    Connection connection = ...;
    PreparedStatement statement = ...;
    ResultSet result = ...
) {
    // Work
}

---

3. Creating Too Many Connections

For server applications, use a properly configured connection pool instead of opening unnecessary connections for every small operation.

---

4. Ignoring Transactions

If multiple operations must succeed together, use a transaction.

---

5. Putting Database Code Everywhere

Don’t scatter JDBC code throughout your application.

A cleaner architecture is:

Controller
    ↓
Service
    ↓
Repository / DAO
    ↓
Database

---

JDBC Best Practices

Here are some practical rules to remember.

Use PreparedStatement

Prefer parameterized SQL for dynamic values.

Use Try-With-Resources

Let Java automatically close JDBC resources.

Use Transactions

Group related database operations when they must succeed or fail together.

Use Connection Pooling

Especially for web applications and other high-concurrency applications.

Keep Database Code Organized

Use a repository or DAO layer rather than placing SQL directly inside controllers.

Validate Input

Don’t trust values coming from users or external systems.

Use Proper Error Handling

Handle database errors appropriately and log enough information for debugging without exposing sensitive information.

---

A Simple JDBC Request Flow

Here’s the whole process in one diagram:

Java Application
       ↓
Get Database Connection
       ↓
Create PreparedStatement
       ↓
Set Parameters
       ↓
Execute SQL
       ↓
ResultSet / Update Count
       ↓
Process Result
       ↓
Close Resources

Once you understand this flow, most basic JDBC code becomes much easier to read.

---

JDBC Learning Path for Beginners

If you’re new to JDBC, learn it in this order:

Java Basics
     ↓
SQL Basics
     ↓
JDBC Driver
     ↓
Connection
     ↓
Statement
     ↓
PreparedStatement
     ↓
ResultSet
     ↓
CRUD Operations
     ↓
Transactions
     ↓
Connection Pooling
     ↓
JDBC with Spring Boot
     ↓
JPA / Hibernate

You don’t need to master everything in one day.

Start by connecting Java to a database and performing a simple SELECT.

Then build a small CRUD application.

---

Final Thoughts

JDBC is one of the fundamental technologies for connecting Java applications to relational databases.

The basic flow is:

Java Application
       ↓
      JDBC
       ↓
 JDBC Driver
       ↓
   Database

The most important JDBC components to remember are:

• Connection → Connects your application to the database
• PreparedStatement → Executes parameterized SQL
• ResultSet → Reads query results
• executeQuery() → Used for queries that return results
• executeUpdate() → Used for INSERT, UPDATE, and DELETE
• Transaction → Groups related database operations
• Connection Pool → Reuses database connections efficiently

JDBC may look a little verbose compared with modern tools such as Spring Data JPA, but learning it is still valuable.

Once you understand what’s happening underneath the higher-level frameworks, concepts like Spring JDBC, JPA, Hibernate, repositories, and database transactions become much easier to understand.

So don’t just memorize the JDBC classes.

Understand the flow:

Connect → Prepare → Execute → Read/Update → Close

Once that pattern becomes familiar, you’re ready to build Java applications that can communicate with real databases.