hibernate监听器的应用

这里是我看到的一个hibernate监听器的简单实现供参考  http://www.360doc.com/content/14/0623/11/8072791_389034447.shtml

设计思路：

首先，提供一个接口，我们监听实体变化其实需要的就是监听实体增删改的过程，这里我们提供的参数EntityImpl时我们系统业务类的顶层实现（相信我们每个公司的产品都会有一个顶层类），然后是一个记录操作日志的实体类History。

 public interface IHistoryListenerProcess {
     public void postInsert(EntityImpl operateObject,History history);
     public void preDelete(EntityImpl operateObject,History history);
     public void postUpdate(EntityImpl operateObject,History history);
 }

这个history的参数并不全，相信每个系统也都各异，但是共有的方法还是有一些的

 public class History extends SysEntity {

     private static final long serialVersionUID = 6727254578815488286L;

     public static final String SEPERATOR = "⑧";

     private String dataId;
     @Meaning("操作人ID")
     private String operatorId;
     @Meaning("操作人名称")
     private String operatorName;
     @Meaning("操作时间")
     private Timestamp operateDate;
     @Meaning("操作类型")
     private String operateType;
     @Meaning("操作属性名")
     private String attrDisplayName;
     @Meaning("操作属性原值")
     private String oldAttrValue;
     @Meaning("操作属性新值")
     private String newAttrValue;
     省略get set
 }

 /**
  * hibernate 事件监听器，对新增，删除，修改事件进行监听
  *
  */
 @SuppressWarnings({ "serial" })
 public class HistoryListener implements PostInsertEventListener, PostUpdateEventListener, PreDeleteEventListener {

     public final static String SAVE = "1"; // 新增
     public final static String DELETE = "2";// 删除
     public final static String UPDATE = "3";// 修改

     /**
      * 监听模式
      * <ul>
      * <li>on：监听所有</li>
      * <li>off：不监听</li>
      * <li>如果是以英文逗号隔开的类名，则只监听这些类</li>
      * <li>这里我们把需要扩展的监听类放在配置文件中SysUtils.getSysParam只是读取配置文件的方法</li>
      * </ul>
      */
     private static String mode = SysUtils.getSysParam("hibernate.history.listener.classes", "off");
     private static String processClassStr = SysUtils.getSysParam("hibernate.history.listener.processCls");
     private static IHistoryListenerProcess process;

     /**
      * 捕获插入事件，并保存到历史记录信息中
      *
      * @param event 新增事件
      */
     public void onPostInsert(PostInsertEvent event) {
         Object object = event.getEntity();
         if (isListened(object)) {
             logHistoryOnSaveOrDelete((EntityImpl) object, SAVE, event.getPersister());
         }
     }

     /**
      * 捕获删除事件，并保存到历史记录信息中
      *
      * @param event 删除事件
      */
     public boolean onPreDelete(PreDeleteEvent event) {
         Object object = event.getEntity();
         if (isListened(object)) {
             logHistoryOnSaveOrDelete((EntityImpl) object, DELETE, event.getPersister());
         }
         return false;
     }

     /**
      * 捕获修改事件，并保存到历史记录信息中
      *
      * @param enent 修改 event.getOldState() 存的是原来的数据 格式为 数据的值的顺序排列</br>
      *            eg: 张三,12,2016..... event.getState() 新的值 排列顺序同上
      *
      */
     public void onPostUpdate(PostUpdateEvent event) {
         Object object = event.getEntity();
         if (isListened(object)) {
             logHistroyOnUpdate((EntityImpl) object, UPDATE, event.getOldState(), event.getState(), event.getPersister());
         }
     }

     /**
      * 新增删除的历史信息 这里写在一块主要是因为新增和删除是记录一个状态，并不会记录其他的东西
      *
      * @param operateObject 被操作字段的对象
      * @param operateType 用户操作类型
      */
     private void logHistoryOnSaveOrDelete(EntityImpl operateObject, String operateType, EntityPersister persister) {
         History history = new History();
         history.setDataId(operateObject.getId());
         history.setOperateType(operateType);
         history.setOperateDate(new java.sql.Timestamp(System.currentTimeMillis()));
         getProcess(operateObject, history, operateType);
         saveHistory(history);
     }

     /**
      * 保存history对象
      *
      * @param history
      */
     private void saveHistory(History history) {

     }

     /**
      * 获取编辑操作字段的属性名，原值，新增
      *
      * @param newModel 监听器监听到被操作字段的对象
      * @param operateType 用户操作类型
      */
     private void logHistroyOnUpdate(EntityImpl newModel, String operateType, Object[] oldStates, Object[] newStates, EntityPersister persister) {
         String[] fields = persister.getPropertyNames();// 字段属性值
         if (oldStates == null || newStates == null || fields == null || oldStates.length != newStates.length || oldStates.length != fields.length) {
             return;
         }
         String oldValue = "";
         String newValue = "";
         for (int i = 0; i < fields.length; i++) {
             Object newState = newStates[i];
             Object oldState = oldStates[i];
             if (newState == oldState || (newState != null && newState.equals(oldState))) {
                 continue;
             }
             newValue += newState + History.SEPERATOR;// 这里用分割符拆分，方便以后处理
             oldValue += oldState + History.SEPERATOR;
         }

         logHistroyOnUpdate(newModel, newValue, oldValue, operateType, persister);
     }

     /**
      * 保存修改字段的历史信息
      *
      * @param operateoperateObjectObject 被操作字段的对象
      * @param newValue 被操作字段的新值
      * @param oldValue 被操作字段的原值
      * @param fieldType 被操作字段的类型
      * @param fieldName 被操作字段的属性名字
      * @param fieldCategoryName 被操作字段对应的字段
      * @param operateType 用户操作类型
      */
     public void logHistroyOnUpdate(EntityImpl operateObject, String newValue, String oldValue, String operateType, EntityPersister persister) {
         History history = SpringContextUtil.getBean(History.class);
         history.setDataId(operateObject.getId());
         history.setOperateType(operateType);
         history.setOldAttrValue(oldValue);
         history.setNewAttrValue(newValue);
         history.setOperateDate(new java.sql.Timestamp(System.currentTimeMillis()));
         getProcess(operateObject, history, operateType);
         saveHistory(history);
     }

     private void getProcess(EntityImpl operateObject, History history, String type) {
         String[] classStr = processClassStr.split(",");
         for (String clazz : classStr) {
             if (StringUtils.isNotBlank(processClassStr)) {
                 Object po = null;
                 try {
                     po = Class.forName(clazz).newInstance();
                 } catch (Exception e) {

                 }

                 if (IHistoryListenerProcess.class.isInstance(po)) {
                     process = (IHistoryListenerProcess) po;
                 } else {
                     throw new SysException("要监听持久化的类必须继承IHistoryListenerProcess接口");
                 }
             }
             if (process == null) {
                 continue;
             }
             if (StringUtils.equals(type, SAVE)) {
                 process.postInsert(operateObject, history);
             } else if (StringUtils.equals(type, UPDATE)) {
                 process.postUpdate(operateObject, history);
             } else if (StringUtils.equals(type, DELETE)) {
                 process.preDelete(operateObject, history);
             }
             process = null;
         }
     }

     /**
      * 判断是否为监听的模块，在这里可做处理
      *
      * @param object 监听到被操作的对象
      */
     private boolean isListened(Object object) {
         if (EntityImpl.class.isInstance(object) && "on".equals(mode)) {
             return true;
         }
         return false;
     }
 }

这里 我们只要implements IHistoryListenerProcess 并且把类的全路径写入到配置文件中，在hibernate执行增删改的时候就会走我们的方法，这有点类似于监听者模式的意思，当然我们实现这个类也就会得到我们需要的EntityImpl类；

这个实现只是一个便捷的想法，以后在编码中可能会用到，但是现实是我们系统中并不会只用hibernate，或者说是我们封装好的save、update等方法，如果是jdbctemplate呢，我还需要一个spring监听器，所以这就需要我们编码的规范

和底层代码封装的丰富程度了！