Java Cache.createRegionFactory方法代码示例

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private void createPartitionedRegion(String regionName) {
 
  final Cache cache = getCache();
  // Create the data region
  RegionFactory<String, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.PARTITION);
  dataRegionFactory.setConcurrencyLevel(4);
  EvictionAttributes ea = EvictionAttributes.createLIFOEntryAttributes(100, EvictionAction.LOCAL_DESTROY);
  dataRegionFactory.setEvictionAttributes(ea);
  dataRegionFactory.setEnableAsyncConflation(true);
  
  FixedPartitionAttributes fpa = FixedPartitionAttributes.createFixedPartition("Par1", true);
  PartitionAttributes pa = new PartitionAttributesFactory()
                                  .setLocalMaxMemory(100)
                                  .setRecoveryDelay(2)
                                  .setTotalMaxMemory(200)
                                  .setRedundantCopies(1)
                                  .addFixedPartitionAttributes(fpa)
                                  .create();
  dataRegionFactory.setPartitionAttributes(pa);
  dataRegionFactory.addCacheListener(new CacheListener1());
  dataRegionFactory.addCacheListener(new CacheListener2());
  dataRegionFactory.create(regionName);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private void createPartitionedRegion(String regionName) {
  final Cache cache = getCache();
  // Create the data region
  RegionFactory<String, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.PARTITION);
  dataRegionFactory.setConcurrencyLevel(4);
  EvictionAttributes ea = EvictionAttributes.createLIFOEntryAttributes(100, EvictionAction.LOCAL_DESTROY);
  dataRegionFactory.setEvictionAttributes(ea);
  dataRegionFactory.setEnableAsyncConflation(true);
  
  FixedPartitionAttributes fpa = FixedPartitionAttributes.createFixedPartition("Par1", true);
  PartitionAttributes pa = new PartitionAttributesFactory()
                                  .setLocalMaxMemory(100)
                                  .setRecoveryDelay(2)
                                  .setTotalMaxMemory(200)
                                  .setRedundantCopies(1)
                                  .addFixedPartitionAttributes(fpa)
                                  .create();
  dataRegionFactory.setPartitionAttributes(pa);
  
  dataRegionFactory.create(regionName);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
