hibernate caching and first level cache

Hibernate caching is an essential concept that helps in optimizing database access and improving the performance of Hibernate applications. Caching in Hibernate can be divided into two levels: first-level cache and second-level cache. Let’s start with an explanation of the first-level cache.

Hibernate First-Level Cache

  Explanation

• Definition : The first-level cache in Hibernate is associated with the Session object. It is enabled by default and cannot be disabled. The main purpose of this cache is to reduce the number of database queries by storing objects that have been retrieved or saved during the lifespan of a Session.
• Scope : The scope of the first-level cache is limited to a session. Each session has its own first-level cache, which means that objects stored in one session’s cache are not visible to another session.
• Lifecycle : The cached objects are available until the session is closed, after which the cache is cleared.

 Advantages

• Reduced Database Access : By caching objects within a session, Hibernate reduces the number of times it needs to query the database.
• Improved Performance : As a result of reduced database access, application performance is improved.
• Automatic Management : Hibernate automatically manages the first-level cache, so developers do not need to explicitly interact with it.

Example in Java: Here’s a simple Java example demonstrating the first-level cache in Hibernate

java
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
	
public class HibernateFirstLevelCacheExample {
    public static void main(String[] args) {
        // Create SessionFactory
        SessionFactory sessionFactory = new Configuration().configure("hibernate.cfg.xml")
                .addAnnotatedClass(Student.class)
                .buildSessionFactory();

        // Create Session
        Session session = sessionFactory.openSession();
        
        try {
            // Start transaction
            session.beginTransaction();
            
            // Fetch student with id 1 (first query)
            Student student1 = session.get(Student.class, 1);
            System.out.println(student1);
            
            // Fetch student with id 1 again (second query, should be served from cache)
            Student student2 = session.get(Student.class, 1);
            System.out.println(student2);
            
            // Commit transaction
            session.getTransaction().commit();
        } finally {
            session.close();
            sessionFactory.close();
        }
    }
}

@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "email")
    private String email;

    // Getters and setters
    // toString method
}

Example

In this example, when the Student entity with ID 1 is fetched the first time, it is retrieved from the database and stored in the first-level cache. When the same entity is fetched again within the same session, it is retrieved from the cache, and no additional database query is made.

Homepage

Readmore