org.hibernate.cache.spi.CacheKeysFactory#org.hibernate.cache.spi.DomainDataRegion源码实例Demo

@Override
public long getElementCountInMemory() {
	long count = 0;
	HashSet<Region> processedRegions = null;

	for ( NaturalIdDataAccess accessStrategy : accessStrategies ) {
		final DomainDataRegion region = accessStrategy.getRegion();
		if ( ExtendedStatisticsSupport.class.isInstance( region ) ) {

		}

		if ( region instanceof ExtendedStatisticsSupport ) {
			if ( processedRegions == null ) {
				processedRegions = new HashSet<>();
			}
			if ( processedRegions.add( region ) ) {
				count += ( (ExtendedStatisticsSupport) region ).getElementCountInMemory();
			}
		}

	}

	if ( count == 0 ) {
		return NO_EXTENDED_STAT_SUPPORT_RETURN;
	}

	return count;
}
 

@Override
public long getElementCountOnDisk() {
	long count = 0;
	HashSet<Region> processedRegions = null;

	for ( NaturalIdDataAccess accessStrategy : accessStrategies ) {
		final DomainDataRegion region = accessStrategy.getRegion();
		if ( ExtendedStatisticsSupport.class.isInstance( region ) ) {

		}

		if ( region instanceof ExtendedStatisticsSupport ) {
			if ( processedRegions == null ) {
				processedRegions = new HashSet<>();
			}
			if ( processedRegions.add( region ) ) {
				count += ( (ExtendedStatisticsSupport) region ).getElementCountOnDisk();
			}
		}

	}

	if ( count == 0 ) {
		return NO_EXTENDED_STAT_SUPPORT_RETURN;
	}

	return count;
}
 

@Override
public long getSizeInMemory() {
	long count = 0;
	HashSet<Region> processedRegions = null;

	for ( NaturalIdDataAccess accessStrategy : accessStrategies ) {
		final DomainDataRegion region = accessStrategy.getRegion();
		if ( ExtendedStatisticsSupport.class.isInstance( region ) ) {

		}

		if ( region instanceof ExtendedStatisticsSupport ) {
			if ( processedRegions == null ) {
				processedRegions = new HashSet<>();
			}
			if ( processedRegions.add( region ) ) {
				count += ( (ExtendedStatisticsSupport) region ).getElementCountOnDisk();
			}
		}

	}

	if ( count == 0 ) {
		return NO_EXTENDED_STAT_SUPPORT_RETURN;
	}

	return count;
}
 

public NaturalIdTransactionalAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		NaturalIdDataCachingConfig config) {
	super( region, keysFactory, storageAccess, config );
}
 

public CollectionNonStrictReadWriteAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		CollectionDataCachingConfig config) {
	super( region, keysFactory, storageAccess, config );
}
 

public AbstractEntityDataAccess(
		DomainDataRegion region,
		CacheKeysFactory cacheKeysFactory,
		DomainDataStorageAccess storageAccess) {
	super( region, storageAccess );
	this.cacheKeysFactory = cacheKeysFactory;
}
 

public NaturalIdReadWriteAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		NaturalIdDataCachingConfig naturalIdDataCachingConfig) {
	super( region, storageAccess );
	this.keysFactory = keysFactory;
}
 

public EntityTransactionalAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		EntityDataCachingConfig accessConfig) {
	super( region, keysFactory, storageAccess );
}
 

public CollectionReadOnlyAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		CollectionDataCachingConfig config) {
	super( region, keysFactory, storageAccess, config );
}
 

public NaturalIdReadOnlyAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		NaturalIdDataCachingConfig config) {
	super( region, keysFactory, storageAccess, config );
	if ( config.isMutable() ) {
		SecondLevelCacheLogger.INSTANCE.readOnlyCachingMutableNaturalId( config.getNavigableRole() );
	}
}
 

public EntityReadWriteAccess(
		DomainDataRegion domainDataRegion,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		EntityDataCachingConfig entityAccessConfig) {
	super( domainDataRegion, storageAccess );
	this.keysFactory = keysFactory;
	this.versionComparator = entityAccessConfig.getVersionComparatorAccess() == null
			? null
			: entityAccessConfig.getVersionComparatorAccess().get();
}
 

public AbstractNaturalIdDataAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		NaturalIdDataCachingConfig config) {
	super( region, storageAccess );
	this.keysFactory = keysFactory;
}
 

public EntityReadOnlyAccess(
		DomainDataRegion region,
		CacheKeysFactory cacheKeysFactory,
		DomainDataStorageAccess storageAccess,
		EntityDataCachingConfig config) {
	super( region, cacheKeysFactory, storageAccess );
	if ( config.isMutable() ) {
		SecondLevelCacheLogger.INSTANCE.readOnlyCachingMutableEntity( config.getNavigableRole() );
	}
}
 

public CollectionReadWriteAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		CollectionDataCachingConfig config) {
	super( region, storageAccess );
	this.keysFactory = keysFactory;
	this.collectionRole = config.getNavigableRole();
	this.versionComparator = config.getOwnerVersionComparator();
}
 

public AbstractCollectionDataAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		CollectionDataCachingConfig config) {
	super( region, storageAccess );
	this.keysFactory = keysFactory;
}
 

public NaturalIdNonStrictReadWriteAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		NaturalIdDataCachingConfig config) {
	super( region, keysFactory, storageAccess, config );
}
 

public EntityNonStrictReadWriteAccess(
		DomainDataRegion domainDataRegion,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		EntityDataCachingConfig entityAccessConfig) {
	super( domainDataRegion, keysFactory, storageAccess );
}
 

@Override
public DomainDataRegion buildDomainDataRegion(
		DomainDataRegionConfig regionConfig,
		DomainDataRegionBuildingContext buildingContext) {
	verifyStarted();
	return new DomainDataRegionTemplate(
			regionConfig,
			this,
			createDomainDataStorageAccess( regionConfig, buildingContext ),
			getImplicitCacheKeysFactory(),
			buildingContext
	);
}
 

public CollectionTransactionAccess(
		DomainDataRegion region,
		CacheKeysFactory keysFactory,
		DomainDataStorageAccess storageAccess,
		CollectionDataCachingConfig config) {
	super( region, keysFactory, storageAccess, config );
}
 

/** */
public IgniteEntityDataAccess(
    HibernateAccessStrategyAdapter stgy,
    AccessType accessType,
    RegionFactory regionFactory,
    DomainDataRegion domainDataRegion,
    Ignite ignite,
    HibernateCacheProxy cache
) {
    super(stgy, regionFactory, domainDataRegion, ignite, cache);

    this.accessType = accessType;
}
 

/**
 * @param stgy Access strategy implementation.
 */
protected IgniteCachedDomainDataAccess(HibernateAccessStrategyAdapter stgy,
    RegionFactory regionFactory,
    DomainDataRegion domainDataRegion,
    Ignite ignite, HibernateCacheProxy cache) {
    super(regionFactory, cache.name(), ignite, cache);

    this.stgy = stgy;
    this.domainDataRegion = domainDataRegion;
}
 

/** {@inheritDoc} */
@Override public DomainDataRegion buildDomainDataRegion(
    DomainDataRegionConfig regionCfg,
    DomainDataRegionBuildingContext buildingCtx) {
    return new IgniteDomainDataRegion(regionCfg, this, null, buildingCtx,
        accessStgyFactory);
}
 

/** */
public IgniteNaturalIdDataAccess(
    HibernateAccessStrategyAdapter stgy,
    AccessType accessType,
    RegionFactory regionFactory,
    DomainDataRegion domainDataRegion,
    Ignite ignite,
    HibernateCacheProxy cache
) {
    super(stgy, regionFactory, domainDataRegion, ignite, cache);

    this.accessType = accessType;
}
 

/**
 * @param stgy Access strategy implementation.
 * @param accessType Strategy access type.
 * @param regionFactory Region factory.
 * @param domainDataRegion Data region.
 * @param ignite Ignite instance.
 * @param cache Cache proxy.
 */
public IgniteCollectionDataAccess(
    HibernateAccessStrategyAdapter stgy,
    AccessType accessType,
    RegionFactory regionFactory,
    DomainDataRegion domainDataRegion,
    Ignite ignite,
    HibernateCacheProxy cache
) {
    super(stgy, regionFactory, domainDataRegion, ignite, cache);

    this.accessType = accessType;
}
 

