MyArchiBook

Hibernate Persistence Context and Object’s LifeCycle

with 4 comments

A Software Industry mainly works on Enterprise Applications. When Persistence Frameworks are being used in the application, then it is better to know about the Persistence Context and Object’s Life Cycle, inorder to deal with the complexities.

BASICS:

  • Object Oriented Programming(OOP)  plays a major central role for developing any application. It is a design concept. It can be imagined as a Collection Of  Interacting Objects.
  • Relational Database Management System helps to store these entity objects into the Database objects(tables).
  • Object Relational Mapping (ORM) relates  objects from Object Oriented domain with relational Data model via mapping.

JPA

    Java Persistence API(JPA exists in JEE5 and higher ) is a specification which  has the features that will make the ORM work.It deals with , how Java Objects(“persistent entites”)are stored in the relational database, how they can be accessed and how the object’s state can be stored so that it can be  restored when the appication is restarted .

Hibernate 3.2,EJB 3 ,TopLink and etc., are frameworks that implement this JPA.

In this post I have briefed on Hibernate’s Persistence Context Pattern and the Object’s LifeCycle.

HIBERNATE PERSISTENCE CONTEXT PATTERN AND OBJECT’S LIFE CYCLE:

  • HIBERNATE is a Simple Persistence Framework . It is a flexible framework even.Flexible, because  it can be used even with or without an application server.
  • Hibernate provides functionality that persists objects of an object-oriented programming environment into some persistent store. These persisted objects are called Persistent Objects.
  • The place where the persistent objects are created,modified and retrieved is called the Persistence Context.
  • The three most importantly used classes of Hibernate’s Persistence API are,
  1. org.hibernate.SessionFactory
  2. org.hibernate.Session
  3. org.hibernate.Transaction

object-life-cycle

  • SessionFactory has the contract to create session instances for the application.Usually one data source has a single session factory instance. In an application, the threads servicing client requests, obtain Session Instances from this factory.
  • Session is THE Hibernate’s Persistence Context.The lifetime of a session is bound between the beginning and the end of a transaction.As said earlier, the persistent objects are created,modified and retrieved only in this session. While carrying out these operations on the objects, they might exist in one of these three states,
  1. transient state
  2. persistent state
  3. detached state
  • Transaction defines the UNIT OF WORK for an application.It is instantiated when Session.beginTransaction() is called.

Let’s get into examples to understand the Object’s life cycle with respect to Persistence Context.Here I have considered an example related to Company and its Chairman.

Attributes: Company Name and Chairman..

CASE 1:

public class CompanyDao {
	public void enterCompanyDetails(){
		Session session=HibernateSessionManager.getInstance().getHibernateSession();
		Transaction transaction=session.beginTransaction();
		try{
			transaction.begin();
			CompanyDetails companyDetails=new CompanyDetails();
			companyDetails.setCompanyName("Apple");
			companyDetails.setCompanyChairman("Steve Jobs");
			session.save(companyDetails);
            EmployeeDetails employeeDetails=new EmployeeDetails();
            employeeDetails.setNoOfEmployees(100000);
            transaction.commit();
		}catch (HibernateException e) {
			transaction.rollback();
		}finally{
			session.close();
		}
	}
}

Logic:SAVE —> COMMIT

  • Line 8 and 9 – the company name and chairman are set to the CompanyDetails object. Now this object’s instance which is a new one exists in the transient State.
  • Line 10- the object’s instance is being saved, which means it is being persisted in the Persistence Context. Now it is in the persistent state.
  • Line 11- a new employeeInstance is created.
  • Line 12- attribute is set to the instance. The instance now exists in the transient state.
  • When the transaction is committed, only the objects in the Persistence Context gets persisted in the Database as a record.i.e.,Here the persistent object companyDetails gets persisted but employeeDetails does not get persisted because it is in transient state.

Check out if you can answer this question ,

Qn.When you  Insert a data and update the same data in a session , will a new memory object be created in the Persistence Context or will it get Updated in the existing object in the Persistence Context…???

Ans: No, a new object is not created in Persistence Context while updating. Instead , the persistent object created when saving the object in the persistence context gets updated.

The answer is explained with an example below,

CASE 2:

public class CompanyDao {
	public void enterCompanyDetails(){
		Session session=HibernateSessionManager.getInstance().getHibernateSession();
		Transaction transaction=session.beginTransaction();
		try{
			transaction.begin();
			CompanyDetails companyDetails=new CompanyDetails();
			companyDetails.setCompanyName("Infosys");
			companyDetails.setCompanyChairman("K.V.Kamath");
			session.save(companyDetails);
			companyDetails.setCompanyChairman("Narayana Murthy");
			session.update(companyDetails);
            transaction.commit();
		}catch (HibernateException e) {
			transaction.rollback();
		}finally{
			session.close();
		}
	}
}

Logic: SAVE –> UPDATE –> COMMIT
TRUE 1

  • Line 8,9 – the attributes are set to the object.The object’s instance is in the transient state.
  • Line 10-The instance is saved. So , it moves to the Persistence Context and becomes a persistent object.
  • Line 11- the instance is again set.
  • Line 12- the instance is updated in the Persistence Context. I mean, already an object is created in the persistence context and that object gets modified/updated. New object is not created in the persistence context.
  • Line 13 – The persistent object is committed/persisted to the DB.

Note:Update() can be performed only on Persistent Objects and not on transient/detached objects whereas saveOrUpdate() automatically converts a transient/detached object to persistent object.

CASE 3:

public class CompanyDao {
	public void enterCompanyDetails(){
		Session session=HibernateSessionManager.getInstance().getHibernateSession();
		Transaction transaction=session.beginTransaction();
		try{
			transaction.begin();
			CompanyDetails companyDetails=new CompanyDetails();
			companyDetails.setCompanyName("Infosys");
			companyDetails.setCompanyChairman("K.V.Kamath");
			session.save(companyDetails);
			companyDetails.setCompanyChairman("Narayana Murthy");
			session.saveOrUpdate(companyDetails);
			session.clear();
			System.out.println("Company Details present : "+session.contains(companyDetails));
            transaction.commit();
		}catch (HibernateException e) {
			transaction.rollback();
		}finally{
			session.close();
		}
	}
}

Logic: SAVE –> UPDATE –> CLEAR –> COMMIT
false

Here in the above code,

  • Line 8,9 -Instance is set.It exists in the transient state.
  • Line 10 -Instance is saved to Persistence Context.It is in the persistent state now.
  • Line 11,12 – instance is set and updated in the Persistence Context
  • Line 13- All instances in the Persistance context are cleared. It has no instance in the context now. This means , the instance is in detached state now.

Like clear() there is also another method evict().The difference is ,evict() detaches a particular instance from the context but clear() detaches all the instances from the Persistence Context.
Hope this post has added an extra feather to your understanding.

Advertisements

Written by thangaveluaishwarya

June 7, 2013 at 9:56 PM

4 Responses

Subscribe to comments with RSS.

  1. Very good blog. For a new bee like me it is very use full

    newbee

    June 11, 2013 at 8:30 AM

  2. Nice. cont this good post

    Mad Rush

    June 16, 2013 at 11:05 AM

  3. interesting. not many touch and discuss specific topics and areas like you have. it should be useful for people to undertand the topics

    Santhosh

    June 21, 2013 at 1:28 PM

  4. Nice article, thanks!

    robert-rusu

    July 28, 2015 at 11:20 PM


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: