Java 类org.hibernate.event.spi.LoadEvent 实例源码

private void loadByDerivedIdentitySimplePkValue(
        LoadEvent event,
        LoadEventListener.LoadType options,
        EntityPersister dependentPersister,
        EmbeddedComponentType dependentIdType,
        EntityPersister parentPersister) {
    final EntityKey parentEntityKey = event.getSession().generateEntityKey( event.getEntityId(), parentPersister );
    final Object parent = doLoad( event, parentPersister, parentEntityKey, options );

    final Serializable dependent = (Serializable) dependentIdType.instantiate( parent, event.getSession() );
    dependentIdType.setPropertyValues( dependent, new Object[] {parent}, dependentPersister.getEntityMode() );
    final EntityKey dependentEntityKey = event.getSession().generateEntityKey( dependent, dependentPersister );
    event.setEntityId( dependent );

    event.setResult( doLoad( event, dependentPersister, dependentEntityKey, options ) );
}

/**
 * Given a proxy, initialize it and/or narrow it provided either
 * is necessary.
 *
 * @param event The initiating load request event
 * @param persister The persister corresponding to the entity to be loaded
 * @param keyToLoad The key of the entity to be loaded
 * @param options The defined load options
 * @param persistenceContext The originating session
 * @param proxy The proxy to narrow
 *
 * @return The created/existing proxy
 */
private Object returnNarrowedProxy(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options,
        final PersistenceContext persistenceContext,
        final Object proxy) {
    LOG.trace( "Entity proxy found in session cache" );
    LazyInitializer li = ( (HibernateProxy) proxy ).getHibernateLazyInitializer();
    if ( li.isUnwrap() ) {
        return li.getImplementation();
    }
    Object impl = null;
    if ( !options.isAllowProxyCreation() ) {
        impl = load( event, persister, keyToLoad, options );
        if ( impl == null ) {
            event.getSession()
                    .getFactory()
                    .getEntityNotFoundDelegate()
                    .handleEntityNotFound( persister.getEntityName(), keyToLoad.getIdentifier() );
        }
    }
    return persistenceContext.narrowProxy( proxy, persister, keyToLoad, impl );
}

/**
 * Performs the process of loading an entity from the configured
 * underlying datasource.
 *
 * @param event The load event
 * @param persister The persister for the entity being requested for load
 * @param keyToLoad The EntityKey representing the entity to be loaded.
 * @param options The load options.
 *
 * @return The object loaded from the datasource, or null if not found.
 */
protected Object loadFromDatasource(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options) {
    final SessionImplementor source = event.getSession();
    Object entity = persister.load(
            event.getEntityId(),
            event.getInstanceToLoad(),
            event.getLockOptions(),
            source
    );

    if ( event.isAssociationFetch() && source.getFactory().getStatistics().isStatisticsEnabled() ) {
        source.getFactory().getStatisticsImplementor().fetchEntity( event.getEntityClassName() );
    }

    return entity;
}

/** 
 * Load the data for the object with the specified id into a newly created object.
 * This is only called when lazily initializing a proxy.
 * Do NOT return a proxy.
 */
@Override
public Object immediateLoad(String entityName, Serializable id) throws HibernateException {
    if ( LOG.isDebugEnabled() ) {
        EntityPersister persister = getFactory().getEntityPersister(entityName);
        LOG.debugf( "Initializing proxy: %s", MessageHelper.infoString( persister, id, getFactory() ) );
    }

    LoadEvent event = new LoadEvent(id, entityName, true, this);
    fireLoad(event, LoadEventListener.IMMEDIATE_LOAD);
    return event.getResult();
}

@Override
public Object internalLoad(String entityName, Serializable id, boolean eager, boolean nullable) throws HibernateException {
    // todo : remove
    LoadEventListener.LoadType type = nullable
            ? LoadEventListener.INTERNAL_LOAD_NULLABLE
            : eager
                    ? LoadEventListener.INTERNAL_LOAD_EAGER
                    : LoadEventListener.INTERNAL_LOAD_LAZY;
    LoadEvent event = new LoadEvent(id, entityName, true, this);
    fireLoad( event, type );
    if ( !nullable ) {
        UnresolvableObjectException.throwIfNull( event.getResult(), id, entityName );
    }
    return event.getResult();
}

