Interface CustomEntityDirtinessStrategy

public interface CustomEntityDirtinessStrategy

During a flush cycle, Hibernate needs to determine which of the entities associated with a Session are dirty, meaning modified. Dirty entities will be UPDATEed in the database.

In some circumstances, the process of determining whether an entity is dirty can carry a significant overhead, since, by default, Hibernate must check each of the entity's attribute values one by one. Sometimes, an application already has knowledge of an entity's dirtiness and making use of that information would save some work. This contract allows the application to take over the task of determining if an entity is dirty.

For example, the application program might define an interface implemented by entities which keep track of their own modified fields:

public interface DirtyTracker {
    Set<String> changes();
}

Then the following implementation of CustomEntityDirtinessStrategy would be used:

public class DirtyTrackerDirtinessStrategy implements CustomEntityDirtinessStrategy {
    @Override
    public boolean canDirtyCheck(Object entity, EntityPersister persister, Session session) {
        return entity instanceof DirtyTracker;
    }

    @Override
    public boolean isDirty(Object entity, EntityPersister persister, Session session) {
        return !((DirtyTracker) entity).changes().isEmpty();
    }

    @Override
    public void resetDirty(Object entity, EntityPersister persister, Session session) {
        ((DirtyTracker) entity).changes().clear();
    }

    @Override
    public void findDirty(Object entity, EntityPersister persister, Session session, DirtyCheckContext dirtyCheckContext) {
        dirtyCheckContext.doDirtyChecking( attributeInformation ->
               ((DirtyTracker) entity).changes().contains( attributeInformation.getName() ) );
    }
}

See Also:

• AvailableSettings.CUSTOM_ENTITY_DIRTINESS_STRATEGY
• Configuration.setCustomEntityDirtinessStrategy(CustomEntityDirtinessStrategy)
• SessionFactoryBuilder.applyCustomEntityDirtinessStrategy(CustomEntityDirtinessStrategy)

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
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

Modifier and Type	Method	Description
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(Object, EntityPersister, 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 Details

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(Object, EntityPersister, Session) will be called next as the definitive means to determine whether the entity is dirty.

Parameters:

entity - The entity to be checked

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(Object, EntityPersister, 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(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