Hibernate回调与拦截机制——Hibernate深入浅出

Hibernate的回调与拦截机制有三种实现方法：
1、实体对象implements Lifecycle接口，Lifecycle接口代码：

<!---->public interface Lifecycle {
    /**
     * 在实体对象Save/Insert操作之前触发.
     */
    public boolean onSave(Session s) throws CallbackException;
    
    /**
     * 在Session.update()操作之前触发.
     */
    public boolean onUpdate(Session s) throws CallbackException;

    /**
     * 在实体对象删除之前触发.
     */
    public boolean onDelete(Session s) throws CallbackException;

    /**<!---->
     * 在实体对象加载之后触发.
     */
    public void onLoad(Session s, Serializable id);
}

实体对象通过实现Lifecycle接口，即可以在特定的持久化阶段，触发特定的处理过程。比如在实体对象Tuser实现了Lifecycle接口的onSave方法，则在实体对象Tuser保存之前将先执行onSave方法。

2、实体对象implements Validatable接口，Validatable接口代码：

<!---->public interface Validatable {
    public void validate() throws ValidationFailure;
}

   Validatable接口定义了数据验证实现方式。实体对象实现Validatable接口，并在validate方法中对当前待保存的数据进行验证，以保证数据的逻辑合法性(由于该方法在实体对象生命周期内，可能被多次调用，所以此方法最好只用于数据本身的逻辑合法性验证，而不要试图去实现数据业务逻辑的验证)。

以上2种方法都要求实现Hibernate中的Lifecycle或Validatable接口，具有很大的侵入性，使得实体对象的移植很不方便。Hibernate又提供了一种拦截机制，为对象持久化事件的捕获和处理提供了一个非侵入性的实现。

3、实现Interceptor接口，在创建session时，指定加载Interceptor相应的实现类，此session 的持久化操作都将首先经由此拦截器捕获处理。Interceptor(Hibernate3)接口代码：

<!---->package org.hibernate;

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

import org.hibernate.type.Type;

public interface Interceptor {
 
    //对象初始化之前加载,这里的entity处于刚被创建的状态(即属性均未赋值).
    public boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames,
            Type[] types) throws CallbackException;
   
    //Session.flush()方法进行脏数据检查时,如果发现PO状态改变,则调用此方法(即实体对象更新之前调用).
    public boolean onFlushDirty(Object entity, Serializable id, Object[] currentState,
           Object[] previousState, String[] propertyNames, Type[] types) throws CallbackException;
   
    //在实体对象被保存之前调用.
    public boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames,
           Type[] types) throws CallbackException;
   
    //在对象被删除之前调用.
    public void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames,
           Type[] types) throws CallbackException;
    /**
     * Called before a collection is (re)created.
     */
    public void onCollectionRecreate(Object collection, Serializable key) throws CallbackException;
    /**
     * Called before a collection is deleted.
     */
    public void onCollectionRemove(Object collection, Serializable key) throws CallbackException;
    /**
     * Called before a collection is updated.
     */
    public void onCollectionUpdate(Object collection, Serializable key) throws CallbackException;
   
    //Session执行flush方法之前调用.
    public void preFlush(Iterator entities) throws CallbackException;
  
    //Session执行flush方法之后调用.
    public void postFlush(Iterator entities) throws CallbackException;

    /**
     * Called to distinguish between transient and detached entities. The return value determines the
     * state of the entity with respect to the current session.
     * <ul>
     * <li><tt>Boolean.TRUE</tt> - the entity is transient
     * <li><tt>Boolean.FALSE</tt> - the entity is detached
     * <li><tt>null</tt> - Hibernate uses the <tt>unsaved-value</tt> mapping and other heuristics to 
     * determine if the object is unsaved
     * </ul>
     * @param entity a transient or detached entity
     * @return Boolean or <tt>null</tt> to choose default behaviour
     */
    public Boolean isTransient(Object entity);
    /**
     * Called from <tt>flush()</tt>. The return value determines whether the entity is updated
     * <ul>
     * <li>an array of property indices - the entity is dirty
     * <li>an empty array - the entity is not dirty
     * <li><tt>null</tt> - use Hibernate's default dirty-checking algorithm
     * </ul>
     * @param entity a persistent entity
     * @return array of dirty property indices or <tt>null</tt> to choose default behaviour
     */
    public int[] findDirty(Object entity, Serializable id, Object[] currentState,
             Object[] previousState, String[] propertyNames, Type[] types);
    /**
     * Instantiate the entity class. Return <tt>null</tt> to indicate that Hibernate should use
     * the default constructor of the class. The identifier property of the returned instance
     * should be initialized with the given identifier.
     *
     * @param entityName the name of the entity
     * @param entityMode The type of entity instance to be returned.
     * @param id the identifier of the new instance
     * @return an instance of the class, or <tt>null</tt> to choose default behaviour
     */
    public Object instantiate(String entityName, EntityMode entityMode,
           Serializable id) throws CallbackException;

    /**
     * Get the entity name for a persistent or transient instance
     * @param object an entity instance
     * @return the name of the entity
     */
    public String getEntityName(Object object) throws CallbackException;

    /**
     * Get a fully loaded entity instance that is cached externally
     * @param entityName the name of the entity
     * @param id the instance identifier
     * @return a fully initialized entity
     * @throws CallbackException
     */
    public Object getEntity(String entityName, Serializable id) throws CallbackException;
    
    /**
     * Called when a Hibernate transaction is begun via the Hibernate <tt>Transaction</tt> 
     * API. Will not be called if transactions are being controlled via some other 
     * mechanism (CMT, for example).
     */
    public void afterTransactionBegin(Transaction tx);
    /**
     * Called before a transaction is committed (but not before rollback).
     */
    public void beforeTransactionCompletion(Transaction tx);
    /**     * Called after a transaction is committed or rolled back.
     */
    public void afterTransactionCompletion(Transaction tx);

    /**
     * Called when sql string is being prepared. 
     * @param sql sql to be prepared
     * @return original or modified sql
     */
    public String onPrepareStatement(String sql);
}

评论

2 楼 friping 2009-10-20  

不好意思，刚刚不小心点了提交。发错了

1 楼 friping 2009-10-20  

   表格: 用换行和

来编辑格子

:sh
字体颜色: 标准深红红色橙色棕色黄色绿色橄榄青色蓝色深蓝靛蓝紫色灰色白色黑色 字体大小: 标准1 (xx-small)2 (x-small)3 (small)4 (medium)5 (large)6 (x-large)7 (xx-large) 对齐: 标准居左居中居右
插入表格: 用换行和

来编辑格子

ock: