Java 类org.hibernate.cache.spi.CacheDataDescription 实例源码

/**
 * @param name              the name for this region cache, which is also used to retrieve configuration/topic
 * @param hazelcastInstance the {@code HazelcastInstance} to which this region cache belongs, used to retrieve
 *                          configuration and to lookup an {@link ITopic} to register a {@link MessageListener}
 *                          with if {@code withTopic} is {@code true} (optional)
 * @param metadata          metadata describing the cached data, used to compare data versions (optional)
 * @param withTopic         {@code true} to register a {@link MessageListener} with the {@link ITopic} whose name
 *                          matches this region cache <i>if</i> a {@code HazelcastInstance} was provided to look
 *                          up the topic; otherwise, {@code false} not to register a listener even if an instance
 *                          was provided
 */
public LocalRegionCache(final String name, final HazelcastInstance hazelcastInstance,
                        final CacheDataDescription metadata, final boolean withTopic) {
    this.hazelcastInstance = hazelcastInstance;
    try {
        config = hazelcastInstance != null ? hazelcastInstance.getConfig().findMapConfig(name) : null;
    } catch (UnsupportedOperationException ignored) {
        EmptyStatement.ignore(ignored);
    }
    versionComparator = metadata != null && metadata.isVersioned() ? metadata.getVersionComparator() : null;
    cache = new ConcurrentHashMap<Object, Expirable>();
    markerIdCounter = new AtomicLong();

    messageListener = createMessageListener();
    if (withTopic && hazelcastInstance != null) {
        topic = hazelcastInstance.getTopic(name);
        topic.addMessageListener(messageListener);
    } else {
        topic = null;
    }
}

/**
 * @param name              the name for this region cache, which is also used to retrieve configuration/topic
 * @param hazelcastInstance the {@code HazelcastInstance} to which this region cache belongs, used to retrieve
 *                          configuration and to lookup an {@link ITopic} to register a {@link MessageListener}
 *                          with if {@code withTopic} is {@code true} (optional)
 * @param metadata          metadata describing the cached data, used to compare data versions (optional)
 * @param withTopic         {@code true} to register a {@link MessageListener} with the {@link ITopic} whose name
 *                          matches this region cache <i>if</i> a {@code HazelcastInstance} was provided to look
 *                          up the topic; otherwise, {@code false} not to register a listener even if an instance
 *                          was provided
 * @since 3.3
 */
public LocalRegionCache(final String name, final HazelcastInstance hazelcastInstance,
                        final CacheDataDescription metadata, final boolean withTopic) {
    this.hazelcastInstance = hazelcastInstance;
    try {
        config = hazelcastInstance != null ? hazelcastInstance.getConfig().findMapConfig(name) : null;
    } catch (UnsupportedOperationException ignored) {
        EmptyStatement.ignore(ignored);
    }
    versionComparator = metadata != null && metadata.isVersioned() ? metadata.getVersionComparator() : null;
    cache = new ConcurrentHashMap<Object, Expirable>();
    markerIdCounter = new AtomicLong();

    messageListener = createMessageListener();
    if (withTopic && hazelcastInstance != null) {
        topic = hazelcastInstance.getTopic(name);
        topic.addMessageListener(messageListener);
    } else {
        topic = null;
    }
}

protected AbstractTransactionalDataRegion(final HazelcastInstance instance, final String regionName,
                                          final Properties props, final CacheDataDescription metadata,
                                          final Cache cache) {
    super(instance, regionName, props);
    this.metadata = metadata;
    this.cache = cache;
}

public IMapRegionCache(final String name, final HazelcastInstance hazelcastInstance,
                       final Properties props, final CacheDataDescription metadata) {
    this.name = name;
    this.hazelcastInstance = hazelcastInstance;
    this.versionComparator = metadata != null && metadata.isVersioned() ? metadata.getVersionComparator() : null;
    this.map = hazelcastInstance.getMap(this.name);
    lockTimeout = CacheEnvironment.getLockTimeoutInMillis(props);
    final long maxOperationTimeout = HazelcastTimestamper.getMaxOperationTimeout(hazelcastInstance);
    tryLockAndGetTimeout = Math.min(maxOperationTimeout, COMPARISON_VALUE);
    markerIdCounter = new AtomicLong();
}

