Advantages of Hibernate over JDBC

Advantages of Hibernate over JDBC

Hibernate and JDBC are both used for database interaction in Java applications. However, Hibernate offers several advantages over JDBC, making it a preferred choice for many developers.

Key Advantages of Hibernate Over JDBC:

1.  Automatic Table Creation

   Hibernate can automatically create and update database tables based on entity mappings, reducing the need for manual schema management.

2.  Simplified Data Access

   Hibernate abstracts the complexity of JDBC by providing a high-level API for data access, making code easier to write and maintain.

3.  Object-Relational Mapping (ORM)

   Hibernate maps Java classes to database tables, allowing developers to work with objects instead of writing SQL queries for CRUD operations.

4.  Caching

   Hibernate supports first-level and second-level caching, improving application performance by reducing the number of database hits.

5.  Lazy Loading

   Hibernate can lazily load associated entities, optimizing performance by loading only the required data when needed.

6.  HQL (Hibernate Query Language)

   Hibernate provides HQL, which is more object-oriented and closer to Java syntax than SQL, making it easier to write and understand queries.

7.  Transaction Management

   Hibernate offers built-in transaction management, ensuring data consistency and integrity with less boilerplate code compared to JDBC.

8.  Database Independence

   Hibernate abstracts the underlying database details, allowing developers to switch databases with minimal code changes.

Hibernate over JDBC

Java Example to Hibernate over JDBC

Here’s an example demonstrating some of the advantages of Hibernate over JDBC, such as automatic table creation, simplified data access, and caching.

  1. Configuration File (hibernate.cfg.xml) :
  • Similar to previous examples, configure Hibernate using an XML file.

Example
xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydatabase</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <mapping class="com.example.MyEntity"/>
    </session-factory>
</hibernate-configuration>

2. Entity Class (MyEntity.java)

  • Define an entity class with JPA annotations for Hibernate to map it to a database table.

Example

java
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class MyEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters and setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

3. Hibernate Utility Class (HibernateUtil.java) :

  • Configure and provide a method to get the Hibernate Session.

Example

java
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory;

    static {
        try {
            sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static Session getSession() {
        return sessionFactory.openSession();
    }
}

4. Main Application Class (MainApp.java) :

  • Demonstrate automatic table creation, simplified data access, and caching.

Example

java
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;

public class MainApp {
    public static void main(String[] args) {
        // Get Session
        Session session = HibernateUtil.getSession();

        // Begin transaction
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();

            // Simplified data access - save an entity
            MyEntity entity = new MyEntity();
            entity.setName("Test Entity");
            session.save(entity);

            // Commit transaction
            transaction.commit();

            // Use caching and simplified queries
            Query<MyEntity> query = session.createQuery("from MyEntity where name = :name", MyEntity.class);
            query.setParameter("name", "Test Entity");
            MyEntity result = query.uniqueResult();
            System.out.println("Queried Entity Name: " + result.getName());

        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}


Comparison with JDBC

For comparison, here’s how you would achieve the same functionality using JDBC.

  1. JDBC Example : Demonstrate the equivalent operations in JDBC, highlighting the verbosity and complexity compared to Hibernate.

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

public class MainAppJDBC {
    private static final String JDBC_URL = "jdbc:mysql://localhost:3306/mydatabase";
    private static final String JDBC_USER = "root";
    private static final String JDBC_PASSWORD = "password";

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

        try {
            // Establish connection
            connection = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD);

            // Insert entity
            String insertSQL = "INSERT INTO MyEntity (name) VALUES (?)";
            preparedStatement = connection.prepareStatement(insertSQL);
            preparedStatement.setString(1, "Test Entity");
            preparedStatement.executeUpdate();

            // Query entity
            String querySQL = "SELECT id, name FROM MyEntity WHERE name = ?";
            preparedStatement = connection.prepareStatement(querySQL);
            preparedStatement.setString(1, "Test Entity");
            resultSet = preparedStatement.executeQuery();

            if (resultSet.next()) {
                System.out.println("Queried Entity Name: " + resultSet.getString("name"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) resultSet.close();
                if (preparedStatement != null) preparedStatement.close();
                if (connection != null) connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

Homepage

Readmore