## org.hibernate
Interface CustomEntityDirtinessStrategy

    public interface CustomEntityDirtinessStrategy

During a flush cycle, Hibernate needs to determine which of the entities associated with a `Session`. Dirty entities are the ones that get UPDATEed to the database.

In some circumstances, that process of determining whether an entity is dirty can take a significant time as by default Hibernate must check each of the entity's attribute values one-by-one. Oftentimes applications already have knowledge of an entity's dirtiness and using that information instead would be more performant. The purpose of this contract then is to allow applications such a plug-in point.

Nested Class Summary
`static interface` `CustomEntityDirtinessStrategy.AttributeChecker` Responsible for identifying when attributes are dirty.
`static interface` `CustomEntityDirtinessStrategy.AttributeInformation` Provides `CustomEntityDirtinessStrategy.AttributeChecker` with meta information about the attributes being checked.
`static interface` `CustomEntityDirtinessStrategy.DirtyCheckContext` A callback to drive dirty checking.

Method Summary
`boolean` `canDirtyCheck(Object entity, EntityPersister persister, Session session)` Is this strategy capable of telling whether the given entity is dirty? A return of `true` means that `isDirty(java.lang.Object, org.hibernate.persister.entity.EntityPersister, org.hibernate.Session)` will be called next as the definitive means to determine whether the entity is dirty.
`void` `findDirty(Object entity, EntityPersister persister, Session session, CustomEntityDirtinessStrategy.DirtyCheckContext dirtyCheckContext)` Callback used to hook into Hibernate algorithm for determination of which attributes have changed.
`boolean` `isDirty(Object entity, EntityPersister persister, Session session)` The callback used by Hibernate to determine if the given entity is dirty.
`void` `resetDirty(Object entity, EntityPersister persister, Session session)` Callback used by Hibernate to signal that the entity dirty flag should be cleared.

Method Detail

### canDirtyCheck

    boolean canDirtyCheck(Object entity,
                          EntityPersister persister,
                          Session session)

  Is this strategy capable of telling whether the given entity is dirty? A return of `true` means that `isDirty(java.lang.Object, org.hibernate.persister.entity.EntityPersister, org.hibernate.Session)` will be called next as the definitive means to determine whether the entity is dirty.

  Parameters:
    `entity` - The entity to be check.
    `persister` - The persister corresponding to the given entity
    `session` - The session from which this check originates.
  Returns:
    `true` indicates the dirty check can be done; `false` indicates it cannot.

### isDirty

    boolean isDirty(Object entity,
                    EntityPersister persister,
                    Session session)

  The callback used by Hibernate to determine if the given entity is dirty. Only called if the previous `canDirtyCheck(java.lang.Object, org.hibernate.persister.entity.EntityPersister, org.hibernate.Session)` returned `true`

  Parameters:
    `entity` - The entity to check.
    `persister` - The persister corresponding to the given entity
    `session` - The session from which this check originates.
  Returns:
    `true` indicates the entity is dirty; `false` indicates the entity is not dirty.

### resetDirty

    void resetDirty(Object entity,
                    EntityPersister persister,
                    Session session)

  Callback used by Hibernate to signal that the entity dirty flag should be cleared. Generally this happens after previous dirty changes were written to the database.

  Parameters:
    `entity` - The entity to reset
    `persister` - The persister corresponding to the given entity
    `session` - The session from which this call originates.

### findDirty

    void findDirty(Object entity,
                   EntityPersister persister,
                   Session session,
                   CustomEntityDirtinessStrategy.DirtyCheckContext dirtyCheckContext)

  Callback used to hook into Hibernate algorithm for determination of which attributes have changed. Applications wanting to hook in to this would call back into the given `CustomEntityDirtinessStrategy.DirtyCheckContext.doDirtyChecking(org.hibernate.CustomEntityDirtinessStrategy.AttributeChecker)` method passing along an appropriate `CustomEntityDirtinessStrategy.AttributeChecker` implementation.

  Parameters:
    `entity` - The entity being checked
    `persister` - The persister corresponding to the given entity
    `session` - The session from which this call originates.
    `dirtyCheckContext` - The callback context

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