@Override
public CollectionRegion buildCollectionRegion(final String regionName, final Properties properties,
                                              final CacheDataDescription metadata) throws CacheException {
    final HazelcastCollectionRegion<LocalRegionCache> region = new HazelcastCollectionRegion<LocalRegionCache>(instance,
            regionName, properties, metadata, new LocalRegionCache(regionName, instance, metadata));
    cleanupService.registerCache(region.getCache());
    return region;
}

@Override
public EntityRegion buildEntityRegion(final String regionName, final Properties properties,
                                      final CacheDataDescription metadata) throws CacheException {
    final HazelcastEntityRegion<LocalRegionCache> region = new HazelcastEntityRegion<LocalRegionCache>(instance,
            regionName, properties, metadata, new LocalRegionCache(regionName, instance, metadata));
    cleanupService.registerCache(region.getCache());
    return region;
}

@Override
public NaturalIdRegion buildNaturalIdRegion(final String regionName, final Properties properties,
                                            final CacheDataDescription metadata) throws CacheException {
    final HazelcastNaturalIdRegion<LocalRegionCache> region = new HazelcastNaturalIdRegion<LocalRegionCache>(
            instance, regionName, properties, metadata, new LocalRegionCache(regionName, instance, metadata));
    cleanupService.registerCache(region.getCache());

    return region;
}

@Test
public void testConstructorIgnoresVersionComparatorForUnversionedData() {
    CacheDataDescription description = mock(CacheDataDescription.class);
    doThrow(AssertionError.class).when(description).getVersionComparator(); // Will fail the test if called

    new LocalRegionCache(CACHE_NAME, null, description);
    verify(description).isVersioned(); // Verify that the versioned flag was checked
    verifyNoMoreInteractions(description);
}

@Test
public void testConstructorSetsVersionComparatorForVersionedData() {
    Comparator<?> comparator = mock(Comparator.class);

    CacheDataDescription description = mock(CacheDataDescription.class);
    when(description.getVersionComparator()).thenReturn(comparator);
    when(description.isVersioned()).thenReturn(true);

    new LocalRegionCache(CACHE_NAME, null, description);
    verify(description).getVersionComparator();
    verify(description).isVersioned();
}

public IMapRegionCache(final String name, final HazelcastInstance hazelcastInstance,
                       final Properties props, final CacheDataDescription metadata) {
    this.name = name;
    this.hazelcastInstance = hazelcastInstance;
    this.versionComparator = metadata != null && metadata.isVersioned() ? metadata.getVersionComparator() : null;
    this.map = hazelcastInstance.getMap(this.name);
    lockTimeout = CacheEnvironment.getLockTimeoutInMillis(props);
    final long maxOperationTimeout = HazelcastTimestamper.getMaxOperationTimeout(hazelcastInstance);
    tryLockAndGetTimeout = Math.min(maxOperationTimeout, COMPARISON_VALUE);
    markerIdCounter = new AtomicLong();
}

public CollectionRegion buildCollectionRegion(final String regionName, final Properties properties,
                                              final CacheDataDescription metadata) throws CacheException {
    final HazelcastCollectionRegion<LocalRegionCache> region = new HazelcastCollectionRegion<LocalRegionCache>(instance,
            regionName, properties, metadata, new LocalRegionCache(regionName, instance, metadata));
    cleanupService.registerCache(region.getCache());
    return region;
}

public EntityRegion buildEntityRegion(final String regionName, final Properties properties,
                                      final CacheDataDescription metadata) throws CacheException {
    final HazelcastEntityRegion<LocalRegionCache> region = new HazelcastEntityRegion<LocalRegionCache>(instance,
            regionName, properties, metadata, new LocalRegionCache(regionName, instance, metadata));
    cleanupService.registerCache(region.getCache());
    return region;
}

public NaturalIdRegion buildNaturalIdRegion(final String regionName, final Properties properties,
                                            final CacheDataDescription metadata) throws CacheException {
    final HazelcastNaturalIdRegion<LocalRegionCache> region = new HazelcastNaturalIdRegion<LocalRegionCache>(
            instance, regionName, properties, metadata, new LocalRegionCache(regionName, instance, metadata));
    cleanupService.registerCache(region.getCache());
    return region;
}

