## org.hibernate
Class EmptyInterceptor

    java.lang.Object
      org.hibernate.EmptyInterceptor

All Implemented Interfaces:
  Serializable, Interceptor

    public class EmptyInterceptor

extends Object
implements Interceptor, Serializable

An interceptor that does nothing. May be used as a base class for application-defined custom interceptors.

Author:
  Gavin King
See Also:
  Serialized Form

Field Summary
`static Interceptor` `INSTANCE`

Constructor Summary
`protected` `EmptyInterceptor()`

Method Summary
`void` `afterTransactionBegin(Transaction tx)` Called when a Hibernate transaction is begun via the Hibernate `Transaction` API.
`void` `afterTransactionCompletion(Transaction tx)` Called after a transaction is committed or rolled back.
`void` `beforeTransactionCompletion(Transaction tx)` Called before a transaction is committed (but not before rollback).
`int[]` `findDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types)` Called from `flush()`.
`Object` `getEntity(String entityName, Serializable id)` Get a fully loaded entity instance that is cached externally
`String` `getEntityName(Object object)` Get the entity name for a persistent or transient instance
`Object` `instantiate(String entityName, EntityMode entityMode, Serializable id)` Instantiate the entity class.
`Boolean` `isTransient(Object entity)` Called to distinguish between transient and detached entities.
`void` `onCollectionRecreate(Object collection, Serializable key)` Called before a collection is (re)created.
`void` `onCollectionRemove(Object collection, Serializable key)` Called before a collection is deleted.
`void` `onCollectionUpdate(Object collection, Serializable key)` Called before a collection is updated.
`void` `onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)` Called before an object is deleted.
`boolean` `onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types)` Called when an object is detected to be dirty, during a flush.
`boolean` `onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)` Called just before an object is initialized.
`String` `onPrepareStatement(String sql)` Called when sql string is being prepared.
`boolean` `onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)` Called before an object is saved.
`void` `postFlush(Iterator entities)` Called after a flush that actually ends in execution of the SQL statements required to synchronize in-memory state with the database.
`void` `preFlush(Iterator entities)` Called before a flush

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### INSTANCE

    public static final Interceptor INSTANCE

Constructor Detail

### EmptyInterceptor

    protected EmptyInterceptor()

Method Detail

### onDelete

    public void onDelete(Object entity,
                         Serializable id,
                         Object[] state,
                         String[] propertyNames,
                         Type[] types)

  Description copied from interface: `Interceptor`
  Called before an object is deleted. It is not recommended that the interceptor modify the `state`.

  Specified by:
    `onDelete` in interface `Interceptor`

