public class CustomerDAOImpl implements CustomerDAO {
    public List getCustomerIdAndName() throws Exception {
  // TODO Auto-generated method stub
  SessionFactory sessionFactory = HibernateUtility.createSessionFactory();
  Session session = null;
  List
  List customers = new LinkedList();
  Customer customer = null;
  
  //Creating the query to fetch customer id and names of the customers
  String hql= "select CE.customerId,CE.customerName from CustomerEntity CE ";
  
  /* We can also create the query without using the alias name
   * String hql= "select customerId,customerName from CustomerEntity";
   */
  try {
   session = sessionFactory.openSession();
   
   //Creating query object
   Query query = session.createQuery(hql);
   
   //Executing the query
   objects = query.list();
   
   for (Object[] object : objects) {
    customer = new Customer();
    customer.setCustomerId((Integer)object[0]);
    customer.setCustomerName((String)object[1]);
    customers.add(customer);
    
   }
   
  } catch (HibernateException exception) {
   exception.printStackTrace();
   DOMConfigurator.configure("src/resources/log4j.xml");
   Logger logger = Logger.getLogger(this.getClass());
   logger.error(exception.getMessage(), exception); 
   throw new Exception("DAO.TECHNICAL_ERROR");
  } 
  catch (Exception exception) {
   exception.printStackTrace();
   DOMConfigurator.configure("src/resources/log4j.xml");
   Logger logger = Logger.getLogger(this.getClass());
   logger.error(exception.getMessage(), exception);
   throw exception;
  }
  finally {
   if(session.isOpen()|| session!=null){
    session.close();
   }
  
  
 }
  return customers;
 }}

String hql = "from CustomerEntity ce where ce.customerName='"+customerName+"' and ce.dateOfBirth='"+dateOfBirth;

String hql = "from CustomerEntity ce where ce.customerName=? and ce.dateOfBirth=?";

query.setString(0,customerName);   //or query.setParameter(0, customerName)
query.setCalendar(1,dateOfBirth);  //or query.setParameter(1,dateOfBirth)

String hql = "from CustomerEntity ce where ce.customerName=:customerName and ce.dateOfBirth=:dateOfBirth";

query.setParameter("customerName", customerName);
query.setParameter("dateOfBirth", dateOfBirth);

String hql = "from CustomerEntity ce where ce.customerName=:customerName and ce.dateOfBirth=:dateOfBirth";

// Creating a new bean object which will be used to set parameters
Customer customerBean = new Customer(); 
customerBean.setCustomerName(customer.getCustomerName());
customerBean.setDateOfBirth(customer.getDateOfBirth());
   
// Setting the parameter values using the bean object
query.setProperties(customerBean);

Good coding practices in parameter setting

If more than one parameters are to be set in your query:

• Defining a positional parameter after named parameter will cause an error?

SELECT c.customerName FROM CustomerEntity c WHERE c.customeId= :id AND c.address = ?

• It is allowed to define a positional parameter before a named parameter?

SELECT c.customerName FROM CustomerEntity c WHERE c.customeId= ? AND c.address = :ad

• It is easier to use and maintain
• It increases the readability of the code
• It makes the code look cleaner

public class CustomerDAOImpl implements CustomerDAO{
public Integer updateCustomerDetails(String customerName,Calender dob,String newAddress,Long newNumber)throws Exception{
  SessionFactory sessionFactory= null;
  Session session=null;
  Integer noOfRowsUpdated = null;

  // Creating a query to update the address and contact number of the customer
  String hql = "Update CustomerEntity ce set ce.address=:address,ce.contactNumber=:contactNumber where 
                           ce.customerName=:customerName and ce.dateOfBirth=:dateOfBirth";
  try {
   sessionFactory=HibernateUtility.createSessionFactory();
   session=sessionFactory.openSession();

   Query query = session.createQuery(hql);                           // Creating the query object
   
   query.setParameter("address", newAddress);             //setting parameters
   query.setParameter("dateOfBirth", dob);
   query.setParameter("customerName", customerName);
   query.setParameter("contactNumber", newNumber);

                        session.beginTransaction()
   noOfRowsUpdated = query.executeUpdate();          // Executing the query, returns the number of rows updated
                        session.getTransaction().commit();
  }catch (HibernateException exception) {
   throw new Exception("DAO.TECHNICAL_ERROR");
  }catch (Exception exception) {
   throw exception;
  }finally {
   if(session.isOpen()|| session!=null){
    session.close();
   }
  } 
  return noOfRowsUpdated;
 }
}

