org.hibernate.loader.entity.UniqueEntityLoader#org.hibernate.engine.spi.LoadQueryInfluencers源码实例Demo

public DynamicBatchingCollectionInitializer(
		QueryableCollection collectionPersister,
		int maxBatchSize,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	super( collectionPersister );
	this.maxBatchSize = maxBatchSize;

	if ( collectionPersister.isOneToMany() ) {
		this.singleKeyLoader = new OneToManyLoader( collectionPersister, 1, factory, influencers );
	}
	else {
		this.singleKeyLoader = new BasicCollectionLoader( collectionPersister, 1, factory, influencers );
	}

	this.batchLoader = new DynamicBatchingCollectionLoader( collectionPersister, factory, influencers );
}
 

public DynamicBatchingCollectionLoader(
		QueryableCollection collectionPersister,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	super( collectionPersister, factory, influencers );

	JoinWalker walker = buildJoinWalker( collectionPersister, factory, influencers );
	initFromWalker( walker );
	this.sqlTemplate = walker.getSQLString();
	this.alias = StringHelper.generateAlias( collectionPersister.getRole(), 0 );
	postInstantiate();

	if ( LOG.isDebugEnabled() ) {
		LOG.debugf(
				"SQL-template for dynamic collection [%s] batch-fetching : %s",
				collectionPersister.getRole(),
				sqlTemplate
		);
	}
}
 

@Override
public FetchStrategy determineFetchPlan(LoadQueryInfluencers loadQueryInfluencers, PropertyPath propertyPath) {
	final EntityPersister owningPersister = getSource().getEntityPersister();

	FetchStyle style = FetchStrategyHelper.determineFetchStyleByProfile(
			loadQueryInfluencers,
			owningPersister,
			propertyPath,
			attributeNumber()
	);
	if ( style == null ) {
		style = FetchStrategyHelper.determineFetchStyleByMetadata(
				( (OuterJoinLoadable) getSource().getEntityPersister() ).getFetchMode( attributeNumber() ),
				getType(),
				sessionFactory()
		);
	}

	return new FetchStrategy(
			FetchStrategyHelper.determineFetchTiming( style, getType(), sessionFactory() ),
			style
	);
}
 

public ReactiveCascadeEntityLoader(
		OuterJoinLoadable persister,
		CascadingAction action,
		SessionFactoryImplementor factory) throws MappingException {
	super(
			persister,
			persister.getIdentifierType(),
			factory,
			LoadQueryInfluencers.NONE
	);

	initFromWalker( new CascadeEntityJoinWalker( persister, action, factory ) );

	postInstantiate();

	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Static select for action %s on entity %s: %s", action, entityName, getSQLString() );
	}
}
 

public ReactiveSubselectOneToManyLoader(
		QueryableCollection persister,
		String subquery,
		Collection entityKeys,
		QueryParameters queryParameters,
		Map<String, int[]> namedParameterLocMap,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( persister, 1, subquery, factory, loadQueryInfluencers );

	keys = new Serializable[ entityKeys.size() ];
	Iterator iter = entityKeys.iterator();
	int i=0;
	while ( iter.hasNext() ) {
		keys[i++] = ( (EntityKey) iter.next() ).getIdentifier();
	}

	this.namedParameters = queryParameters.getNamedParameters();
	this.types = queryParameters.getFilteredPositionalParameterTypes();
	this.values = queryParameters.getFilteredPositionalParameterValues();
	this.namedParameterLocMap = namedParameterLocMap;
}
 

