Java EntityPersister.isVersioned方法代码示例

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
@Override
public Serializable insert(String entityName, Object entity) {
	errorIfClosed();
	EntityPersister persister = getEntityPersister( entityName, entity );
	Serializable id = persister.getIdentifierGenerator().generate( this, entity );
	Object[] state = persister.getPropertyValues( entity );
	if ( persister.isVersioned() ) {
		boolean substitute = Versioning.seedVersion(
				state, persister.getVersionProperty(), persister.getVersionType(), this
		);
		if ( substitute ) {
			persister.setPropertyValues( entity, state );
		}
	}
	if ( id == IdentifierGeneratorHelper.POST_INSERT_INDICATOR ) {
		id = persister.insert(state, entity, this);
	}
	else {
		persister.insert(id, state, entity, this);
	}
	persister.setIdentifier( entity, id, this );
	return id;
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
@Override
public void update(String entityName, Object entity) {
	errorIfClosed();
	EntityPersister persister = getEntityPersister(entityName, entity);
	Serializable id = persister.getIdentifier( entity, this );
	Object[] state = persister.getPropertyValues( entity );
	Object oldVersion;
	if ( persister.isVersioned() ) {
		oldVersion = persister.getVersion( entity );
		Object newVersion = Versioning.increment( oldVersion, persister.getVersionType(), this );
		Versioning.setVersion(state, newVersion, persister);
		persister.setPropertyValues( entity, state );
	}
	else {
		oldVersion = null;
	}
	persister.update(id, state, null, false, null, oldVersion, entity, null, this);
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
private boolean isVersionChanged(Object entity, EventSource source, EntityPersister persister, Object target) {
	if ( !persister.isVersioned() ) {
		return false;
	}
	// for merging of versioned entities, we consider the version having
	// been changed only when:
	// 1) the two version values are different;
	//      *AND*
	// 2) The target actually represents database state!
	//
	// This second condition is a special case which allows
	// an entity to be merged during the same transaction
	// (though during a seperate operation) in which it was
	// originally persisted/saved
	boolean changed = !persister.getVersionType().isSame(
			persister.getVersion( target ),
			persister.getVersion( entity )
	);

	// TODO : perhaps we should additionally require that the incoming entity
	// version be equivalent to the defined unsaved-value?
	return changed && existsInDatabase( target, source, persister );
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
/**
 * Perform any property value substitution that is necessary
 * (interceptor callback, version initialization...)
 *
 * @param entity The entity
 * @param id The entity identifier
 * @param values The snapshot entity state
 * @param persister The entity persister
 * @param source The originating session
 *
 * @return True if the snapshot state changed such that
 *         reinjection of the values into the entity is required.
 */
protected boolean substituteValuesIfNecessary(
		Object entity,
		Serializable id,
		Object[] values,
		EntityPersister persister,
		SessionImplementor source) {
	boolean substitute = source.getInterceptor().onSave(
			entity,
			id,
			values,
			persister.getPropertyNames(),
			persister.getPropertyTypes()
	);

	//keep the existing version number in the case of replicate!
	if ( persister.isVersioned() ) {
		substitute = Versioning.seedVersion(
				values,
				persister.getVersionProperty(),
				persister.getVersionType(),
				source
		) || substitute;
	}
	return substitute;
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
/**
 * Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
 *
 * Add the "hydrated state" (an array) of an uninitialized entity to the session. We don't try
 * to resolve any associations yet, because there might be other entities waiting to be
 * read from the JDBC result set we are currently processing
 *
 * @param persister The persister for the hydrated entity
 * @param id The entity identifier
 * @param values The entity values
 * @param rowId The rowId for the entity
 * @param object An optional instance for the entity being loaded
 * @param lockMode The lock mode
 * @param lazyPropertiesAreUnFetched Whether properties defined as lazy are yet un-fetched
 * @param session The Session
 */
public static void postHydrate(
		final EntityPersister persister,
		final Serializable id,
		final Object[] values,
		final Object rowId,
		final Object object,
		final LockMode lockMode,
		final boolean lazyPropertiesAreUnFetched,
		final SessionImplementor session) {
	final Object version = Versioning.getVersion( values, persister );
	session.getPersistenceContext().addEntry(
			object,
			Status.LOADING,
			values,
			rowId,
			id,
			version,
			lockMode,
			true,
			persister,
			false,
			lazyPropertiesAreUnFetched
		);

	if ( version != null && LOG.isTraceEnabled() ) {
		final String versionStr = persister.isVersioned()
				? persister.getVersionType().toLoggableString( version, session.getFactory() )
				: "null";
		LOG.tracef( "Version: %s", versionStr );
	}
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
/**
 * Convience method to retreive an entities next version value
 */
private Object getNextVersion(FlushEntityEvent event) throws HibernateException {

	EntityEntry entry = event.getEntityEntry();
	EntityPersister persister = entry.getPersister();
	if ( persister.isVersioned() ) {

		Object[] values = event.getPropertyValues();

		if ( entry.isBeingReplicated() ) {
			return Versioning.getVersion( values, persister );
		}
		else {
			int[] dirtyProperties = event.getDirtyProperties();

			final boolean isVersionIncrementRequired = isVersionIncrementRequired(
					event,
					entry,
					persister,
					dirtyProperties
			);

			final Object nextVersion = isVersionIncrementRequired ?
					Versioning.increment( entry.getVersion(), persister.getVersionType(), event.getSession() ) :
					entry.getVersion(); //use the current version

			Versioning.setVersion( values, nextVersion, persister );

			return nextVersion;
		}
	}
	else {
		return null;
	}

}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
/**
 * Performs a pessimistic lock upgrade on a given entity, if needed.
 *
 * @param object The entity for which to upgrade the lock.
 * @param entry The entity's EntityEntry instance.
 * @param lockOptions contains the requested lock mode.
 * @param source The session which is the source of the event being processed.
 */
protected void upgradeLock(Object object, EntityEntry entry, LockOptions lockOptions, EventSource source) {

	LockMode requestedLockMode = lockOptions.getLockMode();
	if ( requestedLockMode.greaterThan( entry.getLockMode() ) ) {
		// The user requested a "greater" (i.e. more restrictive) form of
		// pessimistic lock

		if ( entry.getStatus() != Status.MANAGED ) {
			throw new ObjectDeletedException(
					"attempted to lock a deleted instance",
					entry.getId(),
					entry.getPersister().getEntityName()
			);
		}

		final EntityPersister persister = entry.getPersister();

		if ( log.isTraceEnabled() ) {
			log.tracev(
					"Locking {0} in mode: {1}",
					MessageHelper.infoString( persister, entry.getId(), source.getFactory() ),
					requestedLockMode
			);
		}

		final SoftLock lock;
		final CacheKey ck;
		if ( persister.hasCache() ) {
			ck = source.generateCacheKey( entry.getId(), persister.getIdentifierType(), persister.getRootEntityName() );
			lock = persister.getCacheAccessStrategy().lockItem( ck, entry.getVersion() );
		}
		else {
			ck = null;
			lock = null;
		}

		try {
			if ( persister.isVersioned() && requestedLockMode == LockMode.FORCE  ) {
				// todo : should we check the current isolation mode explicitly?
				Object nextVersion = persister.forceVersionIncrement(
						entry.getId(), entry.getVersion(), source
				);
				entry.forceLocked( object, nextVersion );
			}
			else {
				persister.lock( entry.getId(), entry.getVersion(), object, lockOptions, source );
			}
			entry.setLockMode(requestedLockMode);
		}
		finally {
			// the database now holds a lock + the object is flushed from the cache,
			// so release the soft lock
			if ( persister.hasCache() ) {
				persister.getCacheAccessStrategy().unlockItem( ck, lock );
			}
		}

	}
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
private boolean isCollectionDirtyCheckNecessary(EntityPersister persister, Status status) {
	return ( status == Status.MANAGED || status == Status.READ_ONLY ) &&
			persister.isVersioned() &&
			persister.hasCollections();
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
/**
 * Inject the optimistic locking value into the entity state snapshot.
 *
 * @param fields The state snapshot
 * @param version The optimistic locking value
 * @param persister The entity persister
 */
public static void setVersion(Object[] fields, Object version, EntityPersister persister) {
	if ( !persister.isVersioned() ) {
		return;
	}
	fields[ persister.getVersionProperty() ] = version;
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
/**
 * Extract the optimistic locking value out of the entity state snapshot.
 *
 * @param fields The state snapshot
 * @param persister The entity persister
 * @return The extracted optimistic locking value
 */
public static Object getVersion(Object[] fields, EntityPersister persister) {
	if ( !persister.isVersioned() ) {
		return null;
	}
	return fields[ persister.getVersionProperty() ];
}