1. Create instance of SessionFactory and Session
2. Create a Query object to update the details
3. Begin a transaction
4. Execute the Query
5. Commit the transaction
6. Close SessionFactory and Session

2. Create a Query object to update the details

String hql = "Update CustomerEntity ce set ce.address=:address,ce.contactNumber=:contactNumber where 
                        ce.customerName=:customerName and ce.dateOfBirth=:dateOfBirth";

Query query = session.createQuery(hql);

4. Execute the Query object

query.executeUpdate();

public class CustomerDAOImpl implements CustomerDAO{
public Integer deleteCustomerDetails(String address)throws Exception{
        SessionFactory sessionFactory=null;
        Session session=null;
        Integer noOfRowsUpdated= null ;
        
        String hql = "delete from CustomerEntity ce where ce.address=:address";    // Creating the query 
        try {
            sessionFactory=HibernateUtility.createSessionFactory();
            session=sessionFactory.openSession();
            Query query = session.createQuery(hql);                                // Creating the query object 
            query.setParameter("address", address);
            
            session.beginTransaction();
            noOfRowsUpdated = query.executeUpdate();                               // Executing the query
            session.getTransaction().commit();
            
        }catch (HibernateException exception) {
            throw new Exception("DAO.TECHNICAL_ERROR");
        }catch (Exception exception) {
            throw exception;
        }finally {
            if(session.isOpen()|| session!=null){
                session.close();
            }
        }
        return noOfRowsUpdated;
    }
}

1. Create instance of SessionFactory and Session
2. Create a Query object to delete the details
3. Begin a transaction
4. Execute the Query object
5. Commit the transaction
6. Close SessionFactory and Session

2.Create a Query object to delete the details

String hql = "delete from CustomerEntity ce where ce.address=:address";

4. Execute the Query object

query.executeUpdate();

public class CustomerDAOImpl implements CustomerDAO{
public Integer filterCustomers(String address,Calendar dateOfBirth) throws Exception{
        SessionFactory sessionFactory= null;
        Session session=null;
        Integer noOfRowsAffected = null;
        // Creating the query to filter the customers
        String hql = "insert into SeniorCustomerEntity(customerId,customerName,dateOfBirth,address,contactNumber) "
                      +" select customerId,customerName,dateOfBirth,address,contactNumber "
                      + "from CustomerEntity ce where ce.address=:address and ce.dateOfBirth<:dateofbirth span="">
        
        try {
            sessionFactory = HibernateUtility.createSessionFactory();
            session = sessionFactory.openSession();
            Query query = session.createQuery(hql);                                    // Creating query object
            query.setParameter("address", address);                                    //parameter setting
            query.setParameter("dateOfBirth", dateOfBirth);
            
            session.beginTransaction();           
            noOfRowsAffected = query.executeUpdate();                                 // Executing the query
            session.getTransaction().commit();
            
        }catch (HibernateException exception) {
            throw new Exception("DAO.TECHNICAL_ERROR");
        }catch (Exception exception) {
            throw exception;
        }finally {
            if(session.isOpen()|| session!=null){
                session.close();
            }
     }
        return noOfRowsAffected;
    }
}

1. Create instance of SessionFactory and Session
2. Create a Query object to insert the details
3. Begin a transaction
4. Execute the Query object
5. Commit the transaction
6. Close SessionFactory and Session

