应用程序能够响应Hibernate内部产生的特定事件是非常有用的。这样就允许实现某些通用的功能以及允许对Hibernate功能进行扩展
持久层框架底层的拦截器机制是对诸如Spring等业务管理容器拦截机制的有益补充，使得我们可以在更低层次、更广的对象范围上进行AOP操作（Spring虽然将Hibernate纳入到了其容器管理的范围内，但是并没有途径实现对其实体对象的管理）。这样就允许实现某些通用的功能，以及允许对Hibernate功能进行扩展。
1、拦截器（Interceptors）
Interceptor接口提供了从会话（session）回调（callback）应用程序（application）的机制，这种回调机制可以允许应用程序在持久化对象被保存、更新、删除或是加载之前，检查并（或）修改其属性。
你可以直接实现Interceptor接口，也可以（最好）继承自EmptyInterceptor。
拦截器可以有两种：
- session范围内的
- sessionFactory范围内的
使用拦截器时按如下步骤：
（1）定义实现Interceptor接口的拦截器类
（2）通过session启用拦截器，或者通过Configuration启用全局拦截器
当使用某个重载的SessionFactory.openSession()使用Interceptorzuowei参数调用打开一个session的时候，就指定了Session范围内的拦截器。
Session session = factory.openSession（new AuditInterceptor（））；
SessionFactory范围内的拦截器要通过Configuration中注册，而这必须在创建SessionFactory之前。在这种情况下，给出的拦截器会被这个SessionFactory所打开的所有session使用了，除非session打开时明确指明了使用的拦截器。SessionFactory范围内的拦截器，必须是线程安全的，因为多个session可能并发使用这个拦截器，要因此小心不要保存与session相关的状态。具体配置
new Configuration（）.setInterceptor（new AuditInterceptor（））；
2、事件系统（Event system）
- 如果需要响应持久层的某些特殊事件，你也可以使用Hibernate3的事件框架。该事件系统可以用来替代拦截器，也可以作为拦截器的补充来使用。
-基本上，session接口的每个方法都有相对应的事件。比如LoadEvent，FlushEvent，等等（可以查阅XML配置文件的DTD以及org.hibernate.event包来获得所有已定义的事件的列表）。
- 当某个方法被调用时，hibernate Session会生成一个相应的事件并激活所有配置好的事件监听器（观察者模式）。被监听的方法所做的其实仅仅是激活监听器，”实际“的工作是由监听器完成的。你可以自由的选择实现一个自己定制的监听器：比如，实现并注册用来处理处理LoadEvent的LoadeventListener接口，来处理所有的调用Session的load（）方法的请求。
- 监听器在运行时被实例化为单例（singleton）对象，也就是说，所有同类型的事件的处理共享同一个监听器实例，因此监听器不应该保存任何与请求相关的状态。
- 用户定制的监听器需要实现相关的事件监听器接口，或者从一个适合的基类继承（甚至是从Hibernate自带的默认事件监听器类继承。
- 用户定制的监听器可以通过编程使用Configuration对象来注册，也可以在Hibernate的XML格式的配置文件中进行声明。
- 你还需要修改一处配置，来告诉Hibernate，除了默认监听器，还要附加选定的监听器。
<session-factory> <event type="laod"> <listener class="com.cdtax.MyLoadListener"/> <listener class="org.hibernate.event.def.DefaultLoadEventListener"/> </event>
通过编程的方式注册
Configuration cfg = new Configuration();
LoadEventListener[] stack = {new MyLoadListener(),new DefaultLoadEventListener()};
cfg.getEventListeners().setLoadEventListeners(stack);
- 通过在XML配置文件声明而注册的监听器不能共享实例，如果在多个<lsitener/>节点中使用了相同的类的名字，而每一个引用都会产生一个独立的实例，如果你需要在多个监听器类型之间共享监听器的实例，则你必须使用编程的方式来进行注册。
3、关于配置文件中id标签的generator
有UUID，foreign等
4、拦截器举例：
import java.sql.Date;
import java.sql.Timestamp;
public class People
{
private Long id;
private String username;
private String password;
private int telphone;
private char gender; //'M','F'
private boolean graduation;
private Date birthday;
private Timestamp marryTime;
private byte[] file;
public Long getId()
{
return id;
}
public void setId(Long id)
{
this.id = id;
}
public String getUsername()
{
return username;
}
public void setUsername(String username)
{
this.username = username;
}
public String getPassword()
{
return password;
}
public void setPassword(String password)
{
this.password = password;
}
public int getTelphone()
{
return telphone;
}
public void setTelphone(int telphone)
{
this.telphone = telphone;
}
public char getGender()
{
return gender;
}
public void setGender(char gender)
{
this.gender = gender;
}
public boolean isGraduation()
{
return graduation;
}
public void setGraduation(boolean graduation)
{
this.graduation = graduation;
}
public Date getBirthday()
{
return birthday;
}
public void setBirthday(Date birthday)
{
this.birthday = birthday;
}
public Timestamp getMarryTime()
{
return marryTime;
}
public void setMarryTime(Timestamp marryTime)
{
this.marryTime = marryTime;
}
public byte[] getFile()
{
return file;
}
public void setFile(byte[] file)
{
this.file = file;
}
}
映射文件：
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.cdtax.hibernate.People" table="people"> <id name="id" column="id" type="long"> <generator class="increment"></generator> </id> <property name="username" column="username" type="string"></property> <property name="password" column="password" type="string"></property> <property name="telphone" column="telphone" type="int"></property> <property name="gender" column="gender" type="character"></property> <property name="graduation" column="graduation" type="boolean"></property> <property name="birthday" column="birthday" type="date"></property> <property name="marryTime" column="marryTime" type="timestamp"></property> <property name="file" column="file" type="binary"></property> </class> </hibernate-mapping>
创建数据库表
create table people (id bigint not null, username varchar(255), password varchar(255), telphone integer, gender char(1), graduation bit, birthday date, marryTime datetime, file tinyblob, primary key (id))
创建拦截器：
import java.io.Serializable;
import java.util.Iterator;
import org.hibernate.EmptyInterceptor;
import org.hibernate.Transaction;
import org.hibernate.type.Type;
public class TestInterceptor extends EmptyInterceptor
{
@Override
public boolean onLoad(Object entity, Serializable id, Object[] state,
String[] propertyNames, Type[] types)
{
System.out.println("onLoad invoked!");
for(String propertyName : propertyNames)
{
System.out.println(propertyName);
}
return true;
}
@Override
public boolean onSave(Object entity, Serializable id, Object[] state,
String[] propertyNames, Type[] types)
{
System.out.println("onsave invoked!");
for(String propertyName : propertyNames)
{
System.out.println(propertyName);
}
return true;
}
@Override
public void onDelete(Object entity, Serializable id, Object[] state,
String[] propertyNames, Type[] types)
{
System.out.println("onDelete invoked!");
for(String propertyName : propertyNames)
{
System.out.println(propertyName);
}
}
@Override
public boolean onFlushDirty(Object entity, Serializable id,
Object[] currentState, Object[] previousState,
String[] propertyNames, Type[] types)
{
System.out.println("onFlushDirty invoked!");
for(String propertyName : propertyNames)
{
System.out.println(propertyName);
}
return true;
}
@Override
public void postFlush(Iterator entities)
{
System.out.println("postflush invkked!");
}
@Override
public void beforeTransactionCompletion(Transaction tx)
{
System.out.println("beforeTanscationCompletion invoked!");
}
@Override
public void afterTransactionBegin(Transaction tx)
{
System.out.println("afterTransactionBegin invoked");
}
}
我们的拦截器直接继承自Hibernate的EmptyInterceptor，然后我们覆盖其提供的方法即可。
方法中的参数Object entity就是我们要操作的对象，如这里就是People对象。propertyNames是操作对象的属性名的数组。onLoad方法就是在加载对象的时候执行方法，onSave方法就是在保存对象的时候执行。关于flush，清空缓存，当对象为脏数据时，或者事务提交的时候。
测试：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.Timestamp;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import com.cdtax.interceptor.TestInterceptor;
public class HibernateTest
{
private static SessionFactory sessionFactory;
static
{
try
{
sessionFactory = new Configuration().configure().buildSessionFactory();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
public static void main(String[] args) throws Exception
{
People people = new People();
people.setUsername("zhangsan1");
people.setPassword("223456");
people.setGender('M');
people.setBirthday(new java.sql.Date(new java.util.Date().getTime()));
people.setGraduation(true);
people.setTelphone(1234);
people.setMarryTime(new Timestamp(new java.util.Date().getTime()));
InputStream is = new FileInputStream("c:/RHDSetup.log");
int length = is.available();
byte[] buffer = new byte[length];
is.read(buffer);
people.setFile(buffer);
Session session = sessionFactory.openSession(new TestInterceptor());
Transaction tx = null;
try
{
tx = session.beginTransaction();
session.save(people);
tx.commit();
}
catch(Exception ex)
{
if(null != tx)
{
tx.rollback();
}
}
finally
{
session.close();
}
}
}
这是session范围的拦截器，执行的结果
Hibernate: select max(id) from people
onsave invoked!
username
password
telphone
gender
graduation
birthday
marryTime
file
Hibernate: insert into people (username, password, telphone, gender, graduation, birthday, marryTime, file, id) values (?, ?, ?, ?, ?, ?, ?, ?, ?)
postflush invkked!
beforeTanscationCompletion invoked!
afterTransactionBegin invoked
红色部分是session.save(people);这一句产生的，可以看到在save时，先执行拦截器onSave方法，然后执行insert语句执行数据库插入。然后在事务提交后，执行postFlush方法，在事务结束前后分别在调用beforeTransactionCompletion和afterTransactionCompletion
然后进行查询加载测试：
try
{
tx = session.beginTransaction();
People p = (People)session.get(People.class, new Long(1));
System.out.println(p.getUsername());
tx.commit();
}
Hibernate: select people0_.id as id0_0_, people0_.username as username0_0_, people0_.password as password0_0_, people0_.telphone as telphone0_0_, people0_.gender as gender0_0_, people0_.graduation as graduation0_0_, people0_.birthday as birthday0_0_, people0_.marryTime
as marryTime0_0_, people0_.file as file0_0_ from people people0_ where people0_.id=?
onLoad invoked!
username
password
telphone
gender
graduation
birthday
marryTime
file
zhangsan1
postflush invkked!
beforeTanscationCompletion invoked!
afterTransactionBegin invoked
这次调用了拦截器的onLoad方法。
5、事件（监听器）
拦截器能够实现的功能，事件（监听器同样能够完成），编写两个两个监听器：
import java.io.Serializable;
import org.hibernate.event.SaveOrUpdateEvent;
import org.hibernate.event.def.DefaultSaveEventListener;
public class TestSaveListener extends DefaultSaveEventListener
{
@Override
protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event)
{
System.out.println("performSaveOrUpdate invoked!!!!");
return super.performSaveOrUpdate(event);//必须显式的调用一下父类的方法，否则Hibernate的相关机制都被覆盖掉了
}
}
import org.hibernate.HibernateException;
import org.hibernate.event.LoadEvent;
import org.hibernate.event.def.DefaultLoadEventListener;
public class TestLoadListener extends DefaultLoadEventListener
{
@Override
public void onLoad(LoadEvent arg0, LoadType arg1) throws HibernateException
{
super.onLoad(arg0, arg1); //必须显式的调用一下父类的方法，否则Hibernate的相关机制都被覆盖掉了
System.out.println("onLoad invoked!!!");
System.out.println(arg0.getEntityId() + "," + arg0.getEntityClassName());
}
}
这里需要注意，在重写方法时，一定要显式的调用一下父类的方法，否则Hibernate的相关机制就被你覆盖了，Hibernate就不起作用了。
编写完监听器需要部署到配置文件中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">
<!-- Generated by MyEclipse Hibernate Tools. -->
<hibernate-configuration>
<session-factory>
<property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
<property name="show_sql">true</property>
<mapping resource="People.hbm.xml" />
<event type="load">
<listener class="com.cdtax.event.TestLoadListener"/>
</event>
<event type="save">
<listener class="com.cdtax.event.TestSaveListener"/>
</event>
</session-factory>
</hibernate-configuration>
执行上面的保存测试程序，结果：
performSaveOrUpdate invoked!!!!
Hibernate: select max(id) from people
onsave invoked!
username
password
telphone
gender
graduation
birthday
marryTime
file
Hibernate: insert into people (username, password, telphone, gender, graduation, birthday, marryTime, file, id) values (?, ?, ?, ?, ?, ?, ?, ?, ?)
postflush invkked!
beforeTanscationCompletion invoked!
afterTransactionBegin invoked
可以看到执行了事件监听器方法，同时也执行了拦截器方法。
执行上面查询加载的测试，执行结果：
Hibernate: select people0_.id as id0_0_, people0_.username as username0_0_, people0_.password as password0_0_, people0_.telphone as telphone0_0_, people0_.gender as gender0_0_, people0_.graduation as graduation0_0_, people0_.birthday as birthday0_0_, people0_.marryTime
as marryTime0_0_, people0_.file as file0_0_ from people people0_ where people0_.id=?
onLoad invoked!
username
password
telphone
gender
graduation
birthday
marryTime
file
onLoad invoked!!!
1,com.cdtax.hibernate.People
zhangsan1
postflush invkked!
beforeTanscationCompletion invoked!
afterTransactionBegin invoked
拦截器与事件监听器的区别：
事件的监听器还有另一种配制方法：
在hibernate.cfg.xml中直接配置<listener>标签：
<listener class="com.cdtax.event.TestSaveListener" type="save"/>