private void fireLoad(LoadEvent event, LoadType loadType) {
    errorIfClosed();
    checkTransactionSynchStatus();
    for ( LoadEventListener listener : listeners( EventType.LOAD ) ) {
        listener.onLoad( event, loadType );
    }
    delayedAfterCompletion();
}

/**
 * Performs the load of an entity.
 *
 * @param event The initiating load request event
 * @param persister The persister corresponding to the entity to be loaded
 * @param keyToLoad The key of the entity to be loaded
 * @param options The defined load options
 *
 * @return The loaded entity.
 *
 * @throws HibernateException
 */
protected Object load(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options) {

    if ( event.getInstanceToLoad() != null ) {
        if ( event.getSession().getPersistenceContext().getEntry( event.getInstanceToLoad() ) != null ) {
            throw new PersistentObjectException(
                    "attempted to load into an instance that was already associated with the session: " +
                            MessageHelper.infoString(
                                    persister,
                                    event.getEntityId(),
                                    event.getSession().getFactory()
                            )
            );
        }
        persister.setIdentifier( event.getInstanceToLoad(), event.getEntityId(), event.getSession() );
    }

    Object entity = doLoad( event, persister, keyToLoad, options );

    boolean isOptionalInstance = event.getInstanceToLoad() != null;

    if ( !options.isAllowNulls() || isOptionalInstance ) {
        if ( entity == null ) {
            event.getSession()
                    .getFactory()
                    .getEntityNotFoundDelegate()
                    .handleEntityNotFound( event.getEntityClassName(), event.getEntityId() );
        }
    }

    if ( isOptionalInstance && entity != event.getInstanceToLoad() ) {
        throw new NonUniqueObjectException( event.getEntityId(), event.getEntityClassName() );
    }

    return entity;
}

/**
 * Based on configured options, will either return a pre-existing proxy,
 * generate a new proxy, or perform an actual load.
 *
 * @param event The initiating load request event
 * @param persister The persister corresponding to the entity to be loaded
 * @param keyToLoad The key of the entity to be loaded
 * @param options The defined load options
 *
 * @return The result of the proxy/load operation.
 */
protected Object proxyOrLoad(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options) {

    if ( LOG.isTraceEnabled() ) {
        LOG.tracev(
                "Loading entity: {0}",
                MessageHelper.infoString( persister, event.getEntityId(), event.getSession().getFactory() )
        );
    }

    // this class has no proxies (so do a shortcut)
    if ( !persister.hasProxy() ) {
        return load( event, persister, keyToLoad, options );
    }

    final PersistenceContext persistenceContext = event.getSession().getPersistenceContext();

    // look for a proxy
    Object proxy = persistenceContext.getProxy( keyToLoad );
    if ( proxy != null ) {
        return returnNarrowedProxy( event, persister, keyToLoad, options, persistenceContext, proxy );
    }

    if ( options.isAllowProxyCreation() ) {
        return createProxyIfNecessary( event, persister, keyToLoad, options, persistenceContext );
    }

    // return a newly loaded object
    return load( event, persister, keyToLoad, options );
}

/**
 * If there is already a corresponding proxy associated with the
 * persistence context, return it; otherwise create a proxy, associate it
 * with the persistence context, and return the just-created proxy.
 *
 * @param event The initiating load request event
 * @param persister The persister corresponding to the entity to be loaded
 * @param keyToLoad The key of the entity to be loaded
 * @param options The defined load options
 * @param persistenceContext The originating session
 *
 * @return The created/existing proxy
 */