### onFlushDirty

    public boolean onFlushDirty(Object entity,
                                Serializable id,
                                Object[] currentState,
                                Object[] previousState,
                                String[] propertyNames,
                                Type[] types)

  Description copied from interface: `Interceptor`
  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`.

  Specified by:
    `onFlushDirty` in interface `Interceptor`
  Returns:
    `true` if the user modified the `currentState` in any way.

### onLoad

    public boolean onLoad(Object entity,
                          Serializable id,
                          Object[] state,
                          String[] propertyNames,
                          Type[] types)

  Description copied from interface: `Interceptor`
  Called just before an object is initialized. The interceptor may change the `state`, which will be propagated to the persistent object. Note that when this method is called, `entity` will be an empty uninitialized instance of the class.

  Specified by:
    `onLoad` in interface `Interceptor`
  Returns:
    `true` if the user modified the `state` in any way.

### onSave

    public boolean onSave(Object entity,
                          Serializable id,
                          Object[] state,
                          String[] propertyNames,
                          Type[] types)

  Description copied from interface: `Interceptor`
  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.

  Specified by:
    `onSave` in interface `Interceptor`
  Returns:
    `true` if the user modified the `state` in any way.

### postFlush

    public void postFlush(Iterator entities)

  Description copied from interface: `Interceptor`
  Called after a flush that actually ends in execution of the SQL statements required to synchronize in-memory state with the database.

  Specified by:
    `postFlush` in interface `Interceptor`

### preFlush

    public void preFlush(Iterator entities)

  Description copied from interface: `Interceptor`
  Called before a flush

  Specified by:
    `preFlush` in interface `Interceptor`

### isTransient

    public Boolean isTransient(Object entity)

  Description copied from interface: `Interceptor`
  Called to distinguish between transient and detached entities. The return value determines the state of the entity with respect to the current session.
  - `Boolean.TRUE` - the entity is transient
  - `Boolean.FALSE` - the entity is detached
  - `null` - Hibernate uses the `unsaved-value` mapping and other heuristics to determine if the object is unsaved

  Specified by:
    `isTransient` in interface `Interceptor`
  Parameters:
    `entity` - a transient or detached entity
  Returns:
    Boolean or `null` to choose default behaviour

### instantiate

    public Object instantiate(String entityName,
                              EntityMode entityMode,
                              Serializable id)

  Description copied from interface: `Interceptor`
  Instantiate the entity class. Return `null` 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.

  Specified by:
    `instantiate` in interface `Interceptor`
  Parameters:
    `entityName` - the name of the entity
    `entityMode` - The type of entity instance to be returned.
    `id` - the identifier of the new instance
  Returns:
    an instance of the class, or `null` to choose default behaviour

### findDirty

    public int[] findDirty(Object entity,
                           Serializable id,
                           Object[] currentState,
                           Object[] previousState,
                           String[] propertyNames,
                           Type[] types)

  Description copied from interface: `Interceptor`
  Called from `flush()`. The return value determines whether the entity is updated
  - an array of property indices - the entity is dirty
  - an empty array - the entity is not dirty
  - `null` - use Hibernate's default dirty-checking algorithm

  Specified by:
    `findDirty` in interface `Interceptor`
  Parameters:
    `entity` - a persistent entity
  Returns:
    array of dirty property indices or `null` to choose default behaviour

### getEntityName

    public String getEntityName(Object object)

  Description copied from interface: `Interceptor`
  Get the entity name for a persistent or transient instance

  Specified by:
    `getEntityName` in interface `Interceptor`
  Parameters:
    `object` - an entity instance
  Returns:
    the name of the entity

### getEntity

    public Object getEntity(String entityName,
                            Serializable id)

  Description copied from interface: `Interceptor`
  Get a fully loaded entity instance that is cached externally

  Specified by:
    `getEntity` in interface `Interceptor`
  Parameters:
    `entityName` - the name of the entity
    `id` - the instance identifier
  Returns:
    a fully initialized entity

### afterTransactionBegin

    public void afterTransactionBegin(Transaction tx)

  Description copied from interface: `Interceptor`
  Called when a Hibernate transaction is begun via the Hibernate `Transaction` API. Will not be called if transactions are being controlled via some other mechanism (CMT, for example).

  Specified by:
    `afterTransactionBegin` in interface `Interceptor`

### afterTransactionCompletion

    public void afterTransactionCompletion(Transaction tx)

  Description copied from interface: `Interceptor`
  Called after a transaction is committed or rolled back.

  Specified by:
    `afterTransactionCompletion` in interface `Interceptor`

### beforeTransactionCompletion

    public void beforeTransactionCompletion(Transaction tx)

  Description copied from interface: `Interceptor`
  Called before a transaction is committed (but not before rollback).

  Specified by:
    `beforeTransactionCompletion` in interface `Interceptor`

### onPrepareStatement

    public String onPrepareStatement(String sql)

  Description copied from interface: `Interceptor`
  Called when sql string is being prepared.

  Specified by:
    `onPrepareStatement` in interface `Interceptor`
  Parameters:
    `sql` - sql to be prepared
  Returns:
    original or modified sql

### onCollectionRemove

    public void onCollectionRemove(Object collection,
                                   Serializable key)
                            throws CallbackException

  Description copied from interface: `Interceptor`
  Called before a collection is deleted.

  Specified by:
    `onCollectionRemove` in interface `Interceptor`
  Throws:
    `CallbackException`

### onCollectionRecreate

    public void onCollectionRecreate(Object collection,
                                     Serializable key)
                              throws CallbackException

  Description copied from interface: `Interceptor`
  Called before a collection is (re)created.

  Specified by:
    `onCollectionRecreate` in interface `Interceptor`
  Throws:
    `CallbackException`

### onCollectionUpdate

    public void onCollectionUpdate(Object collection,
                                   Serializable key)
                            throws CallbackException

  Description copied from interface: `Interceptor`
  Called before a collection is updated.

  Specified by:
    `onCollectionUpdate` in interface `Interceptor`
  Throws:
    `CallbackException`

Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.