Difference between ORM and JDBC in Java

1. Introduction

In Java, ORM (Object-Relational Mapping) and JDBC (Java Database Connectivity) are two different approaches for interacting with databases. ORM is a technique that lets you query and manipulate data from a database using an object-oriented paradigm. JDBC is an API for connecting and executing SQL operations in a relational database.

2. Key Points

1. ORM allows you to work with databases using Java objects without writing SQL queries explicitly.

2. JDBC requires you to write SQL queries directly in your Java code.

3. ORM provides a way to map between Java objects and database tables.

4. JDBC deals with database data at the column level, whereas ORM works with entire objects.

3. Differences

ORM	JDBC
ORM is a technique that maps application domain objects to database tables and vice versa, automating the data exchange between an object-oriented language and a relational database.	JDBC is a low-level API for executing SQL statements against a database, directly managing the connection and handling result sets.
Provides a high-level abstraction over database interactions, allowing developers to work with database entities as Java objects without worrying about the underlying SQL.	Requires manual handling of SQL queries, connection lifecycle, and result set parsing, giving developers fine-grained control over database operations.
Supports features like lazy loading, caching, and transactions, which can improve performance and developer productivity.	Lacks built-in support for advanced features like caching and lazy loading, requiring manual implementation for such optimizations.
ORM frameworks (like Hibernate) can automatically generate SQL based on object interactions, significantly reducing the need for SQL code.	Developers must write SQL code explicitly, which can be error-prone and time-consuming but allows precise control over database interactions.
Encourages an object-oriented approach to data manipulation, which can lead to more maintainable and understandable code for developers familiar with object-oriented programming.	It encourages a database-centric approach to data handling, which might be preferred in scenarios requiring complex SQL queries and optimizations.
Better suited for applications requiring a lot of CRUD operations and where database schema changes frequently.	It is more suitable for applications with complex SQL queries, high performance requirements, or when direct control over the database is needed.

4. Example

// JDBC example (Assuming a `users` table exists in the database)

public class JdbcExample {
    public static void main(String[] args) {
        Connection connection = null;
        try {
            // Step 1: Load the JDBC driver
            Class.forName("com.jdbc.Driver");

            // Step 2: Establish a connection
            connection = DriverManager.getConnection("jdbc:database_url", "username", "password");

            // Step 3: Create a statement
            Statement statement = connection.createStatement();

            // Step 4: Execute a query
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");

            // Step 5: Process the results
            while(resultSet.next()) {
                System.out.println("User: " + resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // Step 6: Close the connection
            if (connection != null) try { connection.close(); } catch (SQLException ignore) {}
        }
    }
}

// ORM example (Assuming a `User` class is mapped to a `users` table)

public class OrmExample {
    public static void main(String[] args) {
        // Step 1: Obtain an ORM session
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        // Step 2: Retrieve all User objects
        List<User> users = session.createQuery("from User").list();

        // Step 3: Process the results
        for (User user : users) {
            System.out.println("User: " + user.getUsername());
        }

        // Step 4: Close the session
        session.getTransaction().commit();
        session.close();
    }
}

Output:

// Output from JdbcExample
User: alice
User: bob
// Output from OrmExample
User: alice
User: bob

Explanation:

1. The JdbcExample class directly uses JDBC to load a driver, establish a connection to the database, create a statement, execute an SQL query, process the results, and close the connection.

2. The OrmExample class uses an ORM framework to open a session, begin a transaction, query for User objects using HQL (Hibernate Query Language), process the list of User objects, and finally commit the transaction and close the session.

5. When to use?

- Use JDBC for fine-grained control over database operations and for performance-critical applications where speed is crucial.

- Use ORM when you prefer to work with Java objects or when you want to abstract away the underlying SQL for ease of maintenance and development.