Java 类org.hibernate.loader.entity.UniqueEntityLoader 实例源码

private UniqueEntityLoader getAppropriateLoader(LockMode lockMode, SessionImplementor session) {
    final Map enabledFilters = session.getEnabledFilters();
    if ( queryLoader != null ) {
        return queryLoader;
    }
    else if ( enabledFilters == null || enabledFilters.isEmpty() ) {
        if ( session.getFetchProfile()!=null && LockMode.UPGRADE.greaterThan(lockMode) ) {
            return (UniqueEntityLoader) loaders.get( session.getFetchProfile() );
        }
        else {
            return (UniqueEntityLoader) loaders.get( lockMode );
        }
    }
    else {
        return createEntityLoader( lockMode, enabledFilters );
    }
}

@Override
protected UniqueEntityLoader buildNonBatchingLoader(
        OuterJoinLoadable persister,
        LockMode lockMode,
        SessionFactoryImplementor factory,
        LoadQueryInfluencers influencers) {
    return EntityLoader.forEntity( persister ).withLockMode( lockMode ).withInfluencers( influencers ).byPrimaryKey();
}

@Override
protected UniqueEntityLoader buildNonBatchingLoader(
        OuterJoinLoadable persister,
        LockOptions lockOptions,
        SessionFactoryImplementor factory,
        LoadQueryInfluencers influencers) {
    return EntityLoader.forEntity( persister ).withLockOptions( lockOptions ).withInfluencers( influencers ).byPrimaryKey();
}

@Override
protected UniqueEntityLoader buildBatchingLoader(
        OuterJoinLoadable persister,
        int batchSize,
        LockMode lockMode,
        SessionFactoryImplementor factory,
        LoadQueryInfluencers influencers) {
    return new LegacyBatchingEntityLoader( persister, batchSize, lockMode, factory, influencers );
}

@Override
protected UniqueEntityLoader buildBatchingLoader(
        OuterJoinLoadable persister,
        int batchSize,
        LockOptions lockOptions,
        SessionFactoryImplementor factory,
        LoadQueryInfluencers influencers) {
    return new LegacyBatchingEntityLoader( persister, batchSize, lockOptions, factory, influencers );
}

protected UniqueEntityLoader createEntityLoader(
        LockMode lockMode,
        LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
    //TODO: disable batch loading if lockMode > READ?
    return BatchingEntityLoaderBuilder.getBuilder( getFactory() )
            .buildLoader( this, batchSize, lockMode, getFactory(), loadQueryInfluencers );
}

protected UniqueEntityLoader createEntityLoader(
        LockOptions lockOptions,
        LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
    //TODO: disable batch loading if lockMode > READ?
    return BatchingEntityLoaderBuilder.getBuilder( getFactory() )
            .buildLoader( this, batchSize, lockOptions, getFactory(), loadQueryInfluencers );
}

/**
 * Load an instance using either the <tt>forUpdateLoader</tt> or the outer joining <tt>loader</tt>,
 * depending upon the value of the <tt>lock</tt> parameter
 */
public Object load(Serializable id, Object optionalObject, LockOptions lockOptions, SessionImplementor session)
        throws HibernateException {

    if ( LOG.isTraceEnabled() ) {
        LOG.tracev( "Fetching entity: {0}", MessageHelper.infoString( this, id, getFactory() ) );
    }

    final UniqueEntityLoader loader = getAppropriateLoader(lockOptions, session );
    return loader.load( id, optionalObject, session, lockOptions );
}

private UniqueEntityLoader getAppropriateLoader(LockOptions lockOptions, SessionImplementor session) {
    if ( queryLoader != null ) {
        // if the user specified a custom query loader we need to that
        // regardless of any other consideration
        return queryLoader;
    }
    else if ( isAffectedByEnabledFilters( session ) ) {
        // because filters affect the rows returned (because they add
        // restrictions) these need to be next in precedence
        return createEntityLoader(lockOptions, session.getLoadQueryInfluencers() );
    }
    else if ( session.getLoadQueryInfluencers().getInternalFetchProfile() != null && LockMode.UPGRADE.greaterThan( lockOptions.getLockMode() ) ) {
        // Next, we consider whether an 'internal' fetch profile has been set.
        // This indicates a special fetch profile Hibernate needs applied
        // (for its merge loading process e.g.).
        return ( UniqueEntityLoader ) getLoaders().get( session.getLoadQueryInfluencers().getInternalFetchProfile() );
    }
    else if ( isAffectedByEnabledFetchProfiles( session ) ) {
        // If the session has associated influencers we need to adjust the
        // SQL query used for loading based on those influencers
        return createEntityLoader(lockOptions, session.getLoadQueryInfluencers() );
    }
    else if ( isAffectedByEntityGraph( session ) ) {
        return createEntityLoader( lockOptions, session.getLoadQueryInfluencers() );
    }
    else if ( lockOptions.getTimeOut() != LockOptions.WAIT_FOREVER ) {
        return createEntityLoader( lockOptions, session.getLoadQueryInfluencers() );
    }
    else {
        return ( UniqueEntityLoader ) getLoaders().get( lockOptions.getLockMode() );
    }
}

