Hibernate Framework Architecture and Basics
Hibernate Hello World Tutorial
Hibernate XML Configuration Example
Hibernate Java Configuration Example
Hibernate Transaction Management
Hibernate/JPA - Primary Key Generation Strategies
JPA and Hibernate Cascade Types
Hibernate - Save an Entity Example
Hibernate - Persist an Entity Example
Hibernate - saveOrUpdate() Method Example
Hibernate - get(), load() and byId() Method
Hibernate - merge() Example
Hibernate - Delete or Remove an Entity Example
Hibernate - load() Method Example
Hibernate Session.clear() Method Example
Hibernate One to One Mapping
Hibernate One to Many Mapping
Hibernate Many to Many Annotation
Hibernate One to Many CRUD Example
Hibernate One to One CRUD Example
Hibernate Inheritance Mapping
Hibernate Query Language
Hibernate CRUD Operations Example
Hibernate Session Interface Methods
JSP Servlet Hibernate CRUD Example
Hibernate Registration Form Example
Login Form using JSP + Servlet + Hibernate + MySQL
More .........
In this post, we will understand the Hibernate first-level cache with an example.
Important points
First level cache retrieval example
In this example, we are fetching student object from the database using a hibernate session. we will retrieve it multiple times and will observe the SQL logs to see the differences.
package net.javaguides.hibernate.tutorial;
import org.hibernate.Session;
import org.hibernate.Transaction;
import net.javaguides.hibernate.tutorial.config.HibernateJavaConfig;
import net.javaguides.hibernate.tutorial.entity.Student;
public class FirstLevelCacheDemo {
public static void main(String[] args) {
Transaction transaction = null;
try (Session session = HibernateJavaConfig.getSessionfactory().openSession()) {
// start the transaction
transaction = session.beginTransaction();
// get the student entity using id
Student student1 = session.load(Student.class, new Long(1));
System.out.println(student1.getFirstName());
System.out.println(student1.getLastName());
System.out.println(student1.getEmail());
// load student entity by id
Student student2 = session.load(Student.class, new Long(1));
System.out.println(student2.getFirstName());
System.out.println(student2.getLastName());
System.out.println(student2.getEmail());
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
}
}
}
Output:
Hibernate: select student0_.id as id1_0_0_, student0_.email as email2_0_0_, student0_.first_name as first_na3_0_0_, student0_.last_name as last_nam4_0_0_ from student student0_ where student0_.id=?
Prabhas
Fadatare
prabhas@gmail.com
Prabhas
Fadatare
prabhas@gmail.com
As you can see the second “session.load()” statement does not execute the select query again and loads the student entity directly.
First level cache retrieval example with a new session
With the new session, an entity is fetched from the database again irrespective of whether it is already present in any other session in the application.
package net.javaguides.hibernate.tutorial;
import java.io.Serializable;
import org.hibernate.Session;
import org.hibernate.Transaction;
import net.javaguides.hibernate.tutorial.config.HibernateJavaConfig;
import net.javaguides.hibernate.tutorial.entity.Student;
public class FirstLevelCacheDemo1 {
public static void main(String[] args) {
Transaction transaction = null;
try (Session session = HibernateJavaConfig.getSessionfactory().openSession(); Session session1 = HibernateJavaConfig.getSessionfactory().openSession()) {
// start the transaction
transaction = session.beginTransaction();
// get the student entity using id
Student student1 = session.load(Student.class, new Long(1));
System.out.println(student1.getFirstName());
System.out.println(student1.getLastName());
System.out.println(student1.getEmail());
// load student entity by id
Student student2 = session.load(Student.class, new Long(1));
System.out.println(student2.getFirstName());
System.out.println(student2.getLastName());
System.out.println(student2.getEmail());
// load student entity by id
Student student3 = session1.load(Student.class, new Long(1));
System.out.println(student3.getFirstName());
System.out.println(student3.getLastName());
System.out.println(student3.getEmail());
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
}
}
}
Output:
Hibernate: select student0_.id as id1_0_0_, student0_.email as email2_0_0_, student0_.first_name as first_na3_0_0_, student0_.last_name as last_nam4_0_0_ from student student0_ where student0_.id=?
Prabhas
Fadatare
prabhas@gmail.com
Prabhas
Fadatare
prabhas@gmail.com
Hibernate: select student0_.id as id1_0_0_, student0_.email as email2_0_0_, student0_.first_name as first_na3_0_0_, student0_.last_name as last_nam4_0_0_ from student student0_ where student0_.id=?
Prabhas
Fadatare
prabhas@gmail.com
You can see that even if the student entity was stored in the “session” object, still another database query was executed when we use another session object “session1”.
Removing cache objects from first level cache example
Though we can not disable the first-level cache in hibernate, we can certainly remove some of the objects from it when needed. This is done using two methods :
- Session.evict()
- Session.clear()
Here Session.evict() is used to remove a particular object from the cache associated with a session, and a clear() method is used to remove all cached objects associated with a session. So they are essentially like remove one and remove all.
package net.javaguides.hibernate.tutorial;
import org.hibernate.Session;
import org.hibernate.Transaction;
import net.javaguides.hibernate.tutorial.config.HibernateJavaConfig;
import net.javaguides.hibernate.tutorial.entity.Student;
public class RemoveFirstCacheDemo {
public static void main(String[] args) {
Transaction transaction = null;
try (Session session = HibernateJavaConfig.getSessionfactory().openSession()) {
// start the transaction
transaction = session.beginTransaction();
// get the student entity using id
Student student1 = session.load(Student.class, new Long(1));
System.out.println(student1.getFirstName());
System.out.println(student1.getLastName());
System.out.println(student1.getEmail());
// load student entity by id
Student student2 = session.load(Student.class, new Long(1));
System.out.println(student2.getFirstName());
System.out.println(student2.getLastName());
System.out.println(student2.getEmail());
//session.evict(student2);
session.clear();
// load student entity by id
Student student3 = session.load(Student.class, new Long(1));
System.out.println(student3.getFirstName());
System.out.println(student3.getLastName());
System.out.println(student3.getEmail());
// commit transaction
transaction.commit();
} catch (Exception e) {
if (transaction != null) {
transaction.rollback();
}
}
}
}
Clearly, Session.evict() method removed the student object from the cache so that it was fetched again from the database.
Conclusion
In this article, we understood how the Hibernate first-level cache works with an example. Learn the complete hibernate framework at https://www.javaguides.net/p/hibernate-tutorial.htmFree Spring Boot Tutorial | Full In-depth Course | Learn Spring Boot in 10 Hours
Watch this course on YouTube at Spring Boot Tutorial | Fee 10 Hours Full Course
best explanation, thanks a lot
ReplyDelete