12-Hibernate3.6.2 事件机制

         Hibernate执行持久化过程中，应用程序无法参与其中。所有的数据持久化操作，对用户都是透明的。通过事件框架，Hibernate允许应用程能响应特定的内部事件，从而允许实现某些通用的功能或者对Hibernate功能进行扩展。

Hibernate的事件机制框架由两个部分组成：

       1、拦截器机制：对于特定动作拦截，回调应用中的特定动作

       2、事件系统：重写Hibernate的事件监听器。

 

一、拦截器

Interceptor接口提供了从会话回调应用程序的机制，这种回调机制可以允许应用程序在持久化对象被保存、更新、删除或是加载之前，检查并（或）修改其属性。

通过Interceptor接口，可以在数据进入数据库之前，对数据进行最后的检查，如果数据不符合要求，可以修改数据，从而避免非法数据进入数据库。

使用拦截器按如下两个步骤进行：

1、定义实现Interceptor接口的拦截器

2、通过Session启用拦截器，或者通过Configuration启用全局拦截器

程序可以通过实现Interceptor接口来创建拦截器，也可以通过继承EmptyInterceptor来实现拦截器。

public class MyIterceptor extends EmptyInterceptor {
	// 记录修改次数
	private int updates;
	// 记录创建次数
	private int creates;

	// 当删除实体时，onDelete方法将被调用
	public void onDelete(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {
		// do nothing
	}

	// 当把持久化实体的状态同步到数据库时，onFlushDirty方法被调用
	public boolean onFlushDirty(Object entity, Serializable id,
			Object[] currentState, Object[] previousState,
			String[] propertyNames, Type[] types) {
		// 每同步一次，修改的累加器加1
		updates++;
		for (int i = 0; i < propertyNames.length; i++) {
			if ("lastUpdateTimestamp".equals(propertyNames[i])) {
				currentState[i] = new Date();
				return true;
			}
		}
		return false;
	}

	// 当加载持久化实体时，onLoad方法被调用
	public boolean onLoad(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {
		for (int i = 0; i < propertyNames.length; i++) {
			if ("name".equals(propertyNames[i])) {
				// 输出被装载实体的name属性值
				System.out.println(state[i]);
				return true;
			}
		}
		return false;
	}

	// 保存持久化实例时候，调用该方法
	public boolean onSave(Object entity, Serializable id, Object[] state,
			String[] propertyNames, Type[] types) {
		creates++;
		for (int i = 0; i < propertyNames.length; i++) {
			if ("createTimestamp".equals(propertyNames[i])) {
				state[i] = new Date();
				return true;
			}
		}
		return false;
	}

	// 持久化所做修改同步完成后，调用postFlush方法
	public void postFlush(Iterator entities) {
		System.out.println("创建的次数： " + creates + ", 更新的次数： " + updates);
	}

	// 在同步持久化所做修改之前，调用preFlush方法
	public void preFlush(Iterator entities) {
	}

	// 事务提交之前触发该方法
	public void beforeTransactionCompletion(Transaction tx) {
		System.out.println("事务即将结束");
	}

	// 事务提交之后触发该方法
	public void afterTransactionCompletion(Transaction tx) {
		System.out.println("事务已经结束");
	}
}

上面拦截器没有进行实际的操作，只是打印了一些标识代码。

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

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

Session session = sf.openSession( new MyInterceptor() );

SessionFactory范围内的拦截器要通过Configuration中注册，而这必须在创建SessionFactory之前。在这种情况下，给出的拦截器会被这个SessionFactory所打开的所有session使用了

new Configuration().setInterceptor( new MyInterceptor() );

 

	Configuration cfg = new Configuration().configure().setInterceptor(new MyIterceptor()); 
		SessionFactory sf = cfg.buildSessionFactory(); 
		Session session = sf.openSession(); 
		Transaction tx = session.beginTransaction(); 

		for (int i = 0; i < 2; i++) {
			Category c = new Category();
			c.setName("c" + i);
			session.save(c);
		}

		tx.commit(); 
		session.close();

 

   insert 
    into
        Category
        (name) 
    values
        (?)
Hibernate: 
    insert 
    into
        Category
        (name) 
    values
        (?)
创建的次数： 2, 更新的次数： 0
事务即将结束
事务已经结束

 

二、事件机制

如果需要响应持久层的某些特殊事件，可以使用Hibernate3的事件框架。该事件系统可以用来替代拦截器，也可以作为拦截器的补充来使用。Session接口的每个方法都有相对应的事件。比如 LoadEvent，FlushEvent，等等。当某个方法被调用时，Hibernate Session会生成一个相对应的事件并激活所有配置好的事件监听器。

系统默认监听器实现的处理过程，完成了所有的数据持久化操作，包括插入、修改等操作。如果用户自己定义了自己的监听器，则意味着用户必须完成对象的持久化操作。

监听器是单例模式对象，即所有同类型的事件处理共享同一个监听器实例，因此监听器不应该保存任何状态，即不应该使用成员变量。

 

使用事件系统按如下步骤：

1、实现自己的事件监听器

2、注册自定义事件监听器，代替系统默认的事件监听器

 

实现用户的自定义监听器有如下三种方法：

1、实现对应的监听器接口。实现接口必须实现接口内的所有方法，关键是必须事件Hibernate对应的持久化操作，即数据库访问，这意味着程序员完全取代了Hibernate的底层操作。

2、继承事件适配器。可以选择性地实现需要关注的方法，但依然试图取代Hibernate完成数据库的访问。

3、继承系统默认的事件监听器。扩展特定方法。

 

下面是自定义监听器实例：

import org.hibernate.HibernateException;
import org.hibernate.event.LoadEvent;
import org.hibernate.event.LoadEventListener;
import org.hibernate.event.def.DefaultLoadEventListener;

public class MyLoadListener extends DefaultLoadEventListener {
	// 在LoadEventListener接口仅仅定义了这个方法
	public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)
			throws HibernateException {
		System.out.println("自定义的load事件");
		System.out.println(event.getEntityClassName() + "------"
				+ event.getEntityId());
		super.onLoad(event, loadType);
	}
}

 

public class MySaveListener extends DefaultSaveEventListener {
	protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event) {
		System.out.println("自定义的save事件");
		System.out.println(event.getObject());
		return super.performSaveOrUpdate(event);
	}
}

