Java AdvancedCache类代码示例

import org.infinispan.AdvancedCache; //导入依赖的package包/类
private void initSchema() {
    AtomicReference<Integer> replicationFactor = new AtomicReference<>();
    try {
        replicationFactor.set(Integer.parseInt(replicationFactorProp));
    } catch (NumberFormatException e) {
        log.warnf("Invalid value [%s] for Cassandra replication_factor. Using default value of 1",
                replicationFactorProp);
        replicationFactor.set(1);
    }

    AdvancedCache<String, String> cache = locksCache.getAdvancedCache();
    DistributedLock schemaLock = new DistributedLock(cache, "cassalog");
    schemaLock.lockAndThen(30000, () -> {
        SchemaService schemaService = new SchemaService();
        schemaService.run(session, keyspace, Boolean.parseBoolean(resetDb), replicationFactor.get());
        session.execute("USE " + keyspace);
        logReplicationFactor();
    });
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
/**
 *
 * Get embedded Infinispan cache which acts as an underlying store for JSON documents.
 *
 * Look into global map for registered cache. Avoiding multiple asking CacheManager.
 * <p/>
 * If there is no cache with the given name, get it from CacheManager and put.
 *
 * @param cacheName -- name of cache, AdvancedCache is returned.
 * @return AdvancedCache instance in dependence on a given name.
 */
private AdvancedCache getCache(String cacheName) {
    if (caches.get(cacheName) != null) {
        return this.caches.get(cacheName);
    } else {
        try {
            defaultCacheManager.startCache(cacheName);
            Cache cache = defaultCacheManager.getCache(cacheName);
            this.caches.put(cacheName, cache.getAdvancedCache());
            return cache.getAdvancedCache();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("ERROR DURING STARTING CACHE " + cacheName, e);
        }
    }
    return this.caches.get(cacheName);
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
@Override
public void runTask() {
	// wait for a message from coordinator to try to lock keys A and B
	// post a message TimeoutException if lock cannot be acquired
	// post a message LockSuccess if lock is successful
	getCacheManager().getCache(TestConstants.CACHE_MESSAGE).addListener(new NodeMessageListener<String>() {
		@Override
		public void onMessage(Message<String> value) {
			LOGGER.debug("message received");
			if (value.getAddress().equals(getCacheManager().getCoordinator())) {
				LOGGER.debug("message received from coordinator");
				if ("tryLock".equals(value.getMessage())) {
					LOGGER.debug("received tryLock message");
					AdvancedCache<String, Object> cache =
							getCacheManager().<String, Object>getCache(TestConstants.CACHE_DEFAULT).getAdvancedCache();
					LOGGER.debug("batch started");
					cache.startBatch();
					boolean successful = false;
					Address address = getCacheManager().getAddress();
					try {
						LOGGER.debug("try A, B locks");
						cache.lock("A", "B");
						LOGGER.debug("lock successful");
						successful = true;
						LOGGER.debug("send success message");
						getCacheManager().<String, Message<String>>getCache(TestConstants.CACHE_MESSAGE)
							.put("messageBus", Message.from(address, LOCK_SUCCESS));
					} catch (TimeoutException e) {
						LOGGER.debug("send failure message");
						getCacheManager().<String, Message<String>>getCache(TestConstants.CACHE_MESSAGE)
							.put("messageBus", Message.from(address, TIMEOUT_EXCEPTION));
					} finally {
						cache.endBatch(successful);
						LOGGER.debug("batch ended");
					}
				}
			}
		}
	});
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
@Override
protected Map<ID, T> findAll(Set<ID> keys) {
    AdvancedCache<ID, T> advancedCache = cache.getAdvancedCache();
    return advancedCache.getAll(keys);
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <K, V> AdvancedCache<K, V> asAdvanced(BasicCache<K, V> cache) {
    return Cache.class.cast(cache).getAdvancedCache();
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
   DefaultCacheManager cacheManager = new DefaultCacheManager();
   cacheManager.defineConfiguration("local", new ConfigurationBuilder().build());
   AdvancedCache<String, String> cache = cacheManager.<String, String>getCache("local").getAdvancedCache();
   FunctionalMapImpl<String, String> functionalMap = FunctionalMapImpl.create(cache);
   FunctionalMap.WriteOnlyMap<String, String> writeOnlyMap = WriteOnlyMapImpl.create(functionalMap);
   FunctionalMap.ReadOnlyMap<String, String> readOnlyMap = ReadOnlyMapImpl.create(functionalMap);

   // Execute two parallel write-only operation to store key/value pairs
   CompletableFuture<Void> writeFuture1 = writeOnlyMap.eval("key1", "value1",
      (v, writeView) -> writeView.set(v));
   CompletableFuture<Void> writeFuture2 = writeOnlyMap.eval("key2", "value2",
      (v, writeView) -> writeView.set(v));

   // When each write-only operation completes, execute a read-only operation to retrieve the value
   CompletableFuture<String> readFuture1 =
      writeFuture1.thenCompose(r -> readOnlyMap.eval("key1", EntryView.ReadEntryView::get));
   CompletableFuture<String> readFuture2 =
      writeFuture2.thenCompose(r -> readOnlyMap.eval("key2", EntryView.ReadEntryView::get));

   // When the read-only operation completes, print it out
   System.out.printf("Created entries: %n");
   CompletableFuture<Void> end = readFuture1.thenAcceptBoth(readFuture2, (v1, v2) ->
      System.out.printf("key1 = %s%nkey2 = %s%n", v1, v2));

   // Wait for this read/write combination to finish
   end.get();

   // Create a read-write map
   FunctionalMap.ReadWriteMap<String, String> readWriteMap = ReadWriteMapImpl.create(functionalMap);

   // Use read-write multi-key based operation to write new values
   // together with lifespan and return previous values
   Map<String, String> data = new HashMap<>();
   data.put("key1", "newValue1");
   data.put("key2", "newValue2");
   Traversable<String> previousValues = readWriteMap.evalMany(data, (v, readWriteView) -> {
      String prev = readWriteView.find().orElse(null);
      readWriteView.set(v, new MetaLifespan(Duration.ofHours(1).toMillis()));
      return prev;
   });

   // Use read-only multi-key operation to read current values for multiple keys
   Traversable<EntryView.ReadEntryView<String, String>> entryViews =
      readOnlyMap.evalMany(data.keySet(), readOnlyView -> readOnlyView);
   System.out.printf("Updated entries: %n");
   entryViews.forEach(view -> System.out.printf("%s%n", view));

   // Finally, print out the previous entry values
   System.out.printf("Previous entry values: %n");
   previousValues.forEach(prev -> System.out.printf("%s%n", prev));
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
/**
 * Test {@link AdvancedCache#startBatch()} (to handle concurrent read / update).
 * We lock to keys (A and B) and asks for second nodes (using message) to confirm that these keys cannot be locked
 * concurrently.
 * After keys' release, confirm that second node can now lock these keys.
 * 
 * @throws IOException
 * @throws InterruptedException
 * @throws TimeoutException
 * @throws ExecutionException
 */
@Test
public void testBatch() throws IOException, InterruptedException, TimeoutException, ExecutionException {
	// start infinispan
	final int nodeNumber = 1;
	
	// start test instance
	final EmbeddedCacheManager cacheManager = new TestCacheManagerBuilder("node main", null).build();
	this.cacheManager = cacheManager;
	
	final Object monitor = new Object();
	final Map<Address, String> messages = Maps.newConcurrentMap();
	
	cacheManager.start();
	cacheManager.getCache(TestConstants.CACHE_MESSAGE).addListener(new NodeMessageListener<String>() {
		@Override
		public void onMessage(Message<String> value) {
			messages.put(value.getAddress(), value.getMessage());
			synchronized (monitor) {
				monitor.notify();
			}
		}
	});
	// initializes two keys A and B
	cacheManager.getCache(TestConstants.CACHE_DEFAULT).put("A", "A");
	cacheManager.getCache(TestConstants.CACHE_DEFAULT).put("B", "B");
	
	// start another node that register a task that waits a message to lock A and B
	prepareCluster(nodeNumber, LockTask.class);
	
	// startBatch
	AdvancedCache<Object, Object> cache = cacheManager.<Object, Object>getCache(TestConstants.CACHE_DEFAULT).getAdvancedCache();
	cache.startBatch();
	boolean successful = false;
	final Address address = cacheManager.getAddress();
	
	Callable<Boolean> test = new Callable<Boolean>() {
		@Override
		public Boolean call() throws Exception {
			return ! address.equals(cacheManager.<String, Message<String>>getCache(TestConstants.CACHE_MESSAGE).get(TestConstants.CACHE_KEY_MESSAGE_BUS).getAddress());
		}
	};
	
	try {
		// lock A and B
		cache.lock("A", "B");
		// send message -> second node cannot lock -> message TimeoutException
		cacheManager.getCache(TestConstants.CACHE_MESSAGE).put(TestConstants.CACHE_KEY_MESSAGE_BUS, Message.from(address, LockTask.TRY_LOCK));
		// must be set accordingly with lockAcquisitionTimeout
		waitForEvent(monitor, test, 25, TimeUnit.SECONDS);
		Assert.assertEquals(LockTask.TIMEOUT_EXCEPTION, cacheManager.<String, Message<String>>getCache(TestConstants.CACHE_MESSAGE).get(TestConstants.CACHE_KEY_MESSAGE_BUS).getMessage());
		successful = true;
	} finally {
		// stopBatch
		cache.endBatch(successful);
	}
	// second node can lock
	cacheManager.getCache(TestConstants.CACHE_MESSAGE).put(TestConstants.CACHE_KEY_MESSAGE_BUS, Message.from(address, LockTask.TRY_LOCK));
	// must be set accordingly with lockAcquisitionTimeout
	waitForEvent(monitor, test, 25, TimeUnit.SECONDS);
	Assert.assertEquals(LockTask.LOCK_SUCCESS, cacheManager.<String, Message<String>>getCache(TestConstants.CACHE_MESSAGE).get(TestConstants.CACHE_KEY_MESSAGE_BUS).getMessage());
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
/**
 * @param locksCache The cache used for locking. This class will probably refactored at some point so that the cache
 *                   can be directly injected.
 * @param key The name or value of the lock.
 */
public DistributedLock(AdvancedCache<String, String> locksCache, String key) {
    this.key = key;
    this.locksCache = locksCache;
    this.locksCache.getCacheManager().addListener(this);
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
@Override
protected AdvancedCache createCacheWrapper(AdvancedCache cache) {
    return cache;
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
@Override
protected AdvancedCache createCacheWrapper(AdvancedCache cache) {
    cache.start();
    return cache;
}
 

import org.infinispan.AdvancedCache; //导入依赖的package包/类
@Override
public void execute() throws Exception
{
    AdvancedCache ac = (AdvancedCache)ca.getCache("SOURCE-CACHE");

    // maipulate the JTA transaction with begin/commit/rollback

    ac.lock(key);

    System.out.println("> ok");

    // maipulate the JTA transaction with begin/commit/rollback

}