@Test
public void testConstructorIgnoresVersionComparatorForUnversionedData() {
    CacheDataDescription description = mock(CacheDataDescription.class);
    doThrow(AssertionError.class).when(description).getVersionComparator(); // Will fail the test if called

    new LocalRegionCache(CACHE_NAME, null, description);
    verify(description).isVersioned(); // Verify that the versioned flag was checked
    verifyNoMoreInteractions(description);
}

@Test
public void testConstructorSetsVersionComparatorForVersionedData() {
    Comparator<?> comparator = mock(Comparator.class);

    CacheDataDescription description = mock(CacheDataDescription.class);
    when(description.getVersionComparator()).thenReturn(comparator);
    when(description.isVersioned()).thenReturn(true);

    new LocalRegionCache(CACHE_NAME, null, description);
    verify(description).getVersionComparator();
    verify(description).isVersioned();
}

/** {@inheritDoc} */
@Override public EntityRegion buildEntityRegion(String regionName, Properties props, CacheDataDescription metadata)
    throws CacheException {
    return new HibernateEntityRegion(this,
        regionName,
        accessStgyFactory.node(),
        accessStgyFactory.regionCache(regionName),
        metadata);
}

/** {@inheritDoc} */
@Override public NaturalIdRegion buildNaturalIdRegion(String regionName, Properties props,
                                                      CacheDataDescription metadata) throws CacheException {
    return new HibernateNaturalIdRegion(this,
        regionName,
        accessStgyFactory.node(),
        accessStgyFactory.regionCache(regionName),
        metadata);
}

/** {@inheritDoc} */
@Override public CollectionRegion buildCollectionRegion(String regionName, Properties props,
                                                        CacheDataDescription metadata) throws CacheException {
    return new HibernateCollectionRegion(this,
        regionName,
        accessStgyFactory.node(),
        accessStgyFactory.regionCache(regionName),
        metadata);
}

/**
 * @param factory Region factory.
 * @param name Region name.
 * @param ignite Grid.
 * @param cache Region cache,
 * @param dataDesc Region data description.
 */
HibernateNaturalIdRegion(HibernateRegionFactory factory,
    String name,
    Ignite ignite,
    HibernateCacheProxy cache,
    CacheDataDescription dataDesc) {
    super(factory, name, ignite, cache, dataDesc);
}

/** {@inheritDoc} */
@Override public EntityRegion buildEntityRegion(String regionName, Properties props, CacheDataDescription metadata)
    throws CacheException {
    return new HibernateEntityRegion(this,
        regionName,
        accessStgyFactory.node(),
        accessStgyFactory.regionCache(regionName),
        metadata);
}

/** {@inheritDoc} */
@Override public NaturalIdRegion buildNaturalIdRegion(String regionName, Properties props,
    CacheDataDescription metadata) throws CacheException {
    return new HibernateNaturalIdRegion(this,
        regionName,
        accessStgyFactory.node(),
        accessStgyFactory.regionCache(regionName),
        metadata);
}

/** {@inheritDoc} */
@Override public CollectionRegion buildCollectionRegion(String regionName, Properties props,
    CacheDataDescription metadata) throws CacheException {
    return new HibernateCollectionRegion(this,
        regionName,
        accessStgyFactory.node(),
        accessStgyFactory.regionCache(regionName),
        metadata);
}

@Override
public NaturalIdRegion buildNaturalIdRegion(String regionName,
        Properties properties, CacheDataDescription metadata)
        throws CacheException {
    // TODO Auto-generated method stub
    return null;
}

public MemcachedRegion(CacheNamespace cacheNamespace, OverridableReadOnlyProperties properties, CacheDataDescription metadata, Settings settings,
                       MemcachedAdapter memcachedAdapter, HibernateCacheTimestamper hibernateCacheTimestamper) {
    this.cacheNamespace = cacheNamespace;
    this.properties = properties;
    this.metadata = metadata;
    this.settings = settings;
    this.memcachedAdapter = memcachedAdapter;
    this.hibernateCacheTimestamper = hibernateCacheTimestamper;
}

