Home Hibernate Hibernate Dirty Checking
Questions:Ask|Latest


 
 

Share on Google+Share on Google+

Hibernate Dirty Checking

Advertisement
This section contains the concept of Hibernate dirty checking.

Hibernate Dirty Checking

This section contains the concept of Hibernate dirty checking.

Dirty checking concept :

Dirty checking is a concept to avoid time consuming database write actions. By this concept, all necessary updating and changes are done without affecting the other fields.
Only the changed fields of database are updated and the remaining unchanged fields are left untouched.

Hibernate Dirty Checking :

Hibernate allows dirty checking feature. It saves developer's time and effort in updating of database when states of objects are modified inside a transaction.
Hibernate automatically detects the object states whenever changed and synchronized with the database in order to update.

Example :Here is Hibernate dirty checking example.

Step1. configuration file : hibernate.cfg.xml

hibernate-cfg.xml is configuration file saved in the same folder where the source code of class file is saved. It creates the connection pool and set-up required environment.

<?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>

<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/hibernate_examples</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">1</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">thread</property>
<!-- Disable the second-level cache -->
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">none</property>
<mapping class="net.roseindia.table.Student" />

</session-factory>

</hibernate-configuration>

Step 2. Now create Persistent class ?Hibernate uses the Plain Old Java Object (POJO) classes to map to the databse table.
Here is the code of  Student.java-

package net.roseindia.table;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "student")
public class Student implements Serializable {
public Student() {

}

@Id
@GeneratedValue
@Column(name = "roll_no")
private long roll;

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

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

public long getRoll() {
return roll;
}

public void setRoll(long roll) {
this.roll = roll;
}

public String getName() {
return name;
}

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

public String getCourse() {
return course;
}

public void setCourse(String course) {
this.course = course;
}

}

Step 3 . Now create an util class as HibernateUtil.java

package net.roseindia.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try {
sessionFactory = new AnnotationConfiguration().configure()
.buildSessionFactory();
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}

public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}

Step 4.Here is main class having the concept of dirty checking. It automatically update the changed value in the table without affecting other fields.

package net.roseindia.apps;

import net.roseindia.table.Student;
import net.roseindia.util.HibernateUtil;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class MyApplication{
public static void main(String []args){
Session session = HibernateUtil.getSessionFactory().openSession();
Transaction transaction = null;
try {
transaction = session.beginTransaction();
Student student = (Student) session.load(Student.class, new Long(1));
System.out.println("Student Name: "+student.getName());
student.setName("Rondy");
session.getTransaction().commit();
session.flush();
System.out.println("After updation Student name :"+student.getName());
} catch (HibernateException e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
}

Output:

Hibernate: select student0_.roll_no as roll1_0_0_, student0_.course as course0_0_, student0_.name as name0_0_ from student student0_ where student0_.roll_no=?
Student Name: Mandy
Hibernate: update student set course=?, name=? where roll_no=?
After updation Student name :Rondy

Download source code

Advertisements

Liked it!  Share this Tutorial


Follow us on Twitter, or add us on Facebook or Google Plus to keep you updated with the recent trends of Java and other open source platforms.

Posted on: June 27, 2012

Ask Questions?    Discuss: Hibernate Dirty Checking  

Post your Comment


Your Name (*) :
Your Email :
Subject (*):
Your Comment (*):
  Reload Image
 
 
Comments
bhargav kumar
September 19, 2013
need of flush() ?

in the above example when we commit then session will be flushed and commited (commit=flush+commit) then what is the use of using flush after commit method?
DMCA.com