public void testAsyncIndexUpdaterThreadShutdownForPR() {
  Cache cache = new CacheFactory().create();

  RegionFactory rf = cache.createRegionFactory(RegionShortcut.PARTITION);
  rf.setIndexMaintenanceSynchronous(false);
  Region localRegion = rf.create(name);
  
  assertNotNull("Region ref null", localRegion);
  
  try {
    cache.getQueryService().createIndex("idIndex", "ID", "/"+name);
  } catch (Exception e) {
    cache.close();
    e.printStackTrace();
    fail("Index creation failed");
  }
  
  for (int i=0; i<500; i++) {
    localRegion.put(i, new Portfolio(i));
  }

  GemFireCacheImpl internalCache = (GemFireCacheImpl)cache;
  // Don't disconnect distributed system yet to keep system thread groups alive.
  internalCache.close("Normal disconnect", null, false, false);

  // Get Asynchronous index updater thread group from Distributed System.
  ThreadGroup indexUpdaterThreadGroup = LogWriterImpl.getThreadGroup("QueryMonitor Thread Group");
  
  assertEquals(0, indexUpdaterThreadGroup.activeCount());

  internalCache.getSystem().disconnect();
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
private void createRegionsWithSubRegions() {
  final Cache cache = getCache();
  
  RegionFactory<String, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE);
  dataRegionFactory.setConcurrencyLevel(3);
  Region<String, Integer> region1 = dataRegionFactory.create(REGION1);
  region1.createSubregion(SUBREGION1C, region1.getAttributes());
  Region<String, Integer> subregion2 = region1.createSubregion(SUBREGION1A, region1.getAttributes());
  
  subregion2.createSubregion(SUBREGION1B, subregion2.getAttributes());
  dataRegionFactory.create(REGION2);
  dataRegionFactory.create(REGION3);
  
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private Region<?,?> createParReg(String regionName, Cache cache, Class keyConstraint, Class valueConstraint ) {
  RegionFactory regionFactory = cache.createRegionFactory();
  regionFactory.setDataPolicy(DataPolicy.PARTITION);
  regionFactory.setKeyConstraint(keyConstraint);
  regionFactory.setValueConstraint(valueConstraint);
  return regionFactory.create(regionName);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private Region<?,?> createParRegWithPersistence(String regionName, String diskStoreName, String diskDirName) {
  Cache cache = getCache();
  File diskStoreDirFile = new File(diskDirName);
  diskStoreDirFile.deleteOnExit();
  
  if (!diskStoreDirFile.exists()) {
    diskStoreDirFile.mkdirs();
  }
  
  DiskStoreFactory diskStoreFactory = cache.createDiskStoreFactory();
  diskStoreFactory.setDiskDirs(new File[] { diskStoreDirFile });
  diskStoreFactory.setMaxOplogSize(1);
  diskStoreFactory.setAllowForceCompaction(true);
  diskStoreFactory.setAutoCompact(false);
  diskStoreFactory.create(diskStoreName);
  
  /****
   * Eviction Attributes
   */
  EvictionAttributes ea = EvictionAttributes.createLRUEntryAttributes(1, EvictionAction.OVERFLOW_TO_DISK);
  
  RegionFactory regionFactory = cache.createRegionFactory();
  regionFactory.setDiskStoreName(diskStoreName);
  regionFactory.setDiskSynchronous(true);
  regionFactory.setDataPolicy(DataPolicy.PERSISTENT_PARTITION);
  regionFactory.setEvictionAttributes(ea);
  
  return regionFactory.create(regionName);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private Region<?,?> createRepRegWithPersistence(String regionName, String diskStoreName, String diskDirName) {
  Cache cache = getCache();
  File diskStoreDirFile = new File(diskDirName);
  diskStoreDirFile.deleteOnExit();
  
  if (!diskStoreDirFile.exists()) {
    diskStoreDirFile.mkdirs();
  }
  
  DiskStoreFactory diskStoreFactory = cache.createDiskStoreFactory();
  diskStoreFactory.setDiskDirs(new File[] { diskStoreDirFile });
  diskStoreFactory.setMaxOplogSize(1);
  diskStoreFactory.setAllowForceCompaction(true);
  diskStoreFactory.setAutoCompact(false);
  diskStoreFactory.create(diskStoreName);
  
  /****
   * Eviction Attributes
   */
  EvictionAttributes ea = EvictionAttributes.createLRUEntryAttributes(1, EvictionAction.OVERFLOW_TO_DISK);
  
  RegionFactory regionFactory = cache.createRegionFactory();
  regionFactory.setDiskStoreName(diskStoreName);
  regionFactory.setDiskSynchronous(true);
  regionFactory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
  regionFactory.setEvictionAttributes(ea);
  
  return regionFactory.create(regionName);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private void createRegionsWithSubRegions() {
  final Cache cache = getCache();
  
  RegionFactory<String, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE);
  dataRegionFactory.setConcurrencyLevel(3);
  Region<String, Integer> region1 = dataRegionFactory.create(REGION1);
  region1.createSubregion(SUBREGION1C, region1.getAttributes());
  Region<String, Integer> subregion2 = region1.createSubregion(SUBREGION1A, region1.getAttributes());
  
  subregion2.createSubregion(SUBREGION1B, subregion2.getAttributes());
  dataRegionFactory.create(REGION2);
  dataRegionFactory.create(REGION3);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private Callable getCreateServerCallable(final String regionName, final boolean usePR) {
  return new SerializableCallable("create server and entries") {
    public Object call() {
      Cache cache = getCache();
      List<CacheServer> servers = cache.getCacheServers();
      CacheServer server;
      if (servers.size() > 0) {
        server = servers.get(0);
      } else {
        server = cache.addCacheServer();
        int port = AvailablePortHelper.getRandomAvailableTCPPort();
        server.setPort(port);
        server.setHostnameForClients("localhost");
        try {
          server.start();
        }
        catch (IOException e) {
          fail("Failed to start server ", e);
        }
      }
      if (usePR) {
        RegionFactory factory = cache.createRegionFactory(RegionShortcut.PARTITION);
        PartitionAttributesFactory pf = new PartitionAttributesFactory();
        pf.setTotalNumBuckets(2);
        factory.setPartitionAttributes(pf.create());
        factory.create(regionName);
      } else {
        cache.createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
      }
      return server.getPort();
    }
  };
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private void setupSystem() throws IOException {
  disconnectAllFromDS();
  final Host host = Host.getHost(0);
  final VM[] servers = { host.getVM(0), host.getVM(1) };

  final Properties propsMe = createProperties("me", "G1");
  final Properties propsServer1 = createProperties("Server1", "G1");
  final Properties propsServer2 = createProperties("Server2", "G2");
  
  
  getSystem(propsMe);
  final Cache cache = getCache();
  RegionFactory<String, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE_PROXY);
  dataRegionFactory.setConcurrencyLevel(5);
  Region<String, Integer> region1 = dataRegionFactory.create(REGION1);
  
  
  
  servers[1].invoke( new SerializableRunnable("Create cache for server1") {
    public void run() {
      getSystem(propsServer2);
      createRegionsWithSubRegions();
      createLocalRegion();
      createPartitionedRegion("ParReg1");
    }
  }) ;
  servers[0].invoke( new SerializableRunnable("Create cache for server0") {
    public void run() {
      getSystem(propsServer1);
      createRegionsWithSubRegions();
      createLocalRegion();
      
    }
    });
  
  
  
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private void createLocalSetUp() {
  Properties localProps = new Properties();
  localProps.setProperty(DistributionConfig.NAME_NAME, "Controller");
  getSystem(localProps);
  Cache cache = getCache();
  RegionFactory<Integer, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.REPLICATE);
  Region region1 = dataRegionFactory.create("REGION1");
  Region region2 = dataRegionFactory.create("REGION2");
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private Region<?,?> createParRegWithPersistence(String regionName, String diskStoreName, String diskDirName) {
  Cache cache = getCache();
  File diskStoreDirFile = new File(diskDirName);
  
  if (!diskStoreDirFile.exists()) {
    diskStoreDirFile.mkdirs();
  }
  
  DiskStoreFactory diskStoreFactory = cache.createDiskStoreFactory();
  diskStoreFactory.setDiskDirs(new File[] { diskStoreDirFile });
  diskStoreFactory.setMaxOplogSize(1);
  diskStoreFactory.setAllowForceCompaction(true);
  diskStoreFactory.setAutoCompact(false);
  diskStoreFactory.create(diskStoreName);
  
  /****
   * Eviction Attributes
   */
  EvictionAttributes ea = EvictionAttributes.createLRUEntryAttributes(1, EvictionAction.OVERFLOW_TO_DISK);
  
  RegionFactory regionFactory = cache.createRegionFactory();
  regionFactory.setDiskStoreName(diskStoreName);
  regionFactory.setDiskSynchronous(true);
  regionFactory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
  regionFactory.setScope(Scope.DISTRIBUTED_ACK);
  regionFactory.setEvictionAttributes(ea);
  
  return regionFactory.create(regionName);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
public void testAsyncIndexUpdaterThreadShutdownForRR() {
  Cache cache = new CacheFactory().create();

  RegionFactory rf = cache.createRegionFactory(RegionShortcut.REPLICATE);
  rf.setIndexMaintenanceSynchronous(false);
  Region localRegion = rf.create(name);
  
  assertNotNull("Region ref null", localRegion);
  
  try {
    cache.getQueryService().createIndex("idIndex", "ID", "/"+name);
  } catch (Exception e) {
    cache.close();
    e.printStackTrace();
    fail("Index creation failed");
  }
  
  for (int i=0; i<500; i++) {
    localRegion.put(i, new Portfolio(i));
  }
  
  GemFireCacheImpl internalCache = (GemFireCacheImpl)cache;
  // Don't disconnect distributed system yet to keep system thread groups alive.
  internalCache.close("Normal disconnect", null, false, false);

  // Get Asynchronous index updater thread group from Distributed System.
  ThreadGroup indexUpdaterThreadGroup = LogWriterImpl.getThreadGroup("QueryMonitor Thread Group");
  
  assertEquals(0, indexUpdaterThreadGroup.activeCount());
  
  internalCache.getSystem().disconnect();
  
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
protected RegionFactory<Integer, String> getRegionFactory(Cache cache) {
  return cache.<Integer,String>createRegionFactory(RegionShortcut.PARTITION_PERSISTENT);
}
 

import com.gemstone.gemfire.cache.Cache; //导入方法依赖的package包/类
private void createPartitionedRegion1() {
    final Cache cache = getCache();
    // Create the data region
   RegionFactory<String, Integer> dataRegionFactory = cache.createRegionFactory(RegionShortcut.PARTITION);
   dataRegionFactory.create(PR1);
}