Hibernate拦截器(Interceptor)与事件监听器(Listener)

前言：

由于项目中（S2SH框架）用到了memcache缓存服务器，考虑到同步问题是用每个bean变更时同时更新缓存还是用类似数据库trigger（触发器）去实现呢，答案当然是用类似trigger的方式了，其优点不言而喻，毕竟这么写一劳永逸。

经调查发现，hibernate有两种方式可以实现：

拦截器（Intercept）：与Struts2的拦截器机制基本一样，都是一个操作穿过一层层拦截器，每穿过一个拦截器就会触发相应拦截器的事件做预处理或善后处理。

监听器（Listener）：其实功能与拦截器是相似的，但它实现原理不同，它是为每一个事件注册一个或多个监听器，一旦事件发生，则事件源通知所有监听该事件的监听器，然后监听器处理通知（观察者模式）。

拦截器具体实现：

1. package fi.uum.cache.intercepter;
3. import java.io.Serializable;
4. import java.util.Iterator;
6. import org.hibernate.CallbackException;
7. import org.hibernate.EmptyInterceptor;
8. import org.hibernate.type.Type;
9. import org.springframework.stereotype.Component;
11. @Component
12. public class CacheIntercepter extends EmptyInterceptor{
14. /**
15. *
16. */
17. private static final long serialVersionUID = 1L;
19. @Override
20. public void onDelete(Object entity, Serializable id, Object[] state,
21. String[] propertyNames, Type[] types) {
22. System.out.println(“delete…………..”);
23. super.onDelete(entity, id, state, propertyNames, types);
24. }
26. @Override
27. public boolean onFlushDirty(Object entity, Serializable id,
28. Object[] currentState, Object[] previousState,
29. String[] propertyNames, Type[] types) {
30. System.out.println(“flushDirty…………..”);
31. return super.onFlushDirty(entity, id, currentState, previousState,
32. propertyNames, types);
33. }
35. @Override
36. public boolean onSave(Object entity, Serializable id, Object[] state,
37. String[] propertyNames, Type[] types) {
38. System.out.println(“save…………..”);
39. return super.onSave(entity, id, state, propertyNames, types);
40. }
42. @Override
43. public void onCollectionRecreate(Object collection, Serializable key)
44. throws CallbackException {
45. System.out.println(“recreate…………..”);
46. super.onCollectionRecreate(collection, key);
47. }
49. @Override
50. public void onCollectionRemove(Object collection, Serializable key)
51. throws CallbackException {
52. System.out.println(“remove…………..”);
53. super.onCollectionRemove(collection, key);
54. }
56. @Override
57. public void onCollectionUpdate(Object collection, Serializable key)
58. throws CallbackException {
59. System.out.println(“collectionUpdate…………..”);
60. super.onCollectionUpdate(collection, key);
61. }
63. @Override
64. public boolean onLoad(Object entity, Serializable id, Object[] state,
65. String[] propertyNames, Type[] types) {
66. System.out.println(“load…………..”);
67. return super.onLoad(entity, id, state, propertyNames, types);
68. }
70. @Override
71. public void postFlush(Iterator entities) {
72. System.out.println(“flush…………..”);
73. super.postFlush(entities);
74. }
76. @Override
77. public String onPrepareStatement(String sql) {
78. System.out.println(“statement…………..”+sql);
79. return super.onPrepareStatement(sql);
80. }
82. @Override
83. public void preFlush(Iterator entities) {
84. System.out.println(“preflush…………..”);
85. super.preFlush(entities);
86. }
88. }

类继承EmptyInterceptor是官方推荐做法。

PS:@Component为spring组件（bean）声明方式，用法类似<bean id=”” class=””> beanid 默认为类名（第一个字母小写），使用@Component前需要先在srping配置文件中声明<!– 配置注入信息的包 –><context:component-scan base-package=”*” /> 。
最后，Hibernate的拦截器有两种设置方式，一种是使用sessionFactory.openSession(Interceptor interceptor)，这样的拦截器只会针对该session有效，又叫做局部拦截器。另一种是使用Configuration的setInterceptor(Interceptor interceptor)方法设置，这样的拦截器对每一个session都有效，又称之为全局拦截器，全局拦截器还有种配置方法是在sessionFactory bean中加

1. <property name=“entityInterceptor”>
2. <ref bean=“cacheIntercepter”/>
3. </property>

事件监听器实现：

1. package fi.uum.cache.listener;
3. import org.hibernate.event.spi.PostDeleteEvent;
4. import org.hibernate.event.spi.PostDeleteEventListener;
5. import org.hibernate.event.spi.PostInsertEvent;
6. import org.hibernate.event.spi.PostInsertEventListener;
7. import org.hibernate.event.spi.PostUpdateEvent;
8. import org.hibernate.event.spi.PostUpdateEventListener;
9. import org.hibernate.persister.entity.EntityPersister;
10. import org.springframework.stereotype.Component;
12. @Component
13. public class CacheEventListener implements PostUpdateEventListener ,
14. PostInsertEventListener,PostDeleteEventListener{
16. private static final long serialVersionUID = 1L;
18. @Override
19. public void onPostDelete(PostDeleteEvent arg0) {
20. System.out.println(“delete……………….”);
21. }
23. @Override
24. public void onPostInsert(PostInsertEvent arg0) {
25. System.out.println(“insert……………….”);
26. }
28. @Override
29. public void onPostUpdate(PostUpdateEvent arg0) {
30. System.out.println(“update……………….”);
31. }
33. @Override
34. public boolean requiresPostCommitHanding(EntityPersister arg0) {
35. System.out.println(“here……………….”);
36. return false;
37. }
40. }

配置方法：

在hibernate4中，查看LocalSessionFactroyBean源码去不支持EventListener。spring3.X 对hibernate4不支持这样的配置，hibernate4 改变了注册EventListener的方式，这里使用注解方式：

1. package fi.uum.common.config;
3. import javax.annotation.PostConstruct;
5. import org.hibernate.SessionFactory;
6. import org.hibernate.event.service.spi.EventListenerRegistry;
7. import org.hibernate.event.spi.EventType;
8. import org.hibernate.internal.SessionFactoryImpl;
9. import org.springframework.beans.factory.annotation.Autowired;
10. import org.springframework.stereotype.Component;
12. import fi.uum.cache.listener.CacheEventListener;
14. @Component
15. public class HibernateIntegrator {
17. @Autowired
18. private CacheEventListener cacheEventListener;
20. @Autowired
21. private SessionFactory sessionFactory;
24. @PostConstruct
25. public void registerListeners() {
26. EventListenerRegistry registry = ((SessionFactoryImpl) sessionFactory).getServiceRegistry().getService(
27. EventListenerRegistry.class);
28. registry.getEventListenerGroup(EventType.POST_INSERT).appendListener(cacheEventListener);
29. registry.getEventListenerGroup(EventType.POST_UPDATE).appendListener(cacheEventListener);
30. registry.getEventListenerGroup(EventType.POST_DELETE).appendListener(cacheEventListener);
31. }
33. }

如果你的项目使用的是hibernate3+，建议在sessionFactory bean中配置eventListener。

实际效果：

两种方法实现过发现在本项目中只有save obj的时候才触发了事件（拦截器），一直不解，后来想到hibernate是基于对象操作的，而在项目中除了save方法外，其他的update、delete、等方法都是通过hql语句实现的，所有更新、删除的事件未触发。这样一来必须通过监听statement语句时通过判断该如果是更新还是删除等执行更新缓存了。