How to use org.hibernate.cache.cfg.spi

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 AbstractDomainDataRegion(
      DomainDataRegionConfig regionConfig,
      RegionFactory regionFactory,
      CacheKeysFactory defaultKeysFactory,
      DomainDataRegionBuildingContext buildingContext) {
//        super( regionFactory.qualify( regionConfig.getRegionName() ), regionFactory );
    super( regionConfig.getRegionName(), regionFactory );

    this.sessionFactory = buildingContext.getSessionFactory();

    if ( defaultKeysFactory == null ) {
      defaultKeysFactory = DefaultCacheKeysFactory.INSTANCE;
    }
    this.effectiveKeysFactory = buildingContext.getEnforcedCacheKeysFactory() != null
        ? buildingContext.getEnforcedCacheKeysFactory()
        : defaultKeysFactory;
  }

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();
}

@Override
protected DomainDataStorageAccess createDomainDataStorageAccess(
    DomainDataRegionConfig regionConfig,
    DomainDataRegionBuildingContext buildingContext) {
  return new JCacheAccessImpl(
      getOrCreateCache( regionConfig.getRegionName(), buildingContext.getSessionFactory() )
  );
}

@Override
protected DomainDataStorageAccess createDomainDataStorageAccess(DomainDataRegionConfig regionConfig,
    DomainDataRegionBuildingContext buildingContext) {
  String defaultKey = null;
  if (!regionConfig.getCollectionCaching().isEmpty()) {
    defaultKey = COLLECTION_DEF;
  } else if (!regionConfig.getEntityCaching().isEmpty()) {
    defaultKey = ENTITY_DEF;
  } else if (!regionConfig.getNaturalIdCaching().isEmpty()) {
    defaultKey = NATURAL_ID_DEF;
  } else {
    throw new IllegalArgumentException("Unable to determine entity cache type!");
  }
  
  RMapCache<Object, Object> mapCache = getCache(regionConfig.getRegionName(), buildingContext.getSessionFactory().getProperties(), defaultKey);
  return new RedissonStorage(mapCache, buildingContext.getSessionFactory().getProperties(), defaultKey);
}

