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);
