## org.hibernate.event.internal
Class DefaultLoadEventListener

    java.lang.Object
      org.hibernate.event.internal.AbstractReassociateEventListener
          org.hibernate.event.internal.AbstractLockUpgradeEventListener
              org.hibernate.event.internal.DefaultLoadEventListener

All Implemented Interfaces:
  Serializable, LoadEventListener

    public class DefaultLoadEventListener

extends AbstractLockUpgradeEventListener
implements LoadEventListener

Defines the default load event listeners used by hibernate for loading entities in response to generated load events.

See Also:
  Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface org.hibernate.event.spi.LoadEventListener
`LoadEventListener.LoadType`

Field Summary
`static LockMode` `DEFAULT_LOCK_MODE`
`static Object` `INCONSISTENT_RTN_CLASS_MARKER`
`static Object` `REMOVED_ENTITY_MARKER`

Fields inherited from interface org.hibernate.event.spi.LoadEventListener
`GET, IMMEDIATE_LOAD, INTERNAL_LOAD_EAGER, INTERNAL_LOAD_LAZY, INTERNAL_LOAD_NULLABLE, LOAD, RELOAD`

Constructor Summary
`DefaultLoadEventListener()`

Method Summary
`protected Object` `doLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Coordinates the efforts to load a given entity.
`protected Object` `load(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Performs the load of an entity.
`protected Object` `loadFromDatasource(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Performs the process of loading an entity from the configured underlying datasource.
`protected Object` `loadFromSecondLevelCache(LoadEvent event, EntityPersister persister, LoadEventListener.LoadType options)` Attempts to load the entity from the second-level cache.
`protected Object` `loadFromSessionCache(LoadEvent event, EntityKey keyToLoad, LoadEventListener.LoadType options)` Attempts to locate the entity in the session-level cache.
`protected Object` `lockAndLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options, SessionImplementor source)` If the class to be loaded has been configured with a cache, then lock given id in that cache and then perform the load.
`void` `onLoad(LoadEvent event, LoadEventListener.LoadType loadType)` Handle the given load event.
`protected Object` `proxyOrLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadEventListener.LoadType options)` Based on configured options, will either return a pre-existing proxy, generate a new proxy, or perform an actual load.

Methods inherited from class org.hibernate.event.internal.AbstractLockUpgradeEventListener
`upgradeLock`

Methods inherited from class org.hibernate.event.internal.AbstractReassociateEventListener
`reassociate`

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

Field Detail

### REMOVED_ENTITY_MARKER

    public static final Object REMOVED_ENTITY_MARKER

### INCONSISTENT_RTN_CLASS_MARKER

    public static final Object INCONSISTENT_RTN_CLASS_MARKER

### DEFAULT_LOCK_MODE

    public static final LockMode DEFAULT_LOCK_MODE

Constructor Detail

### DefaultLoadEventListener

    public DefaultLoadEventListener()

Method Detail

### onLoad

    public void onLoad(LoadEvent event,
                       LoadEventListener.LoadType loadType)
                throws HibernateException

  Handle the given load event.

  Specified by:
    `onLoad` in interface `LoadEventListener`
  Parameters:
    `event` - The load event to be handled.
  Throws:
    `HibernateException`

### load

    protected Object load(LoadEvent event,
                          EntityPersister persister,
                          EntityKey keyToLoad,
                          LoadEventListener.LoadType options)

  Performs the load of an entity.

  Parameters:
    `event` - The initiating load request event
    `persister` - The persister corresponding to the entity to be loaded
    `keyToLoad` - The key of the entity to be loaded
    `options` - The defined load options
  Returns:
    The loaded entity.
  Throws:
    `HibernateException`

### proxyOrLoad

    protected Object proxyOrLoad(LoadEvent event,
                                 EntityPersister persister,
                                 EntityKey keyToLoad,
                                 LoadEventListener.LoadType options)

  Based on configured options, will either return a pre-existing proxy, generate a new proxy, or perform an actual load.

  Parameters:
    `event` - The initiating load request event
    `persister` - The persister corresponding to the entity to be loaded
    `keyToLoad` - The key of the entity to be loaded
    `options` - The defined load options
  Returns:
    The result of the proxy/load operation.

### lockAndLoad

    protected Object lockAndLoad(LoadEvent event,
                                 EntityPersister persister,
                                 EntityKey keyToLoad,
                                 LoadEventListener.LoadType options,
                                 SessionImplementor source)

  If the class to be loaded has been configured with a cache, then lock given id in that cache and then perform the load.

  Parameters:
    `event` - The initiating load request event
    `persister` - The persister corresponding to the entity to be loaded
    `keyToLoad` - The key of the entity to be loaded
    `options` - The defined load options
    `source` - The originating session
  Returns:
    The loaded entity
  Throws:
    `HibernateException`

### doLoad

    protected Object doLoad(LoadEvent event,
                            EntityPersister persister,
                            EntityKey keyToLoad,
                            LoadEventListener.LoadType options)

  Coordinates the efforts to load a given entity. First, an attempt is made to load the entity from the session-level cache. If not found there, an attempt is made to locate it in second-level cache. Lastly, an attempt is made to load it directly from the datasource.

  Parameters:
    `event` - The load event
    `persister` - The persister for the entity being requested for load
    `keyToLoad` - The EntityKey representing the entity to be loaded.
    `options` - The load options.
  Returns:
    The loaded entity, or null.

### loadFromDatasource

    protected Object loadFromDatasource(LoadEvent event,
                                        EntityPersister persister,
                                        EntityKey keyToLoad,
                                        LoadEventListener.LoadType options)

  Performs the process of loading an entity from the configured underlying datasource.

  Parameters:
    `event` - The load event
    `persister` - The persister for the entity being requested for load
    `keyToLoad` - The EntityKey representing the entity to be loaded.
    `options` - The load options.
  Returns:
    The object loaded from the datasource, or null if not found.

### loadFromSessionCache

    protected Object loadFromSessionCache(LoadEvent event,
                                          EntityKey keyToLoad,
                                          LoadEventListener.LoadType options)
                                   throws HibernateException

  Attempts to locate the entity in the session-level cache.

  If allowed to return nulls, then if the entity happens to be found in the session cache, we check the entity type for proper handling of entity hierarchies.

  If checkDeleted was set to true, then if the entity is found in the session-level cache, it's current status within the session cache is checked to see if it has previously been scheduled for deletion.

  Parameters:
    `event` - The load event
    `keyToLoad` - The EntityKey representing the entity to be loaded.
    `options` - The load options.
  Returns:
    The entity from the session-level cache, or null.
  Throws:
    `HibernateException` - Generally indicates problems applying a lock-mode.

### loadFromSecondLevelCache

    protected Object loadFromSecondLevelCache(LoadEvent event,
                                              EntityPersister persister,
                                              LoadEventListener.LoadType options)

  Attempts to load the entity from the second-level cache.

  Parameters:
    `event` - The load event
    `persister` - The persister for the entity being requested for load
    `options` - The load options.
  Returns:
    The entity from the second-level cache, or null.

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