12.1. 拦截器(Interceptors)

Interceptor接口提供了从会话(session)回调(callback)应用程序(application)的机制， 这种回调机制可以允许应用程序在持久化对象被保存、更新、删除或是加载之前，检查并（或）修改其 属性。一个可能的用途，就是用来跟踪审核(auditing)信息。例如：下面的这个拦截器，会在一个实现了 Auditable接口的对象被创建时自动地设置createTimestamp属性，并在实现了 Auditable接口的对象被更新时，同步更新lastUpdateTimestamp属性。

你可以直接实现Interceptor接口，也可以（最好）继承自EmptyInterceptor。

  1. package org.hibernate.test;
  3. import java.io.Serializable;
  4. import java.util.Date;
  5. import java.util.Iterator;
  7. import org.hibernate.EmptyInterceptor;
  8. import org.hibernate.Transaction;
  9. import org.hibernate.type.Type;
  11. public class AuditInterceptor extends EmptyInterceptor {
  13.     private int updates;
  14.     private int creates;
  15.     private int loads;
  17.     public void onDelete(Object entity,
  18.                          Serializable id,
  19.                          Object[] state,
  20.                          String[] propertyNames,
  21.                          Type[] types) {
  22.         // do nothing
  23.     }
  25.     public boolean onFlushDirty(Object entity,
  26.                                 Serializable id,
  27.                                 Object[] currentState,
  28.                                 Object[] previousState,
  29.                                 String[] propertyNames,
  30.                                 Type[] types) {
  32.         if ( entity instanceof Auditable ) {
  33.             updates++;
  34.             for ( int i=0; i < propertyNames.length; i++ ) {
  35.                 if ( "lastUpdateTimestamp".equals( propertyNames[i] ) ) {
  36.                     currentState[i] = new Date();
  37.                     return true;
  38.                 }
  39.             }
  40.         }
  41.         return false;
  42.     }
  44.     public boolean onLoad(Object entity,
  45.                           Serializable id,
  46.                           Object[] state,
  47.                           String[] propertyNames,
  48.                           Type[] types) {
  49.         if ( entity instanceof Auditable ) {
  50.             loads++;
  51.         }
  52.         return false;
  53.     }
  55.     public boolean onSave(Object entity,
  56.                           Serializable id,
  57.                           Object[] state,
  58.                           String[] propertyNames,
  59.                           Type[] types) {
  61.         if ( entity instanceof Auditable ) {
  62.             creates++;
  63.             for ( int i=0; i<propertyNames.length; i++ ) {
  64.                 if ( "createTimestamp".equals( propertyNames[i] ) ) {
  65.                     state[i] = new Date();
  66.                     return true;
  67.                 }
  68.             }
  69.         }
  70.         return false;
  71.     }
  73.     public void afterTransactionCompletion(Transaction tx) {
  74.         if ( tx.wasCommitted() ) {
  75.             System.out.println("Creations: " + creates + ", Updates: " + updates, "Loads: " + loads);
  76.         }
  77.         updates=0;
  78.         creates=0;
  79.         loads=0;
  80.     }
  82. }

拦截器可以有两种:Session范围内的，和SessionFactory范围内的。

当使用某个重载的SessionFactory.openSession()使用Interceptor作为参数调用打开一个session的时候，就指定了Session范围内的拦截器。

  1. Session session = sf.openSession( new AuditInterceptor() );

SessionFactory范围内的拦截器要通过Configuration中注册，而这必须在创建SessionFactory之前。在这种情况下，给出的拦截器会被这个SessionFactory所打开的所有session使用了；除非session打开时明确指明了使用的拦截器。SessionFactory范围内的拦截器，必须是线程安全的，因为多个session可能并发使用这个拦截器，要因此小心不要保存与session相关的状态。

  1. new Configuration().setInterceptor( new AuditInterceptor() );