String hql = "insert into SeniorCustomerEntity(customerId,customerName,dateOfBirth,"
    + "address,contactNumber) "+
  " select customerId,customerName,dateOfBirth,address,contactNumber "
  + "from CustomerEntity ce where ce.address=:address and ce.dateOfBirth<:dateofbirth pre="">

4. Execute the Query object

To execute the Query you need to invoke executeUpdate() method.
query.executeUpdate();

This method will execute the query and return the number of rows inserted.

NOTE: HQL supports the insertion of data from one table to another table. HQL cannot be used to directly insert values into a table as it has to be performed with Session methods persist()/save()

@Entity
@Table(name="account")
public class AccountEntity {
 @Id
 private Long accountNo;
 private String accountType;
 @Temporal(TemporalType.DATE)
 private Calendar openingDate;
 private Double balance;
 private String accountStatus;
 @ManyToOne(cascade=CascadeType.ALL)
 @JoinColumn(name="customerId")
 private CustomerEntity customer;
 //generate getters and setters
}

public class CustomerDAOImpl implements CustomerDAO {
 public List

1. Implicit join - JOIN keyword not used explicitly and the relationship is dereferenced using dot operator
2. Explicit join - JOIN keyword is used explicitly which increases the readability of code

public class AccountDAOImpl implements AccountDAO {
      public result minAggregate() throws Exception {
  
  SessionFactory sessionFactory = HibernateUtility.createSessionFactory();
  Session session = null;
  Object result[]= null;

  String hql = "select min(ae.balance), max(ae.balance), sum(ae.balance), avg(ae.balance), count(ae.balance)"
                               +" from AccountEntity ae";              // Creating the query
  try{
  session = sessionFactory.openSession();
  Query query = session.createQuery(hql);        // Creating the query object
  result= query.uniqueResult();             // Executing the query
  }catch (HibernateException exception) {
   throw new Exception("DAO.TECHNICAL_ERROR");
  }catch (Exception exception) {
   throw exception;
  }finally {
   if(session.isOpen()|| session!=null){
       session.close();
   }
  }
  return result;
 }
}

public class CustomerDAOImpl implements CustomerDAO {
 public List

public class AccountDAOImpl implements AccountDAO{