if ( ! Objects.equals( region.getName(), regionConfig.getRegionName() ) ) {
  throw new HibernateException(
      String.format(
          region,
          getRegionFactory().getClass().getName(),
          regionConfig.getRegionName(),
          region.getName()
for ( EntityDataCachingConfig entityAccessConfig : regionConfig.getEntityCaching() ) {
  final EntityDataAccess entityDataAccess = entityAccessMap.put(
      entityAccessConfig.getNavigableRole(),
      region.getEntityDataAccess( entityAccessConfig.getNavigableRole() )
  );
if ( regionConfig.getNaturalIdCaching().isEmpty() ) {
  legacyNaturalIdAccessesForRegion.put( region.getName(), Collections.emptySet() );
  for ( NaturalIdDataCachingConfig naturalIdAccessConfig : regionConfig.getNaturalIdCaching() ) {
    final NaturalIdDataAccess naturalIdDataAccess = naturalIdAccessMap.put(
        naturalIdAccessConfig.getNavigableRole(),
        region.getNaturalIdDataAccess( naturalIdAccessConfig.getNavigableRole() )
    );
    accesses.add( naturalIdDataAccess );
for ( CollectionDataCachingConfig collectionAccessConfig : regionConfig.getCollectionCaching() ) {
  final CollectionDataAccess collectionDataAccess = collectionAccessMap.put(
      collectionAccessConfig.getNavigableRole(),
      region.getCollectionDataAccess( collectionAccessConfig.getNavigableRole() )

/**
 * Should be called at the end of the subtype's constructor, or at least after the
 * `#super(...)` (aka, this type's constructor) call.  It's a timing issue - we need access
 * to the DomainDataStorageAccess in DomainDataRegionTemplate but in methods initiated
 * (atm) from AbstractDomainDataRegion's constructor
 */
protected void completeInstantiation(
    DomainDataRegionConfig regionConfig,
    DomainDataRegionBuildingContext buildingContext) {
  log.tracef( "DomainDataRegion created [%s]; key-factory = %s", regionConfig.getRegionName(), effectiveKeysFactory );
  this.entityDataAccessMap = generateEntityDataAccessMap( regionConfig );
  this.naturalIdDataAccessMap = generateNaturalIdDataAccessMap( regionConfig );
  this.collectionDataAccessMap = generateCollectionDataAccessMap( regionConfig );
}

private Map<NavigableRole, NaturalIdDataAccess> generateNaturalIdDataAccessMap(DomainDataRegionConfig regionConfig) {
  if ( regionConfig.getNaturalIdCaching().isEmpty() ) {
    return Collections.emptyMap();
  }
  final Map<NavigableRole, NaturalIdDataAccess> accessMap = new ConcurrentHashMap<>();
  for ( NaturalIdDataCachingConfig naturalIdAccessConfig : regionConfig.getNaturalIdCaching() ) {
    accessMap.computeIfAbsent(
        naturalIdAccessConfig.getNavigableRole(),
        hierarchy -> generateNaturalIdAccess( naturalIdAccessConfig )
    );
  }
  return Collections.unmodifiableMap( accessMap );
}

private Map<NavigableRole, EntityDataAccess> generateEntityDataAccessMap(
    DomainDataRegionConfig regionConfig) {
  if ( regionConfig.getEntityCaching().isEmpty() ) {
    return Collections.emptyMap();
  }
  final Map<NavigableRole, EntityDataAccess> accessMap = new ConcurrentHashMap<>();
  for ( EntityDataCachingConfig entityAccessConfig : regionConfig.getEntityCaching() ) {
    accessMap.computeIfAbsent(
        entityAccessConfig.getNavigableRole(),
        hierarchy -> generateEntityAccess( entityAccessConfig )
    );
  }
  return Collections.unmodifiableMap( accessMap );
}

private Map<NavigableRole, CollectionDataAccess> generateCollectionDataAccessMap(
    DomainDataRegionConfig regionConfig) {
  if ( regionConfig.getCollectionCaching().isEmpty() ) {
    return Collections.emptyMap();
  }
  final Map<NavigableRole, CollectionDataAccess> accessMap = new ConcurrentHashMap<>();
  for ( CollectionDataCachingConfig cachingConfig : regionConfig.getCollectionCaching() ) {
    accessMap.computeIfAbsent(
        cachingConfig.getNavigableRole(),
        hierarchy -> generateCollectionAccess( cachingConfig )
    );
  }
  return Collections.unmodifiableMap( accessMap );
}

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

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

@Override
public CollectionDataAccess generateCollectionAccess(CollectionDataCachingConfig accessConfig) {
  final NavigableRole namedCollectionRole = accessConfig.getNavigableRole();
  log.debugf( "Generating collection cache access : %s", namedCollectionRole );
  switch ( accessConfig.getAccessType() ) {
    case READ_ONLY: {
      return generateReadOnlyCollectionAccess( accessConfig );
    }
    case READ_WRITE: {
      return generateReadWriteCollectionAccess( accessConfig );
    }
    case NONSTRICT_READ_WRITE: {
      return generateNonStrictReadWriteCollectionAccess( accessConfig );
    }
    case TRANSACTIONAL: {
      return generateTransactionalCollectionDataAccess( accessConfig );
    }
    default: {
      throw new IllegalArgumentException( "Unrecognized cache AccessType - " + accessConfig.getAccessType() );
    }
  }
}

@Override
public NaturalIdDataAccess generateNaturalIdAccess(NaturalIdDataCachingConfig accessConfig) {
  final NavigableRole namedEntityRole = accessConfig.getNavigableRole();
  final AccessType accessType = accessConfig.getAccessType();
  log.debugf( "Generating entity natural-id access [%s] : %s", accessType.getExternalName(), namedEntityRole );
  switch ( accessType ) {
    case READ_ONLY: {
      return generateReadOnlyNaturalIdAccess( accessConfig );
    }
    case READ_WRITE: {
      return generateReadWriteNaturalIdAccess( accessConfig );
    }
    case NONSTRICT_READ_WRITE: {
      return generateNonStrictReadWriteNaturalIdAccess( accessConfig );
    }
    case TRANSACTIONAL: {
      return generateTransactionalNaturalIdDataAccess( accessConfig );
    }
    default: {
      throw new IllegalArgumentException( "Unrecognized cache AccessType - " + accessType );
    }
  }
}

@Override
public EntityDataAccess generateEntityAccess(EntityDataCachingConfig entityAccessConfig) {
  final NavigableRole namedEntityRole = entityAccessConfig.getNavigableRole();
  final AccessType accessType = entityAccessConfig.getAccessType();
  log.debugf( "Generating entity cache access [%s] : %s", accessType.getExternalName(), namedEntityRole );
  switch ( accessType ) {
    case READ_ONLY: {
      return generateReadOnlyEntityAccess( entityAccessConfig );
    }
    case READ_WRITE: {
      return generateReadWriteEntityAccess( entityAccessConfig );
    }
    case NONSTRICT_READ_WRITE: {
      return generateNonStrictReadWriteEntityAccess( entityAccessConfig );
    }
    case TRANSACTIONAL: {
      return generateTransactionalEntityDataAccess( entityAccessConfig );
    }
    default: {
      throw new IllegalArgumentException( "Unrecognized cache AccessType - " + accessType );
    }
  }
}

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

@Override
protected DomainDataStorageAccess createDomainDataStorageAccess(
    DomainDataRegionConfig regionConfig,
    DomainDataRegionBuildingContext buildingContext) {
  return new StorageAccessImpl(
      getOrCreateCache( regionConfig.getRegionName(), buildingContext.getSessionFactory() )
  );
}

  public AbstractDomainDataRegion(
      DomainDataRegionConfig regionConfig,
      RegionFactory regionFactory,
      CacheKeysFactory defaultKeysFactory,
      DomainDataRegionBuildingContext buildingContext) {
//        super( regionFactory.qualify( regionConfig.getRegionName() ), regionFactory );
    super( regionConfig.getRegionName(), regionFactory );

    this.sessionFactory = buildingContext.getSessionFactory();

    if ( defaultKeysFactory == null ) {
      defaultKeysFactory = DefaultCacheKeysFactory.INSTANCE;
    }
    this.effectiveKeysFactory = buildingContext.getEnforcedCacheKeysFactory() != null
        ? buildingContext.getEnforcedCacheKeysFactory()
        : defaultKeysFactory;
  }

@Override
protected DomainDataStorageAccess createDomainDataStorageAccess(DomainDataRegionConfig regionConfig,
    DomainDataRegionBuildingContext buildingContext) {
  return new RedisDomainDataStorageAccessImpl(redisClient,
      getOrCreateCache(regionConfig.getRegionName(), buildingContext.getSessionFactory()));
}

@Override
protected DomainDataStorageAccess createDomainDataStorageAccess(DomainDataRegionConfig regionConfig,
    DomainDataRegionBuildingContext buildingContext) {
  return new RedisDomainDataStorageAccessImpl(redisClient,
      getOrCreateCache(regionConfig.getRegionName(), buildingContext.getSessionFactory()));
}