private Object createProxyIfNecessary(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options,
        final PersistenceContext persistenceContext) {
    Object existing = persistenceContext.getEntity( keyToLoad );
    if ( existing != null ) {
        // return existing object or initialized proxy (unless deleted)
        LOG.trace( "Entity found in session cache" );
        if ( options.isCheckDeleted() ) {
            EntityEntry entry = persistenceContext.getEntry( existing );
            Status status = entry.getStatus();
            if ( status == Status.DELETED || status == Status.GONE ) {
                return null;
            }
        }
        return existing;
    }
    LOG.trace( "Creating new proxy for entity" );
    // return new uninitialized proxy
    Object proxy = persister.createProxy( event.getEntityId(), event.getSession() );
    persistenceContext.getBatchFetchQueue().addBatchLoadableEntityKey( keyToLoad );
    persistenceContext.addProxy( keyToLoad, proxy );
    return proxy;
}

/**
 * If the class to be loaded has been configured with a cache, then lock
 * given id in that cache and then perform the load.
 *
 * @param event The initiating load request event
 * @param persister The persister corresponding to the entity to be loaded
 * @param keyToLoad The key of the entity to be loaded
 * @param options The defined load options
 * @param source The originating session
 *
 * @return The loaded entity
 *
 * @throws HibernateException
 */
protected Object lockAndLoad(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options,
        final SessionImplementor source) {
    SoftLock lock = null;
    final CacheKey ck;
    if ( persister.hasCache() ) {
        ck = source.generateCacheKey(
                event.getEntityId(),
                persister.getIdentifierType(),
                persister.getRootEntityName()
        );
        lock = persister.getCacheAccessStrategy().lockItem( ck, null );
    }
    else {
        ck = null;
    }

    Object entity;
    try {
        entity = load( event, persister, keyToLoad, options );
    }
    finally {
        if ( persister.hasCache() ) {
            persister.getCacheAccessStrategy().unlockItem( ck, lock );
        }
    }

    return event.getSession().getPersistenceContext().proxyFor( persister, keyToLoad, entity );
}

/**
 * Attempts to locate the entity in the session-level cache.
 * <p/>
 * 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.
 * <p/>
 * 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.
 *
 * @param event The load event
 * @param keyToLoad The EntityKey representing the entity to be loaded.
 * @param options The load options.
 *
 * @return The entity from the session-level cache, or null.
 *
 * @throws HibernateException Generally indicates problems applying a lock-mode.
 */
protected Object loadFromSessionCache(
        final LoadEvent event,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options) throws HibernateException {

    SessionImplementor session = event.getSession();
    Object old = session.getEntityUsingInterceptor( keyToLoad );

    if ( old != null ) {
        // this object was already loaded
        EntityEntry oldEntry = session.getPersistenceContext().getEntry( old );
        if ( options.isCheckDeleted() ) {
            Status status = oldEntry.getStatus();
            if ( status == Status.DELETED || status == Status.GONE ) {
                return REMOVED_ENTITY_MARKER;
            }
        }
        if ( options.isAllowNulls() ) {
            final EntityPersister persister = event.getSession()
                    .getFactory()
                    .getEntityPersister( keyToLoad.getEntityName() );
            if ( !persister.isInstance( old ) ) {
                return INCONSISTENT_RTN_CLASS_MARKER;
            }
        }
        upgradeLock( old, oldEntry, event.getLockOptions(), event.getSession() );
    }

    return old;
}

@Override
public void onLoad(
        final LoadEvent event,
        final LoadEventListener.LoadType loadType) throws HibernateException {

    log.info("+++++++++++++");
}

public void onLoad(LoadEvent event,
    LoadEventListener.LoadType loadType)
    throws HibernateException
{
    System.out.println("�Զ����load�¼�");
    System.out.println(event.getEntityClassName()
        + "==========" + event.getEntityId());
    super.onLoad(event, loadType);
}

@Override
public void load(Object object, Serializable id) throws HibernateException {
    LoadEvent event = new LoadEvent(id, object, this);
    fireLoad( event, LoadEventListener.RELOAD );
}

/**
 * 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.
 *
 * @param event The load event
 * @param persister The persister for the entity being requested for load
 * @param keyToLoad The EntityKey representing the entity to be loaded.
 * @param options The load options.
 *
 * @return The loaded entity, or null.
 */
