Tutorial: Hibernate interceptor example

Tools and Technologies we are using here:

JDK 7
Hibernate 4.3.7
MySql 5.1.10
Eclipse Juno 4.2
Maven 3.2

Main Objects of this project are:

pom.xml
hibernate.cfg.xml
annotated pojo
database

Overview of the Project Structure:

Create Database Script:

CREATE DATABASE `hibernate_tutorial` ;

USE `hibernate_tutorial`;

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `user_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `email_id` varchar(255) DEFAULT NULL,
  `first_name` varchar(255) DEFAULT NULL,
  `user_name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

/*Table structure for table `user_activity_tracker` */

DROP TABLE IF EXISTS `user_activity_tracker`;

CREATE TABLE `user_activity_tracker` (
  `activity_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `activity` varchar(255) DEFAULT NULL,
  `created_at` datetime DEFAULT NULL,
  PRIMARY KEY (`activity_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

Create hibernate.cfg.xml

<?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>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate_tutorial</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
         
        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
 
        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <mapping class="com.javamakeuse.poc.pojo.User"/>
        <mapping class="com.javamakeuse.poc.pojo.UserActivityTracker"/>
          
    </session-factory>
</hibernate-configuration>

Create User.java

package com.javamakeuse.poc.pojo;

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

@Entity
@Table(name = "user")
public class User {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 @Column(name = "user_id")
 private long userId;

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

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

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

 public long getUserId() {
  return userId;
 }

 public void setUserId(long userId) {
  this.userId = userId;
 }

 public String getUserName() {
  return userName;
 }

 public void setUserName(String userName) {
  this.userName = userName;
 }

 public String getFirstName() {
  return firstName;
 }

 public void setFirstName(String firstName) {
  this.firstName = firstName;
 }

 public String getEmailId() {
  return emailId;
 }

 public void setEmailId(String emailId) {
  this.emailId = emailId;
 }

}

Create UserActivityTracker.java

package com.javamakeuse.poc.pojo;

import java.util.Date;

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

@Entity
@Table(name = "user_activity_tracker")
public class UserActivityTracker {

 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 @Column(name = "activity_id")
 private long activityId;

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

 @Column(name = "created_at")
 private Date createdAt;

 public UserActivityTracker(String activity, Date createdAt) {
  super();
  this.activity = activity;
  this.createdAt = createdAt;
 }

}

Create HibernateUtility.java Here we are configuring interceptor.

package com.javamakeuse.poc.util;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateUtility {
 private static final SessionFactory sessionFactory = buildSessionFactory();

 private static SessionFactory buildSessionFactory() {
  Configuration configuration = new Configuration()
    .setInterceptor(new ActivityTrackerInterceptor());
  configuration.configure();

  ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
    .applySettings(configuration.getProperties()).build();
  SessionFactory sessionFactory = configuration
    .buildSessionFactory(serviceRegistry);

  return sessionFactory;
 }

 public static SessionFactory getSessionFactory() {
  return sessionFactory;
 }

}

Create ActivityTrackerInterceptor class by extending EmptyInterceptor

package com.javamakeuse.poc.util;

import java.io.Serializable;
import java.util.Calendar;
import java.util.Iterator;

import org.hibernate.EmptyInterceptor;
import org.hibernate.Session;
import org.hibernate.type.Type;

import com.javamakeuse.poc.pojo.User;
import com.javamakeuse.poc.pojo.UserActivityTracker;

public class ActivityTrackerInterceptor extends EmptyInterceptor {

 private static final long serialVersionUID = 1L;
 private String operation = "INSERT";
 boolean isMainEntity = false;

 // called when record deleted.
 public void onDelete(Object entity, Serializable id, Object[] state,
   String[] propertyNames, Type[] types) {
  operation = "DELETE";
  isMainEntity = true;
  System.out.println("Delete function called");
 }

 // called when record updated
 public boolean onFlushDirty(Object entity, Serializable id,
   Object[] currentState, Object[] previousState,
   String[] propertyNames, Type[] types) {
  if (entity instanceof User) {
   System.out.println("Update function called");
   operation = "UPDATE";
   isMainEntity = true;
   return true;
  }
  isMainEntity = false;
  return false;
 }

 // called on load events
 public boolean onLoad(Object entity, Serializable id, Object[] state,
   String[] propertyNames, Type[] types) {

  // log loading events
  System.out.println("load function called");
  return true;
 }

 public boolean onSave(Object entity, Serializable id, Object[] state,
   String[] propertyNames, Type[] types) {
  if (entity instanceof User) {
   System.out.println("save function called");
   operation = "INSERT";
   isMainEntity = true;
   return true;
  }
  isMainEntity = false;
  return false;
 }

 // called before commit into database
 public void preFlush(Iterator iterator) {
  System.out.println("Before commiting");
 }

 // called after committed into database
 public void postFlush(Iterator iterator) {
  System.out.println("After commiting");
  if (isMainEntity) {
   Session session = HibernateUtility.getSessionFactory()
     .openSession();
   session.getTransaction().begin();
   UserActivityTracker activityTracker = new UserActivityTracker(
     operation, Calendar.getInstance().getTime());
   session.save(activityTracker);
   session.getTransaction().commit();
  }
  isMainEntity = false;
 }

}

Note: Here we have creating new row in UserActivityTracker table in postFlush() method.

Create Main.java

package com.javamakeuse.poc.dao;

import org.hibernate.Session;

import com.javamakeuse.poc.pojo.User;
import com.javamakeuse.poc.util.HibernateUtility;

public class Main {
 public static void main(String[] args) {
  Session session = HibernateUtility.getSessionFactory().openSession();

  session.beginTransaction();
  User user = new User();

  user.setEmailId("info@javamakeuse.com");
  user.setFirstName("javamakeuse");
  long insertedID = (Long) session.save(user);
  session.getTransaction().commit();

  session.beginTransaction();
  // fetching user
  User user2 = (User) session.load(User.class, insertedID);
  user2.setUserName("javamakeuse");
  session.update(user);

  session.getTransaction().commit();

 }
}

Run Main.java, It will create two records inside user_activity_tracker table one for INSERT and for UPDATE operation.

OUTPUT:

Hibernate: 
    insert 
    into
        user
        (email_id, first_name, user_name) 
    values
        (?, ?, ?)
Before commiting
After commiting
Hibernate: 
    insert 
    into
        user_activity_tracker
        (activity, created_at) 
    values
        (?, ?)
Before commiting
After commiting
Before commiting
Update function called
Hibernate: 
    update
        user 
    set
        email_id=?,
        first_name=?,
        user_name=? 
    where
        user_id=?
After commiting
Hibernate: 
    insert 
    into
        user_activity_tracker
        (activity, created_at) 
    values
        (?, ?)
Before commiting
After commiting

Record inserted in user table.

Record inserted in user_activity_tracker table.

Download the complete example from here Source Code

References
Reference 1
Reference 2

Tutorial: Hibernate interceptor example

Tools and Technologies we are using here:

Download the complete example from here Source Code

1 comments: