Difference between JDBC and JPA

1. Introduction

JDBC (Java Database Connectivity) and JPA (Java Persistence API) are two different approaches to interacting with databases in Java. JDBC is a low-level API for executing SQL statements and managing database connections. JPA is a higher-level specification for object-relational mapping and managing database operations more abstractly.

2. Key Points

1. JDBC provides a basic framework for database access and requires writing SQL queries in Java.

2. JPA abstracts the database access and allows you to interact with databases through Java objects.

3. JDBC involves more boilerplate code for resource management, like opening and closing connections.

4. JPA facilitates database operations without boilerplate through Entity Managers and supports automatic schema generation.

3. Differences

Low-level API for database operations. High-level API for managing persistence and object-relational mapping.
Requires manual writing and execution of SQL queries. Generates SQL queries automatically based on object-relational mapping.
Does not support object-relational mapping directly. Built around object-relational mapping, it provides a more object-oriented approach to persistence.

4. Example

// JDBC example
Connection connection = DriverManager.getConnection("jdbc:h2:~/test", "sa", "");
PreparedStatement stmt = connection.prepareStatement("SELECT * FROM EMPLOYEES");
ResultSet rs = stmt.executeQuery();
while (rs.next()) {
    System.out.println("Employee ID:" + rs.getInt("ID"));

// JPA example
EntityManagerFactory emf = Persistence.createEntityManagerFactory("employee-unit");
EntityManager em = emf.createEntityManager();
List<Employee> result = em.createQuery("SELECT e FROM Employee e", Employee.class).getResultList();
for (Employee e : result) {
    System.out.println("Employee ID:" + e.getId());


// The output for both would be a list of employee IDs, assuming both are querying the same database.
Employee ID:1
Employee ID:2
Employee ID:3
... and so on for both JDBC and JPA examples.


1. In the JDBC example, you manually create a connection, write the SQL query, handle the execution, and manage resources.

2. In the JPA example, you interact with the database using entities and JPA handles the SQL creation and execution, as well as resource management.

5. When to use?

- Use JDBC when you need fine-grained control over SQL queries and database operations, or when you're working with legacy code that already uses JDBC.

- Use JPA when you want to work with a higher level of abstraction and automate object-relational mapping, making it more convenient to deal with complex data interactions and relationships.