Java NaturalIdRegionAccessStrategy类代码示例

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
public UnionSubclassEntityPersister(
		final EntityBinding entityBinding,
		final EntityRegionAccessStrategy cacheAccessStrategy,
		final NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
		final SessionFactoryImplementor factory,
		final Mapping mapping) throws HibernateException {
	super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory );
	// TODO: implement!!! initializing final fields to null to make compiler happy.
	subquery = null;
	tableName = null;
	subclassClosure = null;
	spaces = null;
	subclassSpaces = null;
	discriminatorValue = null;
	discriminatorSQLValue = null;
	constraintOrderedTableNames = null;
	constraintOrderedKeyColumnNames = null;
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
@Override
public NaturalIdRegionAccessStrategy buildAccessStrategy(final AccessType accessType) throws CacheException {
    if (AccessType.READ_ONLY.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadOnlyAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.NONSTRICT_READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new NonStrictReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    throw new CacheException("AccessType \"" + accessType + "\" is not currently supported by Hazelcast.");
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
private static void populateMappingModel(MetadataImplementor mappingMetadata, ExplicitSqmDomainMetamodel domainMetamodel) {
//		final PersisterFactory persisterFactory = getSessionFactory().getServiceRegistry().getService( PersisterFactory.class );
		final PersisterFactory persisterFactory = domainMetamodel.getPersisterFactory();

		for ( final PersistentClass model : mappingMetadata.getEntityBindings() ) {
//			final EntityRegionAccessStrategy accessStrategy = getSessionFactory().getCache().determineEntityRegionAccessStrategy(
//					model
//			);
			final EntityRegionAccessStrategy accessStrategy = null;

//			final NaturalIdRegionAccessStrategy naturalIdAccessStrategy = getSessionFactory().getCache().determineNaturalIdRegionAccessStrategy(
//					model
//			);
			final NaturalIdRegionAccessStrategy naturalIdAccessStrategy = null;

			persisterFactory.createEntityPersister(
					model,
					accessStrategy,
					naturalIdAccessStrategy,
					domainMetamodel
			);
		}

		persisterFactory.finishUp( domainMetamodel );
	}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {

        switch (accessType) {

            case READ_ONLY:
                if (metadata.isMutable()) {
                    log.warn("read-only cache configured for mutable entity ["
                            + getName() + "]");
                }
                return new ReadOnlyMemcachedNaturalIdRegionAccessStrategy(this, settings);
            case READ_WRITE:
                return new ReadWriteMemcachedNaturalIdRegionAccessStrategy(this, settings, metadata);
            case NONSTRICT_READ_WRITE:
                return new NonStrictReadWriteMemcachedNaturalIdRegionAccessStrategy(this, settings);
            case TRANSACTIONAL:
                return new TransactionalMemcachedNaturalIdRegionAccessStrategy(this, settings);
            default:
                throw new IllegalArgumentException("unrecognized access strategy type [" + accessType + "]");
        }
    }
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
@Override
	public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
		switch ( accessType ) {
			case READ_ONLY:
				if ( getCacheDataDescription().isMutable() ) {
					LOG.warnf( "read-only cache configured for mutable collection [ %s ]", getName() );
				}
				return new ReadOnlyNaturalIdRegionAccessStrategy( this );
			case READ_WRITE:
				 return new ReadWriteNaturalIdRegionAccessStrategy( this );
			case NONSTRICT_READ_WRITE:
				return new NonstrictReadWriteNaturalIdRegionAccessStrategy( this );
			case TRANSACTIONAL:
				return new TransactionalNaturalIdRegionAccessStrategy( this );
//				throw new UnsupportedOperationException( "doesn't support this access strategy" );
			default:
				throw new IllegalArgumentException( "unrecognized access strategy type [" + accessType + "]" );
		}
	}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
@Override
@SuppressWarnings( {"unchecked"})
public EntityPersister createEntityPersister(
		PersistentClass metadata,
		EntityRegionAccessStrategy cacheAccessStrategy,
		NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
		SessionFactoryImplementor factory,
		Mapping cfg) {
	Class<? extends EntityPersister> persisterClass = metadata.getEntityPersisterClass();
	if ( persisterClass == null ) {
		persisterClass = serviceRegistry.getService( PersisterClassResolver.class ).getEntityPersisterClass( metadata );
	}
	return create( persisterClass, ENTITY_PERSISTER_CONSTRUCTOR_ARGS, metadata, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, cfg );
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
/**
 * Handle removing cross reference entries for the given natural-id/pk combo
 *
 * @param persister The persister representing the entity type.
 * @param pk The primary key value
 * @param naturalIdValues The natural id value(s)
 * 
 * @return The cached values, if any.  May be different from incoming values.
 */
public Object[] removeNaturalIdCrossReference(EntityPersister persister, Serializable pk, Object[] naturalIdValues) {
	persister = locatePersisterForKey( persister );
	validateNaturalId( persister, naturalIdValues );

	final NaturalIdResolutionCache entityNaturalIdResolutionCache = naturalIdResolutionCacheMap.get( persister );
	Object[] sessionCachedNaturalIdValues = null;
	if ( entityNaturalIdResolutionCache != null ) {
		final CachedNaturalId cachedNaturalId = entityNaturalIdResolutionCache.pkToNaturalIdMap
				.remove( pk );
		if ( cachedNaturalId != null ) {
			entityNaturalIdResolutionCache.naturalIdToPkMap.remove( cachedNaturalId );
			sessionCachedNaturalIdValues = cachedNaturalId.getValues();
		}
	}

	if ( persister.hasNaturalIdCache() ) {
		final NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy = persister
				.getNaturalIdCacheAccessStrategy();
		final NaturalIdCacheKey naturalIdCacheKey = new NaturalIdCacheKey( naturalIdValues, persister, session() );
		naturalIdCacheAccessStrategy.evict( naturalIdCacheKey );

		if ( sessionCachedNaturalIdValues != null
				&& !Arrays.equals( sessionCachedNaturalIdValues, naturalIdValues ) ) {
			final NaturalIdCacheKey sessionNaturalIdCacheKey = new NaturalIdCacheKey( sessionCachedNaturalIdValues, persister, session() );
			naturalIdCacheAccessStrategy.evict( sessionNaturalIdCacheKey );
		}
	}

	return sessionCachedNaturalIdValues;
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
@Override
		public void removeSharedNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] naturalIdValues) {
			if ( !persister.hasNaturalIdentifier() ) {
				// nothing to do
				return;
			}

			if ( ! persister.hasNaturalIdCache() ) {
				// nothing to do
				return;
			}

			// todo : couple of things wrong here:
			//		1) should be using access strategy, not plain evict..
			//		2) should prefer session-cached values if any (requires interaction from removeLocalNaturalIdCrossReference

			persister = locateProperPersister( persister );
			final NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy = persister.getNaturalIdCacheAccessStrategy();
			final NaturalIdCacheKey naturalIdCacheKey = new NaturalIdCacheKey( naturalIdValues, persister, session );
			naturalIdCacheAccessStrategy.evict( naturalIdCacheKey );

//			if ( sessionCachedNaturalIdValues != null
//					&& !Arrays.equals( sessionCachedNaturalIdValues, deletedNaturalIdValues ) ) {
//				final NaturalIdCacheKey sessionNaturalIdCacheKey = new NaturalIdCacheKey( sessionCachedNaturalIdValues, persister, session );
//				naturalIdCacheAccessStrategy.evict( sessionNaturalIdCacheKey );
//			}
		}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
/**
 * Performs the process of loading an entity from the configured
 * underlying datasource.
 * 
 * @param event The load event
 *
 * @return The object loaded from the datasource, or null if not found.
 */
protected Serializable loadFromDatasource(final ResolveNaturalIdEvent event) {
	final SessionFactoryImplementor factory = event.getSession().getFactory();
	final boolean stats = factory.getStatistics().isStatisticsEnabled();
	long startTime = 0;
	if ( stats ) {
		startTime = System.nanoTime();
	}
	
	final Serializable pk = event.getEntityPersister().loadEntityIdByNaturalId(
			event.getOrderedNaturalIdValues(),
			event.getLockOptions(),
			event.getSession()
	);
	
	if ( stats ) {
		final NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy = event.getEntityPersister().getNaturalIdCacheAccessStrategy();
		final String regionName = naturalIdCacheAccessStrategy == null ? null : naturalIdCacheAccessStrategy.getRegion().getName();
		final long endTime = System.nanoTime();
		final long milliseconds = TimeUnit.MILLISECONDS.convert( endTime - startTime, TimeUnit.NANOSECONDS );
		factory.getStatisticsImplementor().naturalIdQueryExecuted(
				regionName,
				milliseconds );
	}
	
	//PK can be null if the entity doesn't exist
	if (pk != null) {
		event.getSession().getPersistenceContext().getNaturalIdHelper().cacheNaturalIdCrossReferenceFromLoad(
				event.getEntityPersister(),
				pk,
				event.getOrderedNaturalIdValues()
		);
	}
	
	return pk;
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
public NaturalIdRegionAccessStrategy buildAccessStrategy(final AccessType accessType) throws CacheException {
    if (AccessType.READ_ONLY.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadOnlyAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.NONSTRICT_READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new NonStrictReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    throw new CacheException("AccessType \"" + accessType + "\" is not currently supported by Hazelcast.");
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
public static NaturalIdRegionAccessStrategy buildNaturalIdRegionAccessStrategy(TayzGridNaturalIdRegion region, AccessType accessType) {
    switch (accessType) {
        case READ_ONLY:
            return new ReadOnlyTayzGridNaturalIdRegionAccessStrategy(region);
        case NONSTRICT_READ_WRITE:
            return  new NonStrictReadWriteTayzGridNaturalIdRegionAccessStrategy(region);
        case READ_WRITE:
            return new ReadWriteTayzGridNaturalIdRegionAccessStraegy(region);
        case TRANSACTIONAL:
            throw new IllegalArgumentException(accessType + " access strategy not supported.");
        default:
            throw new IllegalArgumentException(accessType + " is not recognized as valid access type.");
    }
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
public EntityPersisterImpl(
		PersistentClass mappingDescriptor,
		EntityRegionAccessStrategy entityCaching,
		NaturalIdRegionAccessStrategy naturalIdCaching,
		PersisterCreationContext creationContext) {
	super( resolveEntityJavaTypeDescriptor( creationContext, mappingDescriptor), null, null );
	this.entityName = mappingDescriptor.getEntityName();
	this.jpaEntityName = mappingDescriptor.getJpaEntityName();

	setTypeConfiguration( creationContext.getTypeConfiguration() );
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
@Override
public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
    switch (accessType) {
        case READ_ONLY:
            return new ReadOnlyNaturalIdRegionAccessStrategy(this);
        case NONSTRICT_READ_WRITE:
            return new NonstrictReadWriteNaturalIdRegionAccessStrategy(this);
        default:
            throw new CacheException("Unsupported access strategy : " + accessType + ".");
    }
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
public NaturalIdRegionAccessStrategy getNaturalIdCacheAccessStrategy() {
	return naturalIdRegionAccessStrategy;
}
 

import org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy; //导入依赖的package包/类
public JoinedSubclassEntityPersister(
		final EntityBinding entityBinding,
		final EntityRegionAccessStrategy cacheAccessStrategy,
		final NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
		final SessionFactoryImplementor factory,
		final Mapping mapping) throws HibernateException {
	super( entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory );
	// TODO: implement!!! initializing final fields to null to make compiler happy
	tableSpan = -1;
	tableNames = null;
	naturalOrderTableNames = null;
	tableKeyColumns = null;
	tableKeyColumnReaders = null;
	tableKeyColumnReaderTemplates = null;
	naturalOrderTableKeyColumns = null;
	naturalOrderTableKeyColumnReaders = null;
	naturalOrderTableKeyColumnReaderTemplates = null;
	naturalOrderCascadeDeleteEnabled = null;
	spaces = null;
	subclassClosure = null;
	subclassTableNameClosure = null;
	subclassTableKeyColumnClosure = null;
	isClassOrSuperclassTable = null;
	naturalOrderPropertyTableNumbers = null;
	propertyTableNumbers = null;
	subclassPropertyTableNumberClosure = null;
	subclassColumnTableNumberClosure = null;
	subclassFormulaTableNumberClosure = null;
	subclassTableSequentialSelect = null;
	subclassTableIsLazyClosure = null;
	discriminatorValues = null;
	notNullColumnNames = null;
	notNullColumnTableNumbers = null;
	constraintOrderedTableNames = null;
	constraintOrderedKeyColumnNames = null;
	discriminatorValue = null;
	discriminatorSQLString = null;
	discriminatorType = StandardBasicTypes.INTEGER;
	explicitDiscriminatorColumnName = null;
	discriminatorAlias = IMPLICIT_DISCRIMINATOR_ALIAS;
	coreTableSpan = -1;
	isNullableTable = null;
	subclassNamesBySubclassTable = null;
}