private net.sf.ehcache.Cache getCache(Class clazz) throws IllegalAccessException {
    EntityPersister entityPersister = ((SessionFactoryImplementor) sessionFactory()).getEntityPersister(clazz.getName() );
    DomainDataRegion region = entityPersister.getCacheAccessStrategy().getRegion();
    Field storageAccessField = getField(region.getClass(), "storageAccess");
    StorageAccess storageAccess = (StorageAccess) storageAccessField.get(region);
    Field cacheField = getField(storageAccess.getClass(), "cache");
    return  (net.sf.ehcache.Cache) cacheField.get(storageAccess);
}
 

@Override
public DomainDataRegion buildDomainDataRegion(
        DomainDataRegionConfig regionConfig,
        DomainDataRegionBuildingContext buildingContext) {
    verifyStarted();
    return new DomainDataRegionImpl(
            regionConfig,
            this,
            createDomainDataStorageAccess( regionConfig, buildingContext ),
            getImplicitCacheKeysFactory(),
            buildingContext
    );
}
 

protected AbstractReadWriteAccess(
		DomainDataRegion domainDataRegion,
		DomainDataStorageAccess storageAccess) {
	super( domainDataRegion, storageAccess );
}
 

protected AbstractCachedDomainDataAccess(
		DomainDataRegion region,
		DomainDataStorageAccess storageAccess) {
	this.region = region;
	this.storageAccess = storageAccess;
}
 

@Override
public DomainDataRegion getRegion() {
	return region;
}
 

@Override
public void prime(Set<DomainDataRegionConfig> cacheRegionConfigs) {
	for ( DomainDataRegionConfig regionConfig : cacheRegionConfigs ) {
		final DomainDataRegion region = getRegionFactory().buildDomainDataRegion( regionConfig, this );
		regionsByName.put( region.getName(), region );

		if ( ! Objects.equals( region.getName(), regionConfig.getRegionName() ) ) {
			throw new HibernateException(
					String.format(
							Locale.ROOT,
							"Region [%s] returned from RegionFactory [%s] was named differently than requested name.  Expecting `%s`, but found `%s`",
							region,
							getRegionFactory().getClass().getName(),
							regionConfig.getRegionName(),
							region.getName()
					)
			);
		}

		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// Entity caching

		for ( EntityDataCachingConfig entityAccessConfig : regionConfig.getEntityCaching() ) {
			final EntityDataAccess entityDataAccess = entityAccessMap.put(
					entityAccessConfig.getNavigableRole(),
					region.getEntityDataAccess( entityAccessConfig.getNavigableRole() )
			);

			legacySecondLevelCacheNames.add(
					StringHelper.qualifyConditionally(
							getSessionFactory().getSessionFactoryOptions().getCacheRegionPrefix(),
							region.getName()
					)
			);
		}


		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// Natural-id caching

		if ( regionConfig.getNaturalIdCaching().isEmpty() ) {
			legacyNaturalIdAccessesForRegion.put( region.getName(), Collections.emptySet() );
		}
		else {
			final HashSet<NaturalIdDataAccess> accesses = new HashSet<>();

			for ( NaturalIdDataCachingConfig naturalIdAccessConfig : regionConfig.getNaturalIdCaching() ) {
				final NaturalIdDataAccess naturalIdDataAccess = naturalIdAccessMap.put(
						naturalIdAccessConfig.getNavigableRole(),
						region.getNaturalIdDataAccess( naturalIdAccessConfig.getNavigableRole() )
				);
				accesses.add( naturalIdDataAccess );
			}

			legacyNaturalIdAccessesForRegion.put( region.getName(), accesses );
		}


		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// Collection caching

		for ( CollectionDataCachingConfig collectionAccessConfig : regionConfig.getCollectionCaching() ) {
			final CollectionDataAccess collectionDataAccess = collectionAccessMap.put(
					collectionAccessConfig.getNavigableRole(),
					region.getCollectionDataAccess( collectionAccessConfig.getNavigableRole() )
			);

			legacySecondLevelCacheNames.add(
					StringHelper.qualifyConditionally(
							getSessionFactory().getSessionFactoryOptions().getCacheRegionPrefix(),
							region.getName()
					)
			);
		}
	}

}