 @SuppressWarnings("unchecked")
 @Override
 public void groupByHavingOrderByFunction() throws Exception {
  SessionFactory sessionFactory = HibernateUtility.createSessionFactory();
  Session session = sessionFactory.openSession();

  try { 
   Query query=session.createQuery("select accountType, avg(balance) from AccountEntity "
                                         + "group by accountType having count(accountNo)>=2 order by avg(balance)");
                        //Query using group by and having and order By 
   List

public class CustomerDAOImpl implements CustomerDAO {
        public void updateCustomer() throws Exception {

                // code to create SessionFactory and Session 
  
                Query query = session.createQeury("from CustomerEntity");
                List clist = query.list();

                //rest of your code    
        } 
        public void getCustomerDetails()throws Exception {

                // Code to create SessionFactory and Session
   
                Query query = session.createQeury("from CustomerEntity");
                List clist = query.list();

                // rest of your code   
        }
        public void DeleteCustomers()throws Exception {

                // Code to create SessionFactory and Session 

                Query query = session.createQeury("from CustomerEntity");
                List clist = query.list();
                
                // rest of your code 
        }
}

@Entity
@Table(name="customer")
@NamedQuery(name ="CustomerEntity.retrieve", query ="from CustomerEntity")
public class CustomerEntity {
 @Id
 private Integer customerId;
 private String customerName;
 @Temporal(TemporalType.DATE)
 private Calendar dateOfBirth;
 private String address;
        @Column(name="phoneNumber")
 private Long ContactNamber;
 
 //generate getters and setters
}

public class CustomerDAOImpl implements CustomerDAO {
        public void updateCustomer() throws Exception {

                // code to create SessionFactory and Session
   
                Query query = session.getNamedQuery("CustomerEntity.retrieve");
                List clist = query.list();
                
               //rest of your code    
        } 
        public void getCustomerDetails()throws Exception {

                // Code to create SessionFactory and Session 
  
                Query query = session.getNamedQuery("CustomerEntity.retrieve");
                List clist = query.list(); 

                // rest of your code   
        }
        public void DeleteCustomers()throws Exception {

                // Code to create SessionFactory and Session 

                Query query = session.getNamedQuery("CustomerEntity.retrieve");
                List clist = query.list(); 

                // rest of your code 
        }
}

@Entity
@Table(name="customer")
@NamedQueries({
 @NamedQuery(name ="CustomerEntity.update", query ="update CustomerEntity CE set CE.address=?,CE.contactNumber=? where CE.customerName=? and CE.dateOfBirth=?")
 ,@NamedQuery(name="CustomerEntity.retreive", query="from CustomerEntity")
})
public class CustomerEntity {
 @Id
 private Integer customerId;
 private String customerName;
 @Temporal(TemporalType.DATE)
 private Calendar dateOfBirth;
 private String address;
 private Long contactNumber;
 
 //generate getters and setters
}

Difference between SQL and HQL

Query Interface

The methods used to execute the query are

The methods used to set parameters are:

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   String searchString="M";
   session=sessionFactory.openSession();
   Criteria criteria=session.createCriteria(CustomerEntity.class);
   
   Criterion condition1 = Restrictions.like("address", searchString+"%");
                        Criterion condition2 = Restrictions.isNotNull("contactNumber");
                       
                        criteria.add(Restrictions.and(condition1,condition2));
   
   ProjectionList requiredColumns = Projections.projectionList();
   
   requiredColumns.add(Projections.property("customerName"));
   requiredColumns.add(Projections.property("address"));
   
   criteria.setProjection(requiredColumns);
   
   criteria.addOrder(Order.asc("customerName"));
   
   List
   System.out.println( "CustomerName"+ "\t" + "Address");
   for (Object[] obj : cusList) {
    System.out.println(obj[0]  + "\t\t" + obj[1]);
   }
   
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {   
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   String searchString="M";
   session=sessionFactory.openSession();
   Criteria criteria=session.createCriteria(CustomerEntity.class);
 
   List cusList=criteria.list();   //executes the statement and returns the list of customer entity
 
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   String searchString="M";
   session=sessionFactory.openSession();
   Criteria criteria=session.createCriteria(CustomerEntity.class);
   
   criteria.add(Restrictions.like("address", searchString+"%"));
   
   List cusList=criteria.list();
   
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {   
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

The output will be:

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   String searchString="M";
   session=sessionFactory.openSession();
   Criteria criteria=session.createCriteria(CustomerEntity.class);
   
   Criterion condition1 = Restrictions.like("address", searchString+"%");
                        Criterion condition2 = Restrictions.isNotNull("contactNumber");
                       
                        criteria.add(Restrictions.and(condition1,condition2));
     
   List Object[] cusList=criteria.list();
   
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {   
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

criteria.add(Restrictions.like("address", searchString+"%")).add(Restrictions.isNotNull("contactNumber"));

Let us add SELECT clause elements in our query as shown below:

SELECT customerName FROM Customer WHERE address LIKE "?%" AND phoneNumber IS NOT NULL;

To represent the column list in SELECT clause, you have to use Projections class. The property() method of Projections is used to indicate the property name that we want to fetch and it returns the Projection object which needs to be set to Criteria using setProjection() method. 

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   String searchString="M";
   session=sessionFactory.openSession();
   Criteria criteria=session.createCriteria(CustomerEntity.class);
   
   Criterion condition1 = Restrictions.like("address", searchString+"%");
                        Criterion condition2 = Restrictions.isNotNull("contactNumber");
                       
                        criteria.add(Restrictions.and(condition1,condition2));
   
   criteria.setProjection(Projections.property("customerName"));
   
   List String cusList=criteria.list();
   
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {   
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

The output would be:

Since we are not retrieving the whole row, the list() method does not return list of customer entity objects. It will be list of strings as we only retrieve names. i.e. the list type will be based on type of attribute retrieved.

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   String searchString="M";
   session=sessionFactory.openSession();
   Criteria criteria=session.createCriteria(CustomerEntity.class);
   
   Criterion condition1 = Restrictions.like("address", searchString+"%");
                        Criterion condition2 = Restrictions.isNotNull("contactNumber");
                       
                        criteria.add(Restrictions.and(condition1,condition2));
   
   ProjectionList requiredColumns = Projections.projectionList();
   
   requiredColumns.add(Projections.property("customerName"));
   requiredColumns.add(Projections.property("address"));
   
   criteria.setProjection(requiredColumns);
   
   List Object[] cusList=criteria.list();
   
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {   
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

The output of the code will be:

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   String searchString="M";
   session=sessionFactory.openSession();
   Criteria criteria=session.createCriteria(CustomerEntity.class);
   
   Criterion condition1 = Restrictions.like("address", searchString+"%");
                        Criterion condition2 = Restrictions.isNotNull("contactNumber");
                       
                        criteria.add(Restrictions.and(condition1,condition2));
   
   ProjectionList requiredColumns = Projections.projectionList();
   
   requiredColumns.add(Projections.property("customerName"));
   requiredColumns.add(Projections.property("address"));
   
   criteria.setProjection(requiredColumns);
   
   criteria.addOrder(Order.asc("customerName"));
   
   List Object[] cusList=criteria.list();
   
    System.out.println( "CustomerName"+ "\t" + "Address");
   for (Object[] obj : cusList) {
    System.out.println(obj[0]  + "\t\t" + obj[1]);
   }
   
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {   
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

The final output of the implementation of requirement R.12.1 will be

public class CustomerDao {
 
 @SuppressWarnings("unchecked")
 public void SearchCustomerByAddress() throws Exception{

  SessionFactory sessionFactory=HibernateUtility.createSessionFactory();
  Session session=null;
  try {
   Criteria criteria = session.createCriteria(AccountEntity.class);
   ProjectionList projList = Projections.projectionList();
 
   projList.add(Projections.rowCount());
   projList.add(Projections.sum("balance"));
   projList.add(Projections.avg("balance"));
   projList.add(Projections.countDistinct("customerId"));
   criteria.setProjection(projList);
   list = criteria.list();
   
   System.out.println("Number of accounts: "+list.get(0)[0]);
   System.out.println("total balance of all accounts: "+list.get(0)[1]);
   System.out.println("average balance for each accounts: "+list.get(0)[2]);
   System.out.println("Number of unique customers: "+list.get(0)[3]);
   
  }catch (HibernateException exception) {   
                        throw new Exception("DAO.TECHNICAL_ERROR");
                }catch (Exception exception) {   
                        throw exception;
                }finally {
                        if(session.isOpen()|| session!=null)
                                session.close();
                }
         }
}

The output of the above code will be:

Difference between HQL and Criteria

Criteria API

By this time now you should be able to use below classes and interfaces of criteria API to perform the database operations.

Restrictions

Few methods of Restrictions class for basic relational constraints:

Few methods of Restrictions class for String matching constraints:18h,19h

Requirement 13: Hibernate caching

• Open the chrome browser and enter http://ilp02/stream
• Select any course like Fundamentals of Java Programming
• Click on View TOC/Start learning and open TOC
• Select first topic and go to the page
• Go 4-5 pages forward
• Remove the LAN connection
• Now click on browser's back and forward button at top left corner

Session session = sessionFactory.openSession();
CustomerEntity customer1 = (CustomerEntity)session.load(CustomerEntity.class, 5001);          
System.out.println("Customer Name 1: " + customer1.getCustomerName());
CustomerEntity customer2 = (CustomerEntity)session.load(CustomerEntity.class, 5001);          
System.out.println("Customer Name 2: " + customer2.getCustomerName());

public void getCustomer() {
  SessionFactory sessionFactory = HibernateUtility.createSessionFactory();
  try {
   Session session = sessionFactory.openSession();
   CustomerEntity customer1 = (CustomerEntity) session.load(CustomerEntity.class, 5007);
   System.out.println("Customer Name 1: "+ customer1.getCustomerName());

   session.evict(customer1);
   //session.clear();
   //System.out.println("Customer cleared from cache");

   CustomerEntity customer2 = (CustomerEntity) session.load(CustomerEntity.class, 5007);
   System.out.println("Customer Name 2: "+ customer2.getCustomerName());

  } catch (Exception e) {
   System.err.println(e.getMessage());
  } finally {
   HibernateUtility.closeSessionFactory();
  }
 }

• void Session.evict(entityObject) : Removes the entity object from session cache.
• boolean Session.contains(entityObject) : Checks whether the entity object is present in the session cache.
• void Session.clear() : Clears all the data present in session cache.

Session session = sessionFactory.openSession();
CustomerEntity customer1 = (CustomerEntity)session.load(CustomerEntity.class, 5001);          //cache miss
System.out.println("Customer Name 1: " + customer1.getCustomerName());
session.evict(customer1);
/*session.clear();*/
CustomerEntity customer2 = (CustomerEntity)session.load(CustomerEntity.class, 5001);          //cache miss
System.out.println("Customer Name 2: " + customer2.getCustomerName());

Session session1= sessionFactory.openSession();
session1.beginTransaction();
CustomerEntity customer1 = (CustomerEntity)session1.load(CustomerEntity.class, 5001);          //cache miss
System.out.println("Customer Name 1: " + customer1.getCustomerName());
//code for business transaction
session1.getTransaction.commit();
Session session2 = sessionFactory.openSession();
session2.beginTransaction();
CustomerEntity customer2 = (CustomerEntity)session2.load(CustomerEntity.class, 5001);          //cache miss
System.out.println("Customer Name 2: " + customer2.getCustomerName());
//code for business transaction
session2.getTransaction.commit();

Session session1= sessionFactory.openSession();
session1.beginTransaction();
CustomerEntity customer1 = (CustomerEntity)session1.load(CustomerEntity.class, 5001);          //cache miss
System.out.println("Customer Name 1: " + customer1.getCustomerName());
//code for business transaction
session1.getTransaction.commit();
session1.evict(customer1);
Session session2 = sessionFactory.openSession();
session2.beginTransaction();
CustomerEntity customer2 = (CustomerEntity)session2.load(CustomerEntity.class, 5001);          //cache hit
System.out.println("Customer Name 2: " + customer2.getCustomerName());
//code for business transaction
session2.getTransaction.commit();

• EHCache or Easy Hibernate Cache
• OSCache
• SwarmCache
• JBossCache

@Entity
@Table(name="Customer")
@Cacheable
@Cache(usage=CacheConcurrencyStrategy.READ_ONLY)
public class CustomerEntity {
 @Id
 private Integer customerId; 
 //properties, getters and setters 
}

• TRANSACTIONAL
• READ_WRITE
• NONSTRICT_READ_WRITE
• READ_ONLY

• void SessionFactory.getCache.evictEntity(EntityClass.class, primarykey) : Removes the entity object from session factory cache.
• boolean SessionFactory.getCache.contains(EntityClass.class, primarykey) : Checks whether the entity object is present in the session factory cache.
• void SessionFactory.getCache.evictAllRegions() : Clears all the data present in session factory cache.

Session session = sessionFactory.openSession();
CustomerEntity customer1 = (CustomerEntity)session.load(CustomerEntity.class, 5001);          //cache miss
System.out.println("Customer Name 1: " + customer1.getCustomerName());
sessionFactory.getCache().evictEntity(CustomerEntity.class, 5001);
//sessionFactory.getCache().evictAllRegions();
CustomerEntity customer2 = (CustomerEntity)session.load(CustomerEntity.class, 5001);          //cache hit
System.out.println("Customer Name 2: " + customer2.getCustomerName());