下面列出了怎么用org.hibernate.cache.spi.access.AccessType的API类实例代码及写法,或者点击链接到github查看源代码。
public EntityRegionAccessStrategy createEntityRegionAccessStrategy(J2CacheEntityRegion entityRegion, AccessType accessType) {
switch (accessType) {
case READ_ONLY:
if (entityRegion.getCacheDataDescription().isMutable()) {
LOG.readOnlyCacheConfiguredForMutableEntity(entityRegion.getName());
}
return new ReadOnlyJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getSettings());
case READ_WRITE:
return new ReadWriteJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getSettings());
case NONSTRICT_READ_WRITE:
return new NonStrictReadWriteJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getSettings());
case TRANSACTIONAL:
return new TransactionalJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getJ2Cache(), entityRegion.getSettings());
default:
throw new IllegalArgumentException("unrecognized access strategy type [" + accessType + "]");
}
}
public CollectionRegionAccessStrategy createCollectionRegionAccessStrategy(J2CacheCollectionRegion collectionRegion, AccessType accessType) {
switch (accessType) {
case READ_ONLY:
if (collectionRegion.getCacheDataDescription().isMutable()) {
LOG.readOnlyCacheConfiguredForMutableEntity(collectionRegion.getName());
}
return new ReadOnlyJ2CacheCollectionRegionAccessStrategy(collectionRegion, collectionRegion.getSettings());
case READ_WRITE:
return new ReadWriteJ2CacheCollectionRegionAccessStrategy(collectionRegion, collectionRegion.getSettings());
case NONSTRICT_READ_WRITE:
return new NonStrictReadWriteJ2CacheCollectionRegionAccessStrategy(collectionRegion, collectionRegion.getSettings());
case TRANSACTIONAL:
return new TransactionalJ2CacheCollectionRegionAccessStrategy(collectionRegion, collectionRegion.getJ2Cache(), collectionRegion.getSettings());
default:
throw new IllegalArgumentException("unrecognized access strategy type [" + accessType + "]");
}
}
public EntityRegionAccessStrategy createEntityRegionAccessStrategy(J2CacheEntityRegion entityRegion, AccessType accessType) {
switch (accessType) {
case READ_ONLY:
if (entityRegion.getCacheDataDescription().isMutable()) {
LOG.readOnlyCacheConfiguredForMutableEntity(entityRegion.getName());
}
return new ReadOnlyJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getSettings());
case READ_WRITE:
return new ReadWriteJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getSettings());
case NONSTRICT_READ_WRITE:
return new NonStrictReadWriteJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getSettings());
case TRANSACTIONAL:
return new TransactionalJ2CacheEntityRegionAccessStrategy(entityRegion, entityRegion.getJ2Cache(), entityRegion.getSettings());
default:
throw new IllegalArgumentException("unrecognized access strategy type [" + accessType + "]");
}
}
@Override
public NaturalIdRegionAccessStrategy createNaturalIdRegionAccessStrategy(J2CacheNaturalIdRegion naturalIdRegion, AccessType accessType) {
switch (accessType) {
case READ_ONLY:
if (naturalIdRegion.getCacheDataDescription().isMutable()) {
LOG.readOnlyCacheConfiguredForMutableEntity(naturalIdRegion.getName());
}
return new ReadOnlyJ2CacheNaturalIdRegionAccessStrategy(naturalIdRegion, naturalIdRegion.getSettings());
case READ_WRITE:
return new ReadWriteJ2CacheNaturalIdRegionAccessStrategy(naturalIdRegion, naturalIdRegion.getSettings());
case NONSTRICT_READ_WRITE:
return new NonStrictReadWriteJ2CacheNaturalIdRegionAccessStrategy(naturalIdRegion, naturalIdRegion.getSettings());
case TRANSACTIONAL:
return new TransactionalJ2CacheNaturalIdRegionAccessStrategy(naturalIdRegion, naturalIdRegion.getJ2Cache(), naturalIdRegion.getSettings());
default:
throw new IllegalArgumentException("unrecognized access strategy type [" + accessType + "]");
}
}
@Override
public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
if (accessType == AccessType.READ_ONLY) {
return new ReadOnlyNaturalIdRegionAccessStrategy(settings, this);
}
if (accessType == AccessType.READ_WRITE) {
return new ReadWriteNaturalIdRegionAccessStrategy(settings, this, mapCache);
}
if (accessType == AccessType.NONSTRICT_READ_WRITE) {
return new NonStrictReadWriteNaturalIdRegionAccessStrategy(settings, this);
}
if (accessType == AccessType.TRANSACTIONAL) {
return new TransactionalNaturalIdRegionAccessStrategy(settings, this);
}
throw new CacheException("Unsupported access strategy: " + accessType);
}
@Override
public CollectionRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
if (accessType == AccessType.READ_ONLY) {
return new ReadOnlyCollectionRegionAccessStrategy(settings, this);
}
if (accessType == AccessType.READ_WRITE) {
return new ReadWriteCollectionRegionAccessStrategy(settings, this, mapCache);
}
if (accessType == AccessType.NONSTRICT_READ_WRITE) {
return new NonStrictReadWriteCollectionRegionAccessStrategy(settings, this);
}
if (accessType == AccessType.TRANSACTIONAL) {
return new TransactionalCollectionRegionAccessStrategy(settings, this);
}
throw new CacheException("Unsupported access strategy: " + accessType);
}
@Override
public CollectionRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
if (accessType == AccessType.READ_ONLY) {
return new ReadOnlyCollectionRegionAccessStrategy(settings, this);
}
if (accessType == AccessType.READ_WRITE) {
return new ReadWriteCollectionRegionAccessStrategy(settings, this, mapCache);
}
if (accessType == AccessType.NONSTRICT_READ_WRITE) {
return new NonStrictReadWriteCollectionRegionAccessStrategy(settings, this);
}
if (accessType == AccessType.TRANSACTIONAL) {
return new TransactionalCollectionRegionAccessStrategy(settings, this);
}
throw new CacheException("Unsupported access strategy: " + accessType);
}
/**
* @param accessType Cache access typr.
* @param igniteInstanceName Name of the grid providing caches.
* @return Session factory.
*/
private SessionFactory startHibernate(AccessType accessType, String igniteInstanceName) {
Configuration cfg = hibernateConfiguration(accessType, igniteInstanceName);
ServiceRegistryBuilder builder = new ServiceRegistryBuilder();
builder.applySetting("hibernate.connection.url", CONNECTION_URL);
builder.applySetting("hibernate.show_sql", false);
return cfg.buildSessionFactory(builder.buildServiceRegistry());
}
/**
* @param accessType Cache access typr.
* @param igniteInstanceName Name of the grid providing caches.
* @return Session factory.
*/
private SessionFactory startHibernate(AccessType accessType, String igniteInstanceName) {
StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder();
builder.applySetting("hibernate.connection.url", CONNECTION_URL);
for (Map.Entry<String, String> e : HibernateL2CacheSelfTest.hibernateProperties(igniteInstanceName, accessType.name()).entrySet())
builder.applySetting(e.getKey(), e.getValue());
builder.applySetting(USE_STRUCTURED_CACHE, "true");
builder.applySetting(REGION_CACHE_PROPERTY + ENTITY1_NAME, "cache1");
builder.applySetting(REGION_CACHE_PROPERTY + ENTITY2_NAME, "cache2");
builder.applySetting(REGION_CACHE_PROPERTY + TIMESTAMP_CACHE, TIMESTAMP_CACHE);
builder.applySetting(REGION_CACHE_PROPERTY + QUERY_CACHE, QUERY_CACHE);
MetadataSources metadataSources = new MetadataSources(builder.build());
metadataSources.addAnnotatedClass(Entity1.class);
metadataSources.addAnnotatedClass(Entity2.class);
metadataSources.addAnnotatedClass(Entity3.class);
metadataSources.addAnnotatedClass(Entity4.class);
Metadata metadata = metadataSources.buildMetadata();
for (PersistentClass entityBinding : metadata.getEntityBindings()) {
if (!entityBinding.isInherited())
((RootClass)entityBinding).setCacheConcurrencyStrategy(accessType.getExternalName());
}
return metadata.buildSessionFactory();
}
/** {@inheritDoc} */
@Override protected NaturalIdDataAccess generateNaturalIdAccess(NaturalIdDataCachingConfig naturalIdAccessCfg) {
HibernateCacheProxy cache = stgyFactory.regionCache(getName());
AccessType accessType = naturalIdAccessCfg.getAccessType();
Ignite ignite = stgyFactory.node();
switch (accessType) {
case READ_ONLY:
HibernateAccessStrategyAdapter readOnlyStgy =
stgyFactory.createReadOnlyStrategy(cache);
return new IgniteNaturalIdDataAccess(readOnlyStgy, accessType, getRegionFactory(),
this, ignite, cache);
case NONSTRICT_READ_WRITE:
HibernateAccessStrategyAdapter nonStrictReadWriteStgy =
stgyFactory.createNonStrictReadWriteStrategy(cache);
return new IgniteNaturalIdDataAccess(nonStrictReadWriteStgy, accessType, getRegionFactory(),
this, ignite, cache);
case READ_WRITE:
HibernateAccessStrategyAdapter readWriteStgy =
stgyFactory.createReadWriteStrategy(cache);
return new IgniteNaturalIdDataAccess(readWriteStgy, accessType, getRegionFactory(),
this, ignite, cache);
case TRANSACTIONAL:
HibernateAccessStrategyAdapter transactionalStgy =
stgyFactory.createTransactionalStrategy(cache);
return new IgniteNaturalIdDataAccess(transactionalStgy, accessType, getRegionFactory(),
this, ignite, cache);
default:
throw new IllegalArgumentException("Unknown Hibernate access type: " + 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;
}
@SuppressWarnings("UnusedReturnValue")
public Builder addEntityConfig(PersistentClass bootEntityDescriptor, AccessType accessType) {
if ( entityConfigsByRootName == null ) {
entityConfigsByRootName = new HashMap<>();
}
// todo (5.3) : this is another place where having `BootstrapContext` / `TypeConfiguration` helps
// would allow us to delay the attempt to resolve the comparator (usual timing issues wrt Type resolution)
final NavigableRole rootEntityName = new NavigableRole( bootEntityDescriptor.getRootClass().getEntityName() );
final EntityDataCachingConfigImpl entityDataCachingConfig = entityConfigsByRootName.computeIfAbsent(
rootEntityName,
x -> new EntityDataCachingConfigImpl(
rootEntityName,
bootEntityDescriptor.isVersioned()
? (Supplier<Comparator>) () -> ( (VersionType) bootEntityDescriptor.getVersion().getType() ).getComparator()
: null,
bootEntityDescriptor.isMutable(),
accessType
)
);
if ( bootEntityDescriptor == bootEntityDescriptor.getRootClass() ) {
entityDataCachingConfig.addCachedType( rootEntityName );
}
else {
entityDataCachingConfig.addCachedType( new NavigableRole( bootEntityDescriptor.getEntityName() ) );
}
return this;
}
@Override
public CollectionRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
switch (accessType) {
case READ_ONLY:
return new ReadOnlyCollectionRegionAccessStrategy(this);
case NONSTRICT_READ_WRITE:
return new NonstrictReadWriteCollectionRegionAccessStrategy(this);
default:
throw new CacheException("Unsupported access strategy : " + accessType + ".");
}
}
/**
* Starts Hibernate.
*
* @param accessType Cache access type.
* @param igniteInstanceName Ignite instance name.
* @return Session factory.
*/
private SessionFactory startHibernate(org.hibernate.cache.spi.access.AccessType accessType, String igniteInstanceName) {
StandardServiceRegistryBuilder builder = registryBuilder();
for (Map.Entry<String, String> e : hibernateProperties(igniteInstanceName, accessType.name()).entrySet())
builder.applySetting(e.getKey(), e.getValue());
// Use the same cache for Entity and Entity2.
builder.applySetting(REGION_CACHE_PROPERTY + ENTITY2_NAME, ENTITY_NAME);
StandardServiceRegistry srvcRegistry = builder.build();
MetadataSources metadataSources = new MetadataSources(srvcRegistry);
for (Class entityClass : getAnnotatedClasses())
metadataSources.addAnnotatedClass(entityClass);
Metadata metadata = metadataSources.buildMetadata();
for (PersistentClass entityBinding : metadata.getEntityBindings()) {
if (!entityBinding.isInherited())
((RootClass)entityBinding).setCacheConcurrencyStrategy(accessType.getExternalName());
}
for (org.hibernate.mapping.Collection collectionBinding : metadata.getCollectionBindings())
collectionBinding.setCacheConcurrencyStrategy(accessType.getExternalName() );
return metadata.buildSessionFactory();
}
public EntityDataCachingConfigImpl(
NavigableRole rootEntityName,
Supplier<Comparator> versionComparatorAccess,
boolean isEntityMutable,
AccessType accessType) {
super( accessType );
this.navigableRole = rootEntityName;
this.versionComparatorAccess = versionComparatorAccess;
this.isEntityMutable = isEntityMutable;
}
/**
* Starts Hibernate.
*
* @param accessType Cache access type.
* @param igniteInstanceName Ignite instance name.
* @return Session factory.
*/
private SessionFactory startHibernate(org.hibernate.cache.spi.access.AccessType accessType, String igniteInstanceName) {
StandardServiceRegistryBuilder builder = registryBuilder();
for (Map.Entry<String, String> e : hibernateProperties(igniteInstanceName, accessType.name()).entrySet())
builder.applySetting(e.getKey(), e.getValue());
// Use the same cache for Entity and Entity2.
builder.applySetting(REGION_CACHE_PROPERTY + ENTITY2_NAME, ENTITY_NAME);
StandardServiceRegistry srvcRegistry = builder.build();
MetadataSources metadataSources = new MetadataSources(srvcRegistry);
for (Class entityClass : getAnnotatedClasses())
metadataSources.addAnnotatedClass(entityClass);
Metadata metadata = metadataSources.buildMetadata();
for (PersistentClass entityBinding : metadata.getEntityBindings()) {
if (!entityBinding.isInherited())
((RootClass) entityBinding).setCacheConcurrencyStrategy(accessType.getExternalName());
}
for (org.hibernate.mapping.Collection collectionBinding : metadata.getCollectionBindings())
collectionBinding.setCacheConcurrencyStrategy(accessType.getExternalName());
return metadata.buildSessionFactory();
}
public void overlay(CacheRegionDefinition overrides) {
if ( overrides == null ) {
return;
}
requested = TruthValue.TRUE;
accessType = AccessType.fromExternalName( overrides.getUsage() );
if ( StringHelper.isEmpty( overrides.getRegion() ) ) {
region = overrides.getRegion();
}
// ugh, primitive boolean
cacheLazyProperties = overrides.isCacheLazy();
}
public MappingDefaultsImpl(StandardServiceRegistry serviceRegistry) {
final ConfigurationService configService = serviceRegistry.getService( ConfigurationService.class );
this.implicitSchemaName = configService.getSetting(
AvailableSettings.DEFAULT_SCHEMA,
StandardConverters.STRING,
null
);
this.implicitCatalogName = configService.getSetting(
AvailableSettings.DEFAULT_CATALOG,
StandardConverters.STRING,
null
);
this.implicitlyQuoteIdentifiers = configService.getSetting(
AvailableSettings.GLOBALLY_QUOTED_IDENTIFIERS,
StandardConverters.BOOLEAN,
false
);
this.implicitCacheAccessType = configService.getSetting(
AvailableSettings.DEFAULT_CACHE_CONCURRENCY_STRATEGY,
new ConfigurationService.Converter<AccessType>() {
@Override
public AccessType convert(Object value) {
return AccessType.fromExternalName( value.toString() );
}
}
);
}
/**
* @throws Exception If failed.
*/
@Test
public void testVersionedEntity() throws Exception {
for (AccessType accessType : accessTypes())
testVersionedEntity(accessType);
}
@Override
public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
return getAccessStrategyFactory().createNaturalIdRegionAccessStrategy(this, accessType);
}
@Override
public AccessType getDefaultAccessType() {
return AccessType.TRANSACTIONAL;
}
public AccessType getDefaultAccessType() {
return AccessType.READ_WRITE;
}
/**
* @throws Exception If failed.
*/
@Test
public void testVersionedEntity() throws Exception {
for (AccessType accessType : accessTypes())
testVersionedEntity(accessType);
}
@Override
public EntityRegionAccessStrategy createEntityRegionAccessStrategy(J2CacheEntityRegion entityRegion, AccessType accessType) {
return new NonstopAwareEntityRegionAccessStrategy(actualFactory.createEntityRegionAccessStrategy(entityRegion, accessType), HibernateNonstopCacheExceptionHandler.getInstance());
}
@Override
public NaturalIdRegionAccessStrategy createNaturalIdRegionAccessStrategy(J2CacheNaturalIdRegion naturalIdRegion, AccessType accessType) {
return new NonstopAwareNaturalIdRegionAccessStrategy(actualFactory.createNaturalIdRegionAccessStrategy(naturalIdRegion, accessType), HibernateNonstopCacheExceptionHandler.getInstance());
}
@Override
public CollectionRegionAccessStrategy createCollectionRegionAccessStrategy(J2CacheCollectionRegion collectionRegion, AccessType accessType) {
return new NonstopAwareCollectionRegionAccessStrategy(actualFactory.createCollectionRegionAccessStrategy(collectionRegion, accessType), HibernateNonstopCacheExceptionHandler.getInstance());
}
@Test
public void buildAccessStrategy_AccessType_READ_ONLY() throws Exception {
assertThat(collectionMemcachedRegion.buildAccessStrategy(AccessType.READ_ONLY))
.isExactlyInstanceOf(ReadOnlyCollectionRegionAccessStrategy.class);
}
/**
* @throws Exception If failed.
*/
@Test
public void testRegionClear() throws Exception {
for (AccessType accessType : accessTypes())
testRegionClear(accessType);
}
@Override
public CollectionRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
return this.getAccessStrategyFactory().createCollectionRegionAccessStrategy(this, accessType);
}
/** {@inheritDoc} */
@Override public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
return new AccessStrategy(createAccessStrategy(accessType));
}