注意：扩展用户自定义监听器时，别忘了在方法中调用父类的对应的方法，否则Hibernate3默认的持久化行为都会失效。

注册用户自定义监听器有两种方法：

1、编程式。通过使用Configuration对象来编程实现注册。

public void newsListenerTest() {
		Configuration conf = new Configuration().configure();
		// 为load事件设置监听器
		conf.setListener("load", "com.iflytek.filter.MyLoadListener");
		conf.setListener("save", "com.iflytek.filter.MySaveListener");
		SessionFactory sfg = conf.buildSessionFactory();
		Session session = sfg.openSession();
		Transaction tx = session.beginTransaction();

		Category category= new Category();
		category.setId(1);
		category.setName("1111");
		session.save(category); // 调用save方法，触动save监听器
		tx.commit();

		session.load(Category.class, 1); // 调用load方法，触动load监听器
		session.close();
	}

 

2、声明式。在hibernate.cfg.xml配置文件中进行声明。

注册事件监听器使用<listener.../>元素。该元素可以接受两个参数。

type:指定该事件监听器所监听的事件类型，class:指定事件监听器的实现类

<listener class="com.iflytek.listener.MyLoadListener" type="load"/> 
<listener class="com.iflytek.listener.MySaveListener" type="save"/>

 

如果需要为指定事件配置多个事件监听器，则需要使用<event.../>元素。在<event.../>元素里可以使用多个<listener.../>子元素来指定多个事件监听器。

<event type="save"> 
	<listener class="com.iflytek.listener.MySaveListener"/> 
	<listener class="com.iflytek.listener.MyLoadListener"/> 
</event>