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监听器，所以这就需要我们编码的规范

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