public BasicCollectionJoinWalker(
		QueryableCollection collectionPersister, 
		int batchSize, 
		String subquery, 
		SessionFactoryImplementor factory, 
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {

	super( factory, loadQueryInfluencers );

	this.collectionPersister = collectionPersister;

	String alias = generateRootAlias( collectionPersister.getRole() );

	walkCollectionTree(collectionPersister, alias);

	List allAssociations = new ArrayList();
	allAssociations.addAll(associations);
	allAssociations.add( OuterJoinableAssociation.createRoot( collectionPersister.getCollectionType(), alias, getFactory() ) );
	initPersisters(allAssociations, LockMode.NONE);
	initStatementString(alias, batchSize, subquery);
}
 

public SubselectCollectionLoader(
		QueryableCollection persister, 
		String subquery,
		Collection entityKeys,
		QueryParameters queryParameters,
		Map<String, int[]> namedParameterLocMap,
		SessionFactoryImplementor factory, 
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( persister, 1, subquery, factory, loadQueryInfluencers );

	keys = new Serializable[ entityKeys.size() ];
	Iterator iter = entityKeys.iterator();
	int i=0;
	while ( iter.hasNext() ) {
		keys[i++] = ( (EntityKey) iter.next() ).getIdentifier();
	}
	
	this.namedParameters = queryParameters.getNamedParameters();
	this.types = queryParameters.getFilteredPositionalParameterTypes();
	this.values = queryParameters.getFilteredPositionalParameterValues();
	this.namedParameterLocMap = namedParameterLocMap;
	
}
 

public ReactiveOneToManyLoader(
		QueryableCollection oneToManyPersister,
		int batchSize,
		String subquery,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super(oneToManyPersister, factory, loadQueryInfluencers);

	initFromWalker( new OneToManyJoinWalker(
			oneToManyPersister,
			batchSize,
			subquery,
			factory,
			loadQueryInfluencers
	) );

	postInstantiate();
	if (LOG.isDebugEnabled()) {
		LOG.debugf("Static select for one-to-many %s: %s", oneToManyPersister.getRole(), getSQLString());
	}
}
 

protected BasicCollectionLoader(
		QueryableCollection collectionPersister,
		int batchSize,
		String subquery,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( collectionPersister, factory, loadQueryInfluencers );

	JoinWalker walker = new BasicCollectionJoinWalker(
			collectionPersister,
			batchSize,
			subquery,
			factory,
			loadQueryInfluencers
	);
	initFromWalker( walker );

	postInstantiate();

	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Static select for collection %s: %s", collectionPersister.getRole(), getSQLString() );
	}
}
 

public OneToManyLoader(
		QueryableCollection oneToManyPersister,
		int batchSize,
		String subquery,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( oneToManyPersister, factory, loadQueryInfluencers );

	JoinWalker walker = new OneToManyJoinWalker(
			oneToManyPersister,
			batchSize,
			subquery,
			factory,
			loadQueryInfluencers
	);
	initFromWalker( walker );

	postInstantiate();
	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Static select for one-to-many %s: %s", oneToManyPersister.getRole(), getSQLString() );
	}
}
 

public EntityJoinWalker(
		OuterJoinLoadable persister, 
		String[] uniqueKey, 
		int batchSize, 
		LockMode lockMode,
		final SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( persister, factory, loadQueryInfluencers );

	this.lockOptions.setLockMode(lockMode);
	
	StringBuilder whereCondition = whereString( getAlias(), uniqueKey, batchSize )
			//include the discriminator and class-level where, but not filters
			.append( persister.filterFragment( getAlias(), Collections.EMPTY_MAP ) );

	AssociationInitCallbackImpl callback = new AssociationInitCallbackImpl( factory );
	initAll( whereCondition.toString(), "", lockOptions, callback );
	this.compositeKeyManyToOneTargetIndices = callback.resolve();
}
 

public EntityJoinWalker(
		OuterJoinLoadable persister,
		String[] uniqueKey,
		int batchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	super( persister, factory, loadQueryInfluencers );
	LockOptions.copy(lockOptions, this.lockOptions);

	StringBuilder whereCondition = whereString( getAlias(), uniqueKey, batchSize )
			//include the discriminator and class-level where, but not filters
			.append( persister.filterFragment( getAlias(), Collections.EMPTY_MAP ) );

	AssociationInitCallbackImpl callback = new AssociationInitCallbackImpl( factory );
	initAll( whereCondition.toString(), "", lockOptions, callback );
	this.compositeKeyManyToOneTargetIndices = callback.resolve();
}
 

public EntityLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	this(
			persister,
			persister.getIdentifierColumnNames(),
			persister.getIdentifierType(),
			batchSize,
			lockMode,
			factory,
			loadQueryInfluencers
		);
}
 

/**
 * Used by JDK serialization...
 *
 * @param ois The input stream from which we are being read...
 *
 * @throws IOException Indicates a general IO stream exception
 * @throws ClassNotFoundException Indicates a class resolution issue
 */
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException, SQLException {
	if ( TRACE_ENABLED ) {
		log.tracef( "Deserializing Session [%s]", getSessionIdentifier() );
	}

	ois.defaultReadObject();

	persistenceContext = StatefulPersistenceContext.deserialize( ois, this );
	actionQueue = ActionQueue.deserialize( ois, this );

	loadQueryInfluencers = (LoadQueryInfluencers) ois.readObject();

	// LoadQueryInfluencers.getEnabledFilters() tries to validate each enabled
	// filter, which will fail when called before FilterImpl.afterDeserialize( factory );
	// Instead lookup the filter by name and then call FilterImpl.afterDeserialize( factory ).
	for ( String filterName : loadQueryInfluencers.getEnabledFilterNames() ) {
		( (FilterImpl) loadQueryInfluencers.getEnabledFilter( filterName ) ).afterDeserialize( getFactory() );
	}

	initializeFromSessionOwner( null );

	this.disallowOutOfTransactionUpdateOperations = !getFactory().getSessionFactoryOptions().isAllowOutOfTransactionUpdateOperations();
	this.discardOnClose = getFactory().getSessionFactoryOptions().isReleaseResourcesOnCloseEnabled();
}
 

private EntityLoader createUniqueKeyLoader(
		Type uniqueKeyType,
		String[] columns,
		LoadQueryInfluencers loadQueryInfluencers) {
	if ( uniqueKeyType.isEntityType() ) {
		String className = ( (EntityType) uniqueKeyType ).getAssociatedEntityName();
		uniqueKeyType = getFactory().getMetamodel().entityPersister( className ).getIdentifierType();
	}
	return new EntityLoader(
			this,
			columns,
			uniqueKeyType,
			1,
			LockMode.NONE,
			getFactory(),
			loadQueryInfluencers
	);
}
 

public BasicCollectionLoader(
		QueryableCollection collectionPersister,
		int batchSize,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	this( collectionPersister, batchSize, null, factory, loadQueryInfluencers );
}
 

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

public ReactiveEntityLoader(
		OuterJoinLoadable persister,
		SessionFactoryImplementor factory,
		LockMode lockMode,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	this( persister, 1, lockMode, factory, loadQueryInfluencers );
}
 

protected CollectionInitializer buildNonBatchingLoader(
		QueryableCollection persister,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	return persister.isOneToMany() ?
			new OneToManyLoader( persister, factory, influencers ) :
			new BasicCollectionLoader( persister, factory, influencers );
}
 

private ReactiveEntityLoader(
		OuterJoinLoadable persister,
		Type uniqueKeyType,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers,
		EntityJoinWalker walker) throws MappingException {
	super( persister, uniqueKeyType, factory, loadQueryInfluencers );

	initFromWalker( walker );
	compositeKeyManyToOneTargetIndices = walker.getCompositeKeyManyToOneTargetIndices();
	postInstantiate();
}
 

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

public ReactiveDynamicBatchingEntityDelegator(
		OuterJoinLoadable persister,
		int maxBatchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) {
	super( persister );
	this.maxBatchSize = maxBatchSize;
	this.singleKeyLoader = new ReactiveEntityLoader( persister, 1, lockMode, factory, loadQueryInfluencers );
	this.dynamicLoader = new ReactiveDynamicBatchingEntityLoader( persister, maxBatchSize, lockMode, factory, loadQueryInfluencers );
}
 