public NaturalIdMemcachedRegion(String regionName, OverridableReadOnlyProperties properties,
                                CacheDataDescription metadata, Settings settings,
                                MemcachedAdapter memcachedAdapter,
                                HibernateCacheTimestamper hibernateCacheTimestamper) {
    super(new CacheNamespace(regionName, true), properties, metadata, settings, memcachedAdapter,
          hibernateCacheTimestamper);
}

public RefineKeyOverridedGeneralDataMemcachedRegion(CacheNamespace cacheNamespace,
                                                    OverridableReadOnlyProperties properties,
                                                    CacheDataDescription metadata, Settings settings,
                                                    MemcachedAdapter memcachedAdapter,
                                                    HibernateCacheTimestamper hibernateCacheTimestamper) {
    super(cacheNamespace, properties, metadata, settings, memcachedAdapter, hibernateCacheTimestamper);
}

@Override
public EntityRegion buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)
        throws CacheException {
    throw new NoCacheRegionFactoryAvailableException();
}

@Override
public NaturalIdRegion buildNaturalIdRegion(String regionName, Properties properties, CacheDataDescription metadata)
        throws CacheException {
    throw new NoCacheRegionFactoryAvailableException();
}

@Override
public CollectionRegion buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)
        throws CacheException {
    throw new NoCacheRegionFactoryAvailableException();
}

@Override
protected Cache<Object, Object> createCache(String regionName, Properties properties, CacheDataDescription metadata) {
    throw new IllegalArgumentException("Unknown hibernate cache: " + regionName);
}

@Override
public CollectionRegion buildCollectionRegion(final String regionName, final Properties properties,
                                              final CacheDataDescription metadata) throws CacheException {
    return new HazelcastCollectionRegion<IMapRegionCache>(instance, regionName, properties, metadata,
            new IMapRegionCache(regionName, instance, properties, metadata));
}

@Override
public EntityRegion buildEntityRegion(final String regionName, final Properties properties,
                                      final CacheDataDescription metadata) throws CacheException {
    return new HazelcastEntityRegion<IMapRegionCache>(instance, regionName, properties, metadata,
            new IMapRegionCache(regionName, instance, properties, metadata));
}

@Override
public NaturalIdRegion buildNaturalIdRegion(final String regionName, final Properties properties,
                                            final CacheDataDescription metadata) throws CacheException {
    return new HazelcastNaturalIdRegion<IMapRegionCache>(instance, regionName, properties, metadata,
            new IMapRegionCache(regionName, instance, properties, metadata));
}

@Override
public CacheDataDescription getCacheDataDescription() {
    return metadata;
}

public HazelcastEntityRegion(final HazelcastInstance instance,
                             final String regionName, final Properties props,
                             final CacheDataDescription metadata, final Cache cache) {
    super(instance, regionName, props, metadata, cache);
}

public HazelcastCollectionRegion(final HazelcastInstance instance,
                                 final String regionName, final Properties props,
                                 final CacheDataDescription metadata, final Cache cache) {
    super(instance, regionName, props, metadata, cache);
}

@Override
protected Cache<Object, Object> createCache(String regionName, Properties properties, CacheDataDescription
    metadata) {
    throw new IllegalStateException(EXCEPTION_MESSAGE + " " + regionName);
}

public CollectionRegion buildCollectionRegion(final String regionName, final Properties properties,
                                              final CacheDataDescription metadata) throws CacheException {
    return new HazelcastCollectionRegion<IMapRegionCache>(instance, regionName, properties, metadata,
            new IMapRegionCache(regionName, instance, properties, metadata));
}

public EntityRegion buildEntityRegion(final String regionName, final Properties properties,
                                      final CacheDataDescription metadata) throws CacheException {
    return new HazelcastEntityRegion<IMapRegionCache>(instance, regionName, properties, metadata,
            new IMapRegionCache(regionName, instance, properties, metadata));
}

public NaturalIdRegion buildNaturalIdRegion(final String regionName, final Properties properties,
                                            final CacheDataDescription metadata) throws CacheException {
    return new HazelcastNaturalIdRegion<IMapRegionCache>(instance, regionName, properties, metadata,
            new IMapRegionCache(regionName, instance, properties, metadata));
}