hibernate拦截器与事件

hibernate3.x使用的是事件机制；

getSession().createQuery(queryString).executeUpdate();和执行原生sql方式getSession().createSQLQuery(nativeQueryString).executeUpdate(); 不执行事件。

第 13 章 拦截器与事件(Interceptors and events)

应用程序能够响应Hibernate内部产生的特定事件是非常有用的。这样就允许实现某些通用的功能以及允许对Hibernate功能进行扩展。

13.1. 拦截器(Interceptors)

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

package org.hibernate.test;

import java.io.Serializable;
import java.util.Date;
import java.util.Iterator;

import org.hibernate.Interceptor;
import org.hibernate.type.Type;

public class AuditInterceptor implements Interceptor, Serializable {

    private int updates;
    private int creates;

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

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

        if ( entity instanceof Auditable ) {
            updates++;
            for ( int i=0; i < propertyNames.length; i++ ) {
                if ( "lastUpdateTimestamp".equals( propertyNames[i] ) ) {
                    currentState[i] = new Date();
                    return true;
                }
            }
        }
        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) {

        if ( entity instanceof Auditable ) {
            creates++;
            for ( int i=0; i<propertyNames.length; i++ ) {
                if ( "createTimestamp".equals( propertyNames[i] ) ) {
                    state[i] = new Date();
                    return true;
                }
            }
        }
        return false;
    }

    public void postFlush(Iterator entities) {
        System.out.println("Creations: " + creates + ", Updates: " + updates);
    }

    public void preFlush(Iterator entities) {
        updates=0;
        creates=0;
    }

    ...

}

创建会话(session)的时候可以指定拦截器。

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

你也可以使用Configuration来设置一个全局范围的拦截器。

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

13.2. 事件系统(Event system)

如果需要响应持久层的某些特殊事件，你也可以使用Hibernate3的事件框架。该事件系统可以用来替代拦截器，也可以作为拦截器的补充来使用。

基本上，Session接口的每个方法都有相对应的事件。比如LoadEvent，FlushEvent，等等（查阅XML配置文件的DTD，以及org.hibernate.event包来获得所有已定义的事件的列表）。当某个方法被调用时，HibernateSession会生成一个相对应的事件并激活所有配置好的事件监听器。系统预设的监听器实现的处理过程就是被监听的方法要做的（被监听的方法所做的其实仅仅是激活监听器， “实际”的工作是由监听器完成的）。不过，你可以自由地选择实现一个自己定制的监听器（比如，实现并注册用来处理处理LoadEvent的LoadEventListener接口）， 来负责处理所有的调用Session的load()方法的请求。

监听器应该被看作是单例(singleton)对象，也就是说，所有同类型的事件的处理共享同一个监听器实例，因此监听器不应该保存任何状态（也就是不应该使用成员变量）。

用户定制的监听器应该实现与所要处理的事件相对应的接口，或者从一个合适的基类继承（甚至是从Hibernate自带的默认事件监听器类继承， 为了方便你这样做，这些类都被声明成non-final的了）。用户定制的监听器可以通过编程使用Configuration对象 来注册，也可以在Hibernate的XML格式的配置文件中进行声明（不支持在Properties格式的配置文件声明监听器）。 下面是一个用户定制的加载事件(load event)的监听器：

public class MyLoadListener extends DefaultLoadEventListener {
    // this is the single method defined by the LoadEventListener interface
    public Object onLoad(LoadEvent event, LoadEventListener.LoadType loadType)
            throws HibernateException {
        if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {
            throw MySecurityException("Unauthorized access");
        }
        return super.onLoad(event, loadType);
    }
}

你还需要修改一处配置，来告诉Hibernate以使用选定的监听器来替代默认的监听器。

<hibernate-configuration>
    <session-factory>
        ...
        <listener type="load" class="MyLoadListener"/>
    </session-factory>
</hibernate-configuration>

看看用另一种方式，通过编程的方式来注册它。

Configuration cfg = new Configuration();
cfg.getSessionEventListenerConfig().setLoadEventListener( new MyLoadListener() );

通过在XML配置文件声明而注册的监听器不能共享实例。如果在多个<listener/>节点中使用了相同的类的名字，则每一个引用都将会产生一个独立的实例。如果你需要在多个监听器类型之间共享监听器的实例，则你必须使用编程的方式来进行注册。

为什么我们实现了特定监听器的接口，在注册的时候还要明确指出我们要注册哪个事件的监听器呢？ 这是因为一个类可能实现多个监听器的接口。在注册的时候明确指定要监听的事件，可以让启用或者禁用对某个事件的监听的配置工作简单些。

13.3. Hibernate的声明式安全机制

通常，Hibernate应用程序的声明式安全机制由会话外观层(session facade)所管理。 现在，Hibernate3允许某些特定的行为由JACC进行许可管理，由JAAS进行授权管理。 本功能是一个建立在事件框架之上的可选的功能。

首先，你必须要配置适当的事件监听器（event listener），来激活使用JAAS管理授权的功能。

<listener type="pre-delete" class="org.hibernate.secure.JACCPreDeleteEventListener"/>
<listener type="pre-update" class="org.hibernate.secure.JACCPreUpdateEventListener"/>
<listener type="pre-insert" class="org.hibernate.secure.JACCPreInsertEventListener"/>
<listener type="pre-load" class="org.hibernate.secure.JACCPreLoadEventListener"/>

接下来，仍然在hibernate.cfg.xml文件中，绑定角色的权限：

<grant role="admin" entity-name="User" actions="insert,update,read"/>
<grant role="su" entity-name="User" actions="*"/>

这些角色的名字就是你的JACC provider所定义的角色的名字。

by:http://oss.org.cn/ossdocs/framework/hibernate/reference-v3_zh-cn/events.html#objectstate-events

hibernate 配置文件：

<!-- Hibernate配置 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
				<!--<prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop> 
					<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop> -->
				<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
				<prop key="hibernate.cache.provider_configuration_file_resource_path">META-INF/ehcache.xml</prop>
			</props>
		</property>
		<!-- 设置事件监听 在org.hibernate.cfg.Configuration 类 setListeners 内可查看type，即下面key="post-delete" 值-->
		<property name="eventListeners">
			<map>
				<entry key="post-delete">
					<bean class="com.xx.framework.lucene.PostDeleteListener" />
				</entry>
				<entry key="post-insert">
					<bean class="com.xx.framework.lucene.PostInsertListener" />
				</entry>
			</map>
		</property>
		<!-- 添加拦截器 -->
		<property name="entityInterceptor" ref="myEmptyInterceptor">
		</property>
		<!-- Scan Packages的配置，如果配置为entity.* 则会扫描entity的所有子包内的映射实体，但是entity包内的类则不会映射!! -->
		<property name="packagesToScan" value="com.xx.application.entity" />
	</bean>
	<bean id="myEmptyInterceptor"
		class="com.xx.framework.lucene.MyEmptyInterceptor"></bean>

参考：

http://jeffreyhsu.iteye.com/blog/191696