hibernate 拦截hibernate事件

拦截hibernate事件：
例子实现审计日志：
1、创建标记接口
用这个接口给所有应该子被自动审计的持久化类做上标记：

/**
*
 例子实现审计日志：
*
 1、创建标记接口
*
 用这个接口给所有应该子被自动审计的持久化类做上标记
*
 @author partner4java
*
*/
publicinterfaceAuditable
 {
publicLong
 getId();
}

2、创建和映射日志记录
创建新的持久化类AuditLogRecord。这个类标识你想要的审计数据库表中记入日志信息:

/**
*
 2、创建和映射日志记录
*
 创建新的持久化类AuditLogRecord。这个类标识你想要的审计数据库表中记入日志信息
*
 @author partner4java
*
*/
publicclassAuditLogRecordimplementsSerializable
 {
privateLong
 auditLogId;
privateString
 message;
privateLong
 entityId;
privateClass
 entityClass;
privateLong
 userId;
privateDate
 created;

<classname="AuditLogRecord"table="Audit_Log_Record"mutable="false">
<id
 name="auditLogId"column="audit_Log_Id"type="long">
<generatorclass="native"/>
</id>

<property
 name="message"length="200"></property>
<property
 name="entityId"column="entity_Id"type="long"not-null="true"></property>
<property
 name="entityClass"column="entity_Class"type="class"not-null="true"></property>
<property
 name="userId"column="user_Id"type="long"></property>
<property
 name="created"type="java.util.Date"not-null="true"update="false"></property>
</class>

3、编写拦截器
当调用save时(),应该自动调用logEvent()方法。利用hibernate完成实现Interceptor接口。

/**
*
 3、编写拦截器
*
 当调用save时(),应该自动调用logEvent()方法。利用hibernate完成实现Interceptor接口。
*
 @author partner4java
*
*/
publicclassAuditLogInterceptorextendsEmptyInterceptor
 {
privateSession
 session;
privateLong
 userId;

privateSet
 inserts =newHashSet();
privateSet
 updates =newHashSet();


publicvoidsetSession(Session
 session) {
this.session
 = session;
}

publicvoidsetUserId(Long
 userId) {
this.userId
 = userId;
}

/**
 * 每当hibernate侦测到脏对象时，就调用
 * Called when an object is detected to be dirty, during a flush. The interceptor may modify the detected currentState, which will be propagated to both the database and the persistent object. Note that not all flushes end in actual synchronization with the
 database, in which case the new currentState will be propagated to the object, but not necessarily (immediately) to the database. It is strongly recommended that the interceptor not modify the previousState.
 */
publicbooleanonFlushDirty(Object
 entity, Serializable id,
Object[]
 currentState, Object[] previousState,
String[]
 propertyNames, Type[] types) {
if(entityinstanceofAuditable){
inserts.add(entity);
}

returnfalse;
}

/**
 * 保存实体时
 * Called before an object is saved. The interceptor may modify the state, which will be used for the SQL INSERT and propagated to the persistent object.
 */
publicbooleanonSave(Object
 entity, Serializable id, Object[] state,
String[]
 propertyNames, Type[] types) {
if(entityinstanceofAuditable){
updates.add(entity);
}

returnfalse;
}

/**
 * hibernate在执行了把持久化上下文实现为与数据库同步的SQL之后调用他
 * Called after a flush that actually ends in execution of the SQL statements required to synchronize in-memory state with the database
 */
publicvoidpostFlush(Iterator
 entities)throwsCallbackException{
try{
for(Iterator
 it = inserts.iterator();it.hasNext();){
Auditable
 auditable = (Auditable) it.next();
AuditLog.logEvent("create",auditable,userId,session.connection());
}

for(Iterator
 it = updates.iterator();it.hasNext();){
Auditable
 auditable = (Auditable) it.next();
AuditLog.logEvent("update",auditable,userId,session.connection());
}
}finally{
inserts.clear();
updates.clear();
}

}

}

4、启用拦截器
第一次打开会话时，你需要把Interceptor分配到Hibernate Session：

publicclassItemDao
 {

publicvoidsaveDao(Item
 item){
AuditLogInterceptor
 interceptor =newAuditLogInterceptor();
Session
 session = getSessionFactory().openSession(interceptor);
Transaction
 tx = session.beginTransaction();

interceptor.setSession(session);
interceptor.setUserId(1L);

session.save(item);

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

AuditLog：

publicclassAuditLog
 {

publicstaticvoidlogEvent(String
 message, Auditable auditable,
Long
 userId, Connection connection) {
Session
 session = getSessionFactory().openSession(connection);

try{
AuditLogRecord
 auditLogRecord =newAuditLogRecord(message,
 auditable.getId(),
auditable.getClass(),
 userId,newDate());
session.save(auditLogRecord);
session.flush();
}finally{
session.close();
}

}

}

调用：

ItemDao
 itemDao =newItemDao();
itemDao.saveDao(newItem("hello2"));

//hibernate打印：
//Hibernate:
 insert into ITEM (ITEM_NAME) values (?)
//Hibernate:
 insert into Audit_Log_Record (message, entity_Id, entity_Class, user_Id, created) values (?, ?, ?, ?, ?)

内核事件系统：
Hibernate3.x与Hibernate2.x相比，是内核持久化引擎实现的一项重要的重新设计。新内核引擎基于一个事件/监听器的模型。
（默认方法通过DefaultLoadEventListener处理）
监听器实际上应该被认为是单例，意味着他们在请求之间被共享，因而不应该把任何事务相关的状态保存为实例变量。


cfg.getEventListeners().setLoadEventListeners(listenerStack);

hibernate：

...
<event type="load">
<listener class="mylis.."/>
</event>
</session-factory>

JPA:
...
<property name="hiernate.ejb.event.load" value="mylis...,..."/>
</properties>
</persistence-unit>