private void createLoaders() {
    loaders.put( LockMode.NONE, createEntityLoader( LockMode.NONE ) );

    UniqueEntityLoader readLoader = createEntityLoader( LockMode.READ );
    loaders.put( LockMode.READ, readLoader );

    //TODO: inexact, what we really need to know is: are any outer joins used?
    boolean disableForUpdate = getSubclassTableSpan() > 1 &&
            hasSubclasses() &&
            !getFactory().getDialect().supportsOuterJoinForUpdate();

    loaders.put(
            LockMode.UPGRADE,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.UPGRADE )
        );
    loaders.put(
            LockMode.UPGRADE_NOWAIT,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.UPGRADE_NOWAIT )
        );
    loaders.put(
            LockMode.FORCE,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.FORCE )
        );

    loaders.put(
            "merge",
            new CascadeEntityLoader( this, CascadingAction.MERGE, getFactory() )
        );
    loaders.put(
            "refresh",
            new CascadeEntityLoader( this, CascadingAction.REFRESH, getFactory() )
        );
}

/**
 * Load an instance using either the <tt>forUpdateLoader</tt> or the outer joining <tt>loader</tt>,
 * depending upon the value of the <tt>lock</tt> parameter
 */
public Object load(Serializable id, Object optionalObject, LockMode lockMode, SessionImplementor session)
        throws HibernateException {

    if ( log.isTraceEnabled() ) {
        log.trace(
                "Fetching entity: " +
                MessageHelper.infoString( this, id, getFactory() )
            );
    }

    final UniqueEntityLoader loader = getAppropriateLoader( lockMode, session );
    return loader.load( id, optionalObject, session );
}

protected void createLoaders() {
    final Map loaders = getLoaders();
    loaders.put( LockMode.NONE, createEntityLoader( LockMode.NONE ) );

    UniqueEntityLoader readLoader = createEntityLoader( LockMode.READ );
    loaders.put( LockMode.READ, readLoader );

    //TODO: inexact, what we really need to know is: are any outer joins used?
    boolean disableForUpdate = getSubclassTableSpan() > 1 &&
            hasSubclasses() &&
            !getFactory().getDialect().supportsOuterJoinForUpdate();

    loaders.put(
            LockMode.UPGRADE,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.UPGRADE )
        );
    loaders.put(
            LockMode.UPGRADE_NOWAIT,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.UPGRADE_NOWAIT )
        );
    loaders.put(
            LockMode.UPGRADE_SKIPLOCKED,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.UPGRADE_SKIPLOCKED )
        );
    loaders.put(
            LockMode.FORCE,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.FORCE )
        );
    loaders.put(
            LockMode.PESSIMISTIC_READ,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.PESSIMISTIC_READ )
        );
    loaders.put(
            LockMode.PESSIMISTIC_WRITE,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.PESSIMISTIC_WRITE )
        );
    loaders.put(
            LockMode.PESSIMISTIC_FORCE_INCREMENT,
            disableForUpdate ?
                    readLoader :
                    createEntityLoader( LockMode.PESSIMISTIC_FORCE_INCREMENT )
        );
    loaders.put( LockMode.OPTIMISTIC, createEntityLoader( LockMode.OPTIMISTIC) );
    loaders.put( LockMode.OPTIMISTIC_FORCE_INCREMENT, createEntityLoader(LockMode.OPTIMISTIC_FORCE_INCREMENT) );

    loaders.put(
            "merge",
            new CascadeEntityLoader( this, CascadingActions.MERGE, getFactory() )
        );
    loaders.put(
            "refresh",
            new CascadeEntityLoader( this, CascadingActions.REFRESH, getFactory() )
        );
}

protected UniqueEntityLoader createEntityLoader(LockMode lockMode, Map enabledFilters) throws MappingException {
    //TODO: disable batch loading if lockMode > READ?
    return BatchingEntityLoader.createBatchingEntityLoader( this, batchSize, lockMode, getFactory(), enabledFilters );
}

protected UniqueEntityLoader createEntityLoader(LockMode lockMode) throws MappingException {
    return createEntityLoader( lockMode, CollectionHelper.EMPTY_MAP );
}

/**
 * Used internally to create static loaders.  These are the default set of loaders used to handle get()/load()
 * processing.  lock() handling is done by the LockingStrategy instances (see {@link #getLocker})
 *
 * @param lockMode The lock mode to apply to the thing being loaded.
 * @return
 *
 * @throws MappingException
 */
protected UniqueEntityLoader createEntityLoader(LockMode lockMode) throws MappingException {
    return createEntityLoader( lockMode, LoadQueryInfluencers.NONE );
}