protected Object doLoad(
        final LoadEvent event,
        final EntityPersister persister,
        final EntityKey keyToLoad,
        final LoadEventListener.LoadType options) {

    final boolean traceEnabled = LOG.isTraceEnabled();
    if ( traceEnabled ) {
        LOG.tracev(
                "Attempting to resolve: {0}",
                MessageHelper.infoString( persister, event.getEntityId(), event.getSession().getFactory() )
        );
    }

    Object entity = loadFromSessionCache( event, keyToLoad, options );
    if ( entity == REMOVED_ENTITY_MARKER ) {
        LOG.debug( "Load request found matching entity in context, but it is scheduled for removal; returning null" );
        return null;
    }
    if ( entity == INCONSISTENT_RTN_CLASS_MARKER ) {
        LOG.debug(
                "Load request found matching entity in context, but the matched entity was of an inconsistent return type; returning null"
        );
        return null;
    }
    if ( entity != null ) {
        if ( traceEnabled ) {
            LOG.tracev(
                    "Resolved object in session cache: {0}",
                    MessageHelper.infoString( persister, event.getEntityId(), event.getSession().getFactory() )
            );
        }
        return entity;
    }

    entity = loadFromSecondLevelCache( event, persister, options );
    if ( entity != null ) {
        if ( traceEnabled ) {
            LOG.tracev(
                    "Resolved object in second-level cache: {0}",
                    MessageHelper.infoString( persister, event.getEntityId(), event.getSession().getFactory() )
            );
        }
    }
    else {
        if ( traceEnabled ) {
            LOG.tracev(
                    "Object not resolved in any cache: {0}",
                    MessageHelper.infoString( persister, event.getEntityId(), event.getSession().getFactory() )
            );
        }
        entity = loadFromDatasource( event, persister, keyToLoad, options );
    }

    if ( entity != null && persister.hasNaturalIdentifier() ) {
        event.getSession().getPersistenceContext().getNaturalIdHelper().cacheNaturalIdCrossReferenceFromLoad(
                persister,
                event.getEntityId(),
                event.getSession().getPersistenceContext().getNaturalIdHelper().extractNaturalIdValues(
                        entity,
                        persister
                )
        );
    }


    return entity;
}

/**
 * Attempts to load the entity from the second-level cache.
 *
 * @param event The load event
 * @param persister The persister for the entity being requested for load
 * @param options The load options.
 *
 * @return The entity from the second-level cache, or null.
 */
protected Object loadFromSecondLevelCache(
        final LoadEvent event,
        final EntityPersister persister,
        final LoadEventListener.LoadType options) {

    final SessionImplementor source = event.getSession();
    final boolean useCache = persister.hasCache()
            && source.getCacheMode().isGetEnabled()
            && event.getLockMode().lessThan( LockMode.READ );

    if ( !useCache ) {
        // we can't use cache here
        return null;
    }

    final SessionFactoryImplementor factory = source.getFactory();
    final CacheKey ck = source.generateCacheKey(
            event.getEntityId(),
            persister.getIdentifierType(),
            persister.getRootEntityName()
    );

    final Object ce = CacheHelper.fromSharedCache( source, ck, persister.getCacheAccessStrategy() );
    if ( factory.getStatistics().isStatisticsEnabled() ) {
        if ( ce == null ) {
            factory.getStatisticsImplementor().secondLevelCacheMiss(
                    persister.getCacheAccessStrategy().getRegion().getName()
            );
        }
        else {
            factory.getStatisticsImplementor().secondLevelCacheHit(
                    persister.getCacheAccessStrategy().getRegion().getName()
            );
        }
    }

    if ( ce == null ) {
        // nothing was found in cache
        return null;
    }

    CacheEntry entry = (CacheEntry) persister.getCacheEntryStructure().destructure( ce, factory );
    Object entity = convertCacheEntryToEntity( entry, event.getEntityId(), persister, event );

    if ( !persister.isInstance( entity ) ) {
        throw new WrongClassException(
                "loaded object was of wrong class " + entity.getClass(),
                event.getEntityId(),
                persister.getEntityName()
            );
    }

    return entity;
}