org.hibernate.LockOptions#getAliasLockCount ( )源码实例Demo

@Override
protected LockMode determineFollowOnLockMode(LockOptions lockOptions) {
	final LockMode lockModeToUse = lockOptions.findGreatestLockMode();

	if ( lockOptions.getAliasLockCount() > 1 ) {
		// > 1 here because criteria always uses alias map for the root lock mode (under 'this_')
		LOG.aliasSpecificLockingWithFollowOnLocking( lockModeToUse );
	}

	return lockModeToUse;
}
 

@Override
protected String applyLocks(
		String sql,
		QueryParameters parameters,
		Dialect dialect,
		List<AfterLoadAction> afterLoadActions) throws QueryException {
	final LockOptions lockOptions = parameters.getLockOptions();
	if ( lockOptions == null ||
			( lockOptions.getLockMode() == LockMode.NONE && lockOptions.getAliasLockCount() == 0 ) ) {
		return sql;
	}

	// user is request locking, lets see if we can apply locking directly to the SQL...

	// 		some dialects wont allow locking with paging...
	afterLoadActions.add(
			new AfterLoadAction() {
				private final LockOptions originalLockOptions = lockOptions.makeCopy();

				@Override
				public void afterLoad(SharedSessionContractImplementor session, Object entity, Loadable persister) {
					( (Session) session ).buildLockRequest( originalLockOptions ).lock(
							persister.getEntityName(),
							entity
					);
				}
			}
	);
	parameters.getLockOptions().setLockMode( LockMode.READ );

	return sql;
}
 

/**
 * @param lockOptions a collection of lock modes specified dynamically via the Query interface
 */
@Override
protected LockMode[] getLockModes(LockOptions lockOptions) {
	if ( lockOptions == null ) {
		return defaultLockModes;
	}

	if ( lockOptions.getAliasLockCount() == 0
			&& ( lockOptions.getLockMode() == null || LockMode.NONE.equals( lockOptions.getLockMode() ) ) ) {
		return defaultLockModes;
	}

	// unfortunately this stuff can't be cached because
	// it is per-invocation, not constant for the
	// QueryTranslator instance

	LockMode[] lockModesArray = new LockMode[entityAliases.length];
	for ( int i = 0; i < entityAliases.length; i++ ) {
		LockMode lockMode = lockOptions.getEffectiveLockMode( entityAliases[i] );
		if ( lockMode == null ) {
			//NONE, because its the requested lock mode, not the actual!
			lockMode = LockMode.NONE;
		}
		lockModesArray[i] = lockMode;
	}

	return lockModesArray;
}
 

@Override
protected LockMode[] getLockModes(LockOptions lockOptions) {

	// unfortunately this stuff can't be cached because
	// it is per-invocation, not constant for the
	// QueryTranslator instance
	HashMap nameLockOptions = new HashMap();
	if ( lockOptions == null ) {
		lockOptions = LockOptions.NONE;
	}

	if ( lockOptions.getAliasLockCount() > 0 ) {
		Iterator iter = lockOptions.getAliasLockIterator();
		while ( iter.hasNext() ) {
			Map.Entry me = (Map.Entry) iter.next();
			nameLockOptions.put(
					getAliasName( (String) me.getKey() ),
					me.getValue()
			);
		}
	}
	LockMode[] lockModesArray = new LockMode[names.length];
	for ( int i = 0; i < names.length; i++ ) {
		LockMode lm = (LockMode) nameLockOptions.get( names[i] );
		//if ( lm == null ) lm = LockOptions.NONE;
		if ( lm == null ) {
			lm = lockOptions.getLockMode();
		}
		lockModesArray[i] = lm;
	}
	return lockModesArray;
}
 

@Override
protected String applyLocks(
		String sql,
		QueryParameters parameters,
		Dialect dialect,
		List<AfterLoadAction> afterLoadActions) throws QueryException {
	// can't cache this stuff either (per-invocation)
	// we are given a map of user-alias -> lock mode
	// create a new map of sql-alias -> lock mode

	final LockOptions lockOptions = parameters.getLockOptions();

	if ( lockOptions == null ||
			( lockOptions.getLockMode() == LockMode.NONE && lockOptions.getAliasLockCount() == 0 ) ) {
		return sql;
	}


	// user is request locking, lets see if we can apply locking directly to the SQL...

	// 		some dialects wont allow locking with paging...
	if ( shouldUseFollowOnLocking( parameters, dialect, afterLoadActions ) ) {
		return sql;
	}

	//		there are other conditions we might want to add here, such as checking the result types etc
	//		but those are better served after we have redone the SQL generation to use ASTs.


	// we need both the set of locks and the columns to reference in locks
	// as the ultimate output of this section...
	final LockOptions locks = new LockOptions( lockOptions.getLockMode() );
	final Map<String, String[]> keyColumnNames = dialect.forUpdateOfColumns()
			? new HashMap<>()
			: null;

	locks.setScope( lockOptions.getScope() );
	locks.setTimeOut( lockOptions.getTimeOut() );

	for ( Map.Entry<String, String> entry : sqlAliasByEntityAlias.entrySet() ) {
		final String userAlias = entry.getKey();
		final String drivingSqlAlias = entry.getValue();
		if ( drivingSqlAlias == null ) {
			throw new IllegalArgumentException( "could not locate alias to apply lock mode : " + userAlias );
		}
		// at this point we have (drivingSqlAlias) the SQL alias of the driving table
		// corresponding to the given user alias.  However, the driving table is not
		// (necessarily) the table against which we want to apply locks.  Mainly,
		// the exception case here is joined-subclass hierarchies where we instead
		// want to apply the lock against the root table (for all other strategies,
		// it just happens that driving and root are the same).
		final QueryNode select = (QueryNode) queryTranslator.getSqlAST();
		final Lockable drivingPersister = (Lockable) select.getFromClause()
				.findFromElementByUserOrSqlAlias( userAlias, drivingSqlAlias )
				.getQueryable();
		final String sqlAlias = drivingPersister.getRootTableAlias( drivingSqlAlias );

		final LockMode effectiveLockMode = lockOptions.getEffectiveLockMode( userAlias );
		locks.setAliasSpecificLockMode( sqlAlias, effectiveLockMode );

		if ( keyColumnNames != null ) {
			keyColumnNames.put( sqlAlias, drivingPersister.getRootTableIdentifierColumnNames() );
		}
	}

	// apply the collected locks and columns
	return dialect.applyLocksToSql( sql, locks, keyColumnNames );
}