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