3.5. 创建嵌入式缓存

将 Data Grid 添加到项目，以便在您的应用程序中创建嵌入的缓存。

<dependencies>
  <dependency>
    <groupId>org.infinispan</groupId>
    <artifactId>infinispan-core</artifactId>
  </dependency>
</dependencies>

Data Grid 提供了一个 GlobalConfigurationBuilder API，用于控制 Cache Manager 和用于配置缓存的 ConfigurationBuilder API。

// Set up a clustered Cache Manager.
GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
// Initialize the default Cache Manager.
DefaultCacheManager cacheManager = new DefaultCacheManager(global.build());
// Create a distributed cache with synchronous replication.
ConfigurationBuilder builder = new ConfigurationBuilder();
                     builder.clustering().cacheMode(CacheMode.DIST_SYNC);
// Obtain a volatile cache.
Cache<String, String> cache = cacheManager.administration().withFlags(CacheContainerAdmin.AdminFlag.VOLATILE).getOrCreateCache("myCache", builder.build());
// Stop the Cache Manager.
cacheManager.stop();

Cache<String, String> myCache = manager.getCache("myCache");

前面的操作会创建一个名为 myCache 的缓存（如果尚未存在），并返回它。

使用 getCache （） 方法仅在您调用方法的节点上创建缓存。换句话说，它会执行一个本地操作，它必须在集群中的每个节点上调用。通常，在多个节点间部署的应用程序会在初始化过程中获取缓存，以确保缓存都是 对称的，并在每个节点上存在。

Cache<String, String> myCache = manager.administration().createCache("myCache", "myTemplate");

前面的操作还会在随后加入集群的任何节点上自动创建缓存。

默认情况下，您使用 createCache （） 方法创建的缓存是临时的。如果整个集群关闭，则缓存重启后不会自动创建。

Cache<String, String> myCache = manager.administration().withFlags(AdminFlag.PERMANENT).createCache("myCache", "myTemplate");

要使 PERMANENT 标志生效，您必须启用全局状态并设置配置存储提供程序。

有关配置存储供应商的更多信息，请参阅 GlobalStateConfigurationBuilder#configurationStorage （）。

Data Grid 提供了一个 Cache 接口，它公开简单的方法来添加、检索和删除条目，包括 JDK 的 ConcurrentMap 接口公开的原子机制。根据所使用的缓存模式，调用这些方法会触发多个事情，甚至可能包括将条目复制到远程节点或从远程节点查找条目，或可能缓存存储。

对于简单使用，使用 Cache API 不应与使用 JDK Map API 不同，因此从基于映射到 Data Grid 的缓存的简单内存缓存迁移应该很简单。

试图全局执行这些操作会对性能有很大的影响，并成为可扩展性瓶颈。因此，这些方法应该仅用于信息或调试目的。

应注意，在 withFlags （） 方法中使用某些标记可以缓解其中的一些问题，请检查每个方法的文档以了解更多详情。

除了 Lifespan 外，Data Grid 还支持 maxIdle 作为额外的指标，以决定到期。可以使用任何 lifespans 或 maxIdles 的组合。

要达到此目的，putForExternalRead （） 充当 put 调用，只有在缓存中不存在密钥时才运行，并在另一个线程尝试同时存储同一密钥时失败。在这个特殊情况下，缓存数据是优化系统的方法，而不需要缓存失败会影响到持续的事务，因此为什么以不同的方式处理失败。putForExternalRead （） 被视为快速操作，因为无论它是否成功，它都不会等待任何锁定，因此会立即返回到调用者。

要了解如何使用此操作，让我们来看基本的示例。试想一下，个人实例的缓存，每个由 PersonId 的密钥，其数据源自于单独的数据存储中。以下代码显示了在此示例上下文中使用 putForExternalRead 的最常见模式：

// Id of the person to look up, provided by the application
PersonId id = ...;

// Get a reference to the cache where person instances will be stored
Cache<PersonId, Person> cache = ...;

// First, check whether the cache contains the person instance
// associated with with the given id
Person cachedPerson = cache.get(id);

if (cachedPerson == null) {
   // The person is not cached yet, so query the data store with the id
   Person person = dataStore.lookup(id);

   // Cache the person along with the id so that future requests can
   // retrieve it from memory rather than going to the data store
   cache.putForExternalRead(id, person);
} else {
   // The person was found in the cache, so return it to the application
   return cachedPerson;
}

请注意，putForExternalRead 不应用作使用源自应用程序执行的新 Person 实例更新缓存的机制（例如，来自修改人员地址的事务）。更新缓存的值时，请使用标准 放置 操作，否则可能会出现缓存损坏数据的可能性。

AdvancedCache advancedCache = cache.getAdvancedCache();

advancedCache.withFlags(Flag.CACHE_MODE_LOCAL, Flag.SKIP_LOCKING)
   .withFlags(Flag.FORCE_SYNCHRONOUS)
   .put("hello", "world");

Set<CompletableFuture<?>> futures = new HashSet<>();
futures.add(cache.putAsync(key1, value1)); // does not block
futures.add(cache.putAsync(key2, value2)); // does not block
futures.add(cache.putAsync(key3, value3)); // does not block

// the remote calls for the 3 puts will effectively be executed
// in parallel, particularly useful if running in distributed mode
// and the 3 keys would typically be pushed to 3 different nodes
// in the cluster

// check that the puts completed successfully
for (CompletableFuture<?> f: futures) f.get();