public ReactiveDynamicBatchingEntityDelegator(
		OuterJoinLoadable persister,
		int maxBatchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) {
	super( persister );
	this.maxBatchSize = maxBatchSize;
	this.singleKeyLoader = new ReactiveEntityLoader( persister, 1, lockOptions, factory, loadQueryInfluencers );
	this.dynamicLoader = new ReactiveDynamicBatchingEntityLoader( persister, maxBatchSize, lockOptions, factory, loadQueryInfluencers );
}
 

/**
 * Builds a batch-fetch capable loader based on the given persister, lock-mode, etc.
 *
 * @param persister The entity persister
 * @param batchSize The maximum number of ids to batch-fetch at once
 * @param lockMode The lock mode
 * @param factory The SessionFactory
 * @param influencers Any influencers that should affect the built query
 *
 * @return The loader.
 */
public UniqueEntityLoader buildLoader(
		OuterJoinLoadable persister,
		int batchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers influencers) {
	if ( batchSize <= 1 ) {
		// no batching
		return buildNonBatchingLoader( persister, lockMode, factory, influencers );
	}
	return buildBatchingLoader( persister, batchSize, lockMode, 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 buildNonBatchingLoader(
			OuterJoinLoadable persister,
			LockOptions lockOptions,
			SessionFactoryImplementor factory,
			LoadQueryInfluencers influencers) {
		return new ReactivePlanEntityLoader.Builder( persister )
				.withLockMode( lockOptions.getLockMode() )
				.withInfluencers( influencers )
				.byPrimaryKey();
//		return new ReactiveEntityLoader( persister, factory, lockOptions.getLockMode(), influencers);
	}
 

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

public ReactiveDynamicBatchingEntityLoader(
		OuterJoinLoadable persister,
		int maxBatchSize,
		LockOptions lockOptions,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) {
	this( persister, maxBatchSize, lockOptions.getLockMode(), factory, loadQueryInfluencers );
}
 

public ReactiveDynamicBatchingEntityLoader(
		OuterJoinLoadable persister,
		int maxBatchSize,
		LockMode lockMode,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) {
	super( persister, -1, lockMode, factory, loadQueryInfluencers );

	EntityJoinWalker walker = new EntityJoinWalker(
			persister,
			persister.getIdentifierColumnNames(),
			-1,
			lockMode,
			factory,
			loadQueryInfluencers) {
		@Override
		protected StringBuilder whereString(String alias, String[] columnNames, int batchSize) {
			return buildBatchFetchRestrictionFragment(
					alias,
					columnNames,
					getDialect()
			);
		}
	};

	initFromWalker( walker );
	this.sqlTemplate = walker.getSQLString();
	this.alias = walker.getAlias();
	postInstantiate();

	if ( LOG.isDebugEnabled() ) {
		LOG.debugf(
				"SQL-template for dynamic entity [%s] batch-fetching [%s] : %s",
				entityName,
				lockMode,
				sqlTemplate
		);
	}
}
 

@Override
public CollectionInitializer createRealBatchingCollectionInitializer(
		QueryableCollection persister,
		int maxBatchSize,
		SessionFactoryImplementor factory,
		LoadQueryInfluencers loadQueryInfluencers) throws MappingException {
	int[] batchSizes = ArrayHelper.getBatchSizes( maxBatchSize );
	Loader[] loaders = new Loader[ batchSizes.length ];
	for ( int i = 0; i < batchSizes.length; i++ ) {
		loaders[i] = new BasicCollectionLoader( persister, batchSizes[i], factory, loadQueryInfluencers );
	}
	return new LegacyBatchingCollectionInitializer( persister, batchSizes, loaders );
}