Hibernate的回调与拦截

在Hibernate中，有两种方式可以捕获实体对象的GRUD操作并执行相应的处理

Hibernate回调(org.hibernate.classic.Lifecycle接口)：

//Provides callbacks from the Session to the persistent object.
//Persistent classes may implement this interface but they are not
//required to.
//If a CallbackException is thrown, the operation is vetoed and the
//exception is passed back to the application.
public interface Lifecycle {
	
	//If onSave(), onUpdate() or onDelete() return VETO,
	//the operation is silently vetoed.
	public static final boolean VETO = true;
	public static final boolean NO_VETO = false;

	//Called just before the object is saved
	public boolean onSave(Session s) throws CallbackException;

	//Called when an entity is passed to Session.update().
	//This method is not called every time the object's
	//state is persisted during a flush.
	public boolean onUpdate(Session s) throws CallbackException;

	//Called just before an object is deleted
	public boolean onDelete(Session s) throws CallbackException;

	//Called just after an object is loaded
	public void onLoad(Session s, Serializable id);
}

需要注意的地方：

1，如果onSave()、onUpdate()、onDelete()方法返回VOTE（true）或者在以上方法中抛出了CallbackException异常，操作将会停止而不会调用之后的Session.save()、Session.update()、Session.delete()方法

2，并不是每次调用Session.update()方法之前都会调用onUpdate()方法

3，调用Session.get()方法会直接返回实体对象，故在调用该方法后会立即调用onload()方法，而调用Session.load()方法返回的是实体对象的代理，故在调用该方法后不会立即调用onload()方法，对象在第一次使用时才会真正加载，而在对象真正加载完成之后才会调用onload()方法

4，不能直接使用方法中的Session对象，该方法是由当前Session负责调用，如果在这些方法中又调用当前Session进行持久化，将导致Session内部状态混乱

在onSave()方法中调用Session.save()方法将会导致死循环，但是在onSave()方法中执行Session.update()方法却没有报异常，不过通常方法只负责记录日志，数据合法性校验等简单工作，不会在这里再次调用Session对象完成数据持久化，故不需考虑太多

提到Lifecycle接口，通常也要提到Validatable接口（org.hibernate.classic.Validatable）：

//Implemented by persistent classes with invariants that must
//be checked before inserting into or updating the database.
public interface Validatable {
	
	//Validate the state of the object before persisting it.
	//If a violation occurs, throw a ValidationFailure.
	//This method must not change the state of the object by
	//side-effect.
	public void validate() throws ValidationFailure;
}

只有在对象插入和对象更新时才会调用validate()方法对对象数据合法性进行校验

public class User implements Serializable,Lifecycle,Validatable{
	private Integer id;
	private String name;
	private Integer age;
	private static final long serialVersionUID = 1L;
	
	public User(){}
	
	public Integer getId() {
		return id;
	}
	
	public void setId(Integer id) {
		this.id = id;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public Integer getAge() {
		return age;
	}
	
	public void setAge(Integer age) {
		this.age = age;
	}

	public boolean onSave(Session s) throws CallbackException {
		System.out.println("********on save********");
		System.out.println("id :" + id);
		System.out.println("name :" + name);
		System.out.println("age :" + age);
		return Lifecycle.NO_VETO;
	}

	@Override
	public boolean onUpdate(Session s) throws CallbackException {
		System.out.println("********on update********");
		System.out.println("id :" + id);
		System.out.println("name :" + name);
		System.out.println("age :" + age);
		return Lifecycle.VETO;
	}

	@Override
	public boolean onDelete(Session s) throws CallbackException {
		System.out.println("********on delete********");
		throw new CallbackException("Delete operation is not allowed!");
	}

	@Override
	public void onLoad(Session s, Serializable id) {
		System.out.println("********on load********");
		System.out.println("id :" + id);
	}

	@Override
	public void validate() throws ValidationFailure {
		System.out.println("~~~~~~~~valid~~~~~~~~");
		if(id < 0)
			throw new ValidationFailure("Illegal id!");
		if(name == null || name.equals(""))
			throw new ValidationFailure("Illegal name!");
		if(age < 0 || age > 150)
			throw new ValidationFailure("Illegal age!");
	}
}

由于这种方式对POJO带有侵入性，所以不建议使用

 

Hibernate拦截(org.hibernate.Interceptor接口)：

接口定义了非常多的方法，基本上通过命名就可以看出其功能，就不一一介绍了

不建议直接继承Interceptor接口，更好的方式是继承EmptyInterceptor类，并重写需要的方法，EmptyInterceptor接口如下：

public class EmptyInterceptor implements Interceptor, 
		Serializable {
	
	public static final Interceptor INSTANCE = 
		new EmptyInterceptor();
	
	protected EmptyInterceptor() {}

	public void onDelete(
			Object entity, 
			Serializable id, 
			Object[] state, 
			String[] propertyNames, 
			Type[] types) {}

	public boolean onFlushDirty(
			Object entity, 
			Serializable id, 
			Object[] currentState, 
			Object[] previousState, 
			String[] propertyNames, 
			Type[] types) {
		return false;
	}

	public boolean onLoad(
			Object entity, 
			Serializable id, 
			Object[] state, 
			String[] propertyNames, 
			Type[] types) {
		return false;
	}

	public boolean onSave(
			Object entity, 
			Serializable id, 
			Object[] state, 
			String[] propertyNames, 
			Type[] types) {
		return false;
	}

	public void postFlush(Iterator entities) {}
	
	public void preFlush(Iterator entities) {}

	public Boolean isTransient(Object entity) {
		return null;
	}

	public Object instantiate(String entityName, EntityMode entityMode, 
			Serializable id) {
		return null;
	}

	public int[] findDirty(Object entity,
			Serializable id,
			Object[] currentState,
			Object[] previousState,
			String[] propertyNames,
			Type[] types) {
		return null;
	}

	public String getEntityName(Object object) {
		return null;
	}

	public Object getEntity(String entityName, Serializable id) {
		return null;
	}

	public void afterTransactionBegin(Transaction tx) {}

        public void afterTransactionCompletion(Transaction tx) {}

	public void beforeTransactionCompletion(Transaction tx) {}

	public String onPrepareStatement(String sql) {
		return sql;
	}

	public void onCollectionRemove(Object collection, Serializable key) 
			throws CallbackException {}

	public void onCollectionRecreate(Object collection, Serializable key) 
			throws CallbackException {}

	public void onCollectionUpdate(Object collection, Serializable key) 
			throws CallbackException {}	
}

示例如下：

public class LogInterceptor extends EmptyInterceptor {

	private static final long serialVersionUID = 1L;

	@Override
	public boolean onLoad(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {
		System.out.println(entity.getClass().getName() + " loaded.");
		return false;
	}
}

值得注意的是可以配置2种范围的拦截器

SessionFactory范围的拦截器：

由于多个Session可能并发的使用SessionFactoruy范围的拦截器，故该拦截器必须是线程安全的

LogInterceptor li = new LogInterceptor();
Configuration conf = new Configuration().setInterceptor(li);  
SessionFactory sessionFactory = conf.configure().buildSessionFactory();
        
Session sess = sessionFactory.openSession();

Session范围的拦截器：

LogInterceptor li = new LogInterceptor();
Configuration conf = new Configuration();  
SessionFactory sessionFactory = conf.configure().buildSessionFactory();
        
Session sess = sessionFactory.openSession(li);