Apache Geode 的 Spring Data（数据）

版本 2.7.6

Spring Data for Apache Geode专注于集成Spring Framework强大的非侵入式编程模型。以及使用 Apache Geode 简化 Java 应用程序的配置和开发的概念当使用Apache Geode作为数据管理解决方案时。

本文档假设您已经对核心 Spring 框架有基本的了解和一定的熟悉。和Apache Geode概念。

虽然已尽一切努力确保本文档全面完整，没有错误，某些主题超出了本文档的范围，可能需要更多解释（例如，数据分发管理使用带有 HA 的分区，同时仍保持一致性）。此外，一些印刷错误可能已经悄悄出现。如果您确实发现了错误甚至更严重的错误，请提请Spring Data团队注意这些问题。通过在JIRA中提出适当的问题。

1. 简介

Spring Data for Apache Geode 参考指南解释了如何使用 Spring 框架使用 Apache Geode 配置和开发应用程序。它介绍了基本概念并提供大量示例来帮助您快速入门。

2. 要求

Spring Data for Apache Geode 需要 Java 8.0，Spring Framework5 和Apache Geode1.9.0。

3. 新功能

从 1.2.0.RELEASE 开始，这个项目（以前称为 Spring GemFire）已重命名为 Spring Data for Apache Geode 以反映它现在是Spring Data项目的一个模块，并建立在Apache Geode之上。

3.1. 2.0 版本中的新功能

升级到Apache Geode 9.1.1。
升级到 Spring Data Commons 2.0.8.RELEASE。
升级到 Spring Framework 5.0.7.RELEASE。
通过按关注点打包不同的类别和组件来重组 SDG 代码库。
添加了对 Java 8 类型的广泛支持，特别是在 SD 存储库抽象中。
更改为存储库接口和抽象，例如不再需要 ID。java.io.Serializable
Setannotationattribute to默认情况下。@EnableEntityDefinedRegionsignoreIfExiststrue
Setannotationattribute to默认情况下。@Indexedoverridefalse
重命名为。@EnableIndexes@EnableIndexing
引入了 aclass 以轻松方便地表达客户端之间对键和值的兴趣和使用 JavaConfig 时的服务器。InterestsBuilder
在注释配置模型中添加了对堆外、Redis 适配器、以及Apache Geode的新安全框架。

3.2. 2.1 版本中的新功能

升级到Apache Geode 1.9.0。
升级到 Spring Framework 5.1.0.RELEASE。
升级到 Spring Data Commons 2.1.0.RELEASE。
添加了对并行缓存/区域快照的支持，以及在加载快照时调用回调。
添加了对注册 QueryPostProcessor 的支持，以自定义从存储库查询方法生成的 OQL。
添加了对 o.s.d.g.mapping.Mapping.MappingPdxSerializer 中的 include/exclude TypeFilters 的支持。
更新了文档。

3.3. 2.2 版本中的新功能

升级到Apache Geode 1.9.0。
升级到 Spring Framework 5.2.0.RELEASE。
升级到 Spring Data Commons 2.2.0.RELEASE。
添加注释配置支持以配置和引导 Apache Geode 定位器应用程序用。@LocatorApplication
添加了对网关接收器和网关发送方的注释配置支持。
更新了文档。

参考指南

4. 文档结构

以下章节解释了Spring Data for Apache Geode提供的核心功能：

使用 Spring 容器引导 Apache Geode描述了为配置、初始化和访问提供的配置支持 Apache Geode Caches、Regions 和相关的分布式系统组件。
使用 Apache Geode API 解释了 Apache Geode API与各种数据访问功能之间的集成。在 Spring 中可用，例如基于模板的数据访问、异常转换、事务管理和缓存。
使用 Apache Geode 序列化描述了对 Apache Geode托管对象的序列化和反序列化的增强功能。
POJO 映射描述了使用 Spring Data 存储在 Apache Geode 中的 POJO 的持久性映射。
Spring Data for Apache GeodeRepository描述了如何创建和使用Spring Data Repository来访问数据通过使用基本的 CRUD 和简单的查询操作存储在 Apache Geode 中。
函数执行的注释支持描述了如何使用注释创建和使用 Apache Geode 函数在数据所在的位置执行分布式计算。
连续查询（CQ）描述如何使用 Apache Geode 的连续查询（CQ）功能根据在 Apache Geode 定义和注册的兴趣处理事件流 OQL（对象查询语言）。
在Apache Geode中引导Spring ApplicationContext描述了如何使用Apache Geode服务器配置和引导Springrun。ApplicationContextGfsh
示例应用程序描述了随发行版提供的示例，以说明各种功能在 Spring Data for Apache Geode 中可用。

5. 使用弹簧容器引导 Apache Geode

Spring Data for Apache Geode 提供 Apache Geode 内存数据网格（IMDG）的完整配置和初始化使用 Spring IoC 容器。该框架包括多个类，以帮助简化 Apache Geode 组件，包括：缓存、区域、索引、磁盘存储、函数、WAN 网关、持久性备份和其他几个分布式系统组件，以支持各种应用程序用例以最小的努力。

本节假定对Apache Geode基本熟悉。有关更多信息，请参阅 Apache Geode产品文档。

5.1. 使用 Spring 优于 Apache Geode 的优势`cache.xml`

Spring Data for Apache Geode的XML命名空间支持Apache Geode内存数据网格（IMDG）的完整配置。 XML命名空间是在Spring上下文中配置Apache Geode的两种方法之一，以便正确管理 Apache Geode在Spring容器中的生命周期。在 Spring 中配置 Apache Geode 的另一种方法上下文是通过使用基于注释的配置。

虽然由于遗留原因，对Apache Geode本机的支持仍然存在，但Apache Geode应用程序开发人员鼓励使用XML配置的人在Spring XML中做所有事情，以利用许多美妙的东西。 Spring 必须提供，例如模块化 XML 配置、属性占位符和覆盖， SpEL（Spring Expression Language）和环境配置文件。在XML命名空间的背后，Spring Data for Apache Geode广泛使用Spring的模式来简化创建。 Apache Geode 组件的配置和初始化。cache.xmlFactoryBean

Apache Geode 提供了多个回调接口，例如、和允许开发人员添加自定义事件处理程序。使用Spring的IoC容器，你可以配置这些回调。作为普通的春豆，并将它们注入到Apache Geode组件中。这是一个显着的改进 native，提供相对有限的配置选项，需要回调才能实现 Apache Geode的接口（参见连接可声明的组件看看如何在Spring的容器中仍然使用）。CacheListenerCacheLoaderCacheWritercache.xmlDeclarableDeclarables

此外，IDE，如Spring Tool Suite（STS），为Spring XML命名空间提供了出色的支持。包括代码完成、弹出注释和实时验证。

5.2. 使用核心命名空间

为了简化配置，Spring Data for Apache Geode 提供了一个专用的 XML 命名空间，用于配置核心 Apache Geode 组件。可以使用 Spring 的标准定义直接配置 bean。然而所有 Bean 属性都通过 XML 命名空间公开，因此使用原始 Bean 定义几乎没有好处。<bean>

有关 Spring 中基于 XML 模式的配置的更多信息，请参阅 Spring 框架参考文档中的附录。

Spring 数据存储库支持使用单独的 XML 命名空间。有关更多信息，请参阅Apache Geode 存储库的 Spring 数据关于如何为 Apache Geode 存储库配置 Spring 数据。

要使用 Spring Data for Apache Geode XML 命名空间，请在 Spring XML 配置元数据中声明它，如以下示例所示：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:gfe="https://www.springframework.org/schema/geode" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
    https://www.springframework.org/schema/geode https://www.springframework.org/schema/geode/spring-geode.xsd 
">

  <bean id ... >

  <gfe:cache ...> 

</beans>

Spring Data for Apache Geode XML 命名空间前缀。任何名称都有效，但在整个参考文档中，都会使用。`gfe`
XML 命名空间前缀映射到 URI。
XML 命名空间 URI 位置。请注意，即使该位置指向外部地址（确实存在并且有效），Spring 在本地解析模式，因为它包含在 Spring Data for Apache Geode 库中。
使用带有前缀的 XML 命名空间的示例声明。`gfe`

可以将默认命名空间更改为 fromto。这对于主要由 Apache Geode 组件，因为它避免声明前缀。为此，请交换命名空间前缀声明如前所示，如以下示例所示：`beans``gfe` <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="https://www.springframework.org/schema/geode" xmlns:beans="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd https://www.springframework.org/schema/geode https://www.springframework.org/schema/geode/spring-geode.xsd "> <beans:bean id ... > <cache ...> </beans>

可以将默认命名空间更改为 fromto。这对于主要由 Apache Geode 组件，因为它避免声明前缀。为此，请交换命名空间前缀声明如前所示，如以下示例所示：beansgfe

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/geode" 
       xmlns:beans="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
    https://www.springframework.org/schema/geode https://www.springframework.org/schema/geode/spring-geode.xsd
">

  <beans:bean id ... > 

  <cache ...> 

</beans>

此 XML 文档的默认命名空间声明指向 Spring Data for Apache Geode XML 命名空间。
Spring 的原始 bean 定义的命名空间前缀声明。`beans`
使用命名空间的 Bean 声明。请注意前缀。`beans`
使用命名空间的 Bean 声明。请注意缺少前缀，因为这是默认命名空间。`gfe``gfe`

5.3. 使用数据访问命名空间

除了核心XML命名空间（），Spring Data for Apache Geode提供了一个数据访问XML命名空间（），这主要是为了简化Apache Geode客户端应用程序的开发。此命名空间目前包含对 Apache Geode存储库和函数执行的支持，以及提供便捷连接方式的 atag a Apache Geode cluster。gfegfe-data<datasource>

5.3.1. 连接到 Apache Geode 的简单方法

对于许多应用程序，使用默认值与 Apache Geode 数据网格的基本连接就足够了。 Spring Data for Apache Geode'stag提供了一种访问数据的简单方法。数据源创建 aand 连接。此外，它还会查询集群服务器以获取所有现有根区域并创建每个客户端的（空）客户端区域代理。<datasource>ClientCachePool

<gfe-data:datasource>
  <locator host="remotehost" port="1234"/>
</gfe-data:datasource>

标签在语法上类似于。它可以配置一个或多个嵌套元素以连接到现有数据网格。此外，可用于配置池的所有属性受支持。此配置会自动为集群成员上定义的每个区域创建客户机区域 Bean 连接到定位器，因此可以通过 Spring 数据映射注释无缝引用它们（）并自动连接到应用程序类。<datasource><gfe:pool>locatorserverGemfireTemplate

当然，您可以显式配置客户端区域。例如，如果要在本地内存中缓存数据，如以下示例所示：

<gfe-data:datasource>
  <locator host="remotehost" port="1234"/>
</gfe-data:datasource>

<gfe:client-region  shortcut="CACHING_PROXY"/>

5.4. 配置缓存

要使用Apache Geode，您需要创建一个新的缓存或连接到现有的缓存。使用当前版本对于 Apache Geode，每个 VM 只能有一个打开的缓存（更严格地说，每个）。在大多数情况下，缓存只应创建一次。ClassLoader

本节介绍适用于对等（P2P）的对等成员的创建和配置拓扑和缓存服务器。Amember还可用于独立应用程序和集成测试。但是，在典型的生产系统中，大多数应用程序进程充当缓存客户端，而是创建实例。这在配置 Apache Geode 客户端缓存和客户端区域部分中进行了描述。`Cache``Cache``ClientCache`

可以使用以下简单声明创建具有默认配置的对等方：Cache

<gfe:cache/>

在 Spring 容器初始化期间，任何包含此缓存定义的注册都会创建一个名为 Spring Bean，该 Bean 引用了一个 Apache Geodeinstance。这个 bean 指的是一个现有的或，如果一个不存在，一个新创建的。由于没有指定了其他属性，新创建应用默认缓存配置。ApplicationContextCacheFactoryBeangemfireCacheCacheCacheCache

依赖于此命名约定的 Apache Geode 组件的所有 Spring 数据，因此无需显式声明依赖关系。如果您愿意，可以使用提供的属性来显式创建依赖项通过各种 SDG XML 命名空间元素。此外，您可以使用属性覆盖缓存的 Bean 名称，如下：CacheCachecache-refid

<gfe:cache />

Apache Geodecan 可以使用 Spring 完全配置。但是，Apache Geode的本机XML配置文件，，也受支持。对于需要本机配置 Apache Geode 缓存的情况，您可以使用属性提供对 Apache Geode XML 配置文件的引用，如下：Cachecache.xmlcache-xml-location

<gfe:cache  cache-xml-location="classpath:cache.xml"/>

在此示例中，如果需要创建高速缓存，它将使用名为位于类路径根目录中的文件以对其进行配置。cache.xml

该配置利用 Spring的资源抽象来定位文件。抽象允许使用各种搜索模式，具体取决于运行时环境或在资源位置中指定的前缀（如果有）。`Resource`

除了引用外部XML配置文件之外，您还可以指定使用任何Spring支持功能的Apache Geode System属性。Properties

例如，您可以使用命名空间中定义的元素来定义直接或从属性文件加载属性，如下所示：propertiesutilProperties

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:gfe="https://www.springframework.org/schema/geode"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
    https://www.springframework.org/schema/geode https://www.springframework.org/schema/geode/spring-geode.xsd
    http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd
">

  <util:properties  location="file:/path/to/gemfire.properties"/>

  <gfe:cache properties-ref="gemfireProperties"/>

</beans>

建议使用属性文件外部化特定于环境的设置在应用程序配置之外。

仅当需要创建新缓存时，缓存设置才适用。如果 VM 中已存在打开的缓存，这些设置将被忽略。

5.4.1. 高级缓存配置

对于高级缓存配置，元素提供了许多作为属性公开的配置选项或子元素，如以下清单所示：cache

<gfe:cache
    cache-xml-location=".."
    properties-ref=".."
    close="false"
    copy-on-read="true"
    critical-heap-percentage="90"
    eviction-heap-percentage="70"
    enable-auto-reconnect="false" 
    lock-lease="120"
    lock-timeout="60"
    message-sync-interval="1"
    pdx-serializer-ref="myPdxSerializer"
    pdx-persistent="true"
    pdx-disk-store="diskStore"
    pdx-read-serialized="false"
    pdx-ignore-unread-fields="true"
    search-timeout="300"
    use-bean-factory-locator="true" 
    use-cluster-configuration="false" 
>

  <gfe:transaction-listener ref="myTransactionListener"/> 

  <gfe:transaction-writer> 
    <bean class="org.example.app.gemfire.transaction.TransactionWriter"/>
  </gfe:transaction-writer>

  <gfe:gateway-conflict-resolver ref="myGatewayConflictResolver"/> 

  <gfe:jndi-binding jndi-name="myDataSource" type="ManagedDataSource"/> 

</gfe:cache>

属性支持各种缓存选项。有关此示例中显示的任何内容的更多信息，请参阅 Apache Geode产品文档。该属性确定在关闭 Spring 应用程序上下文时是否应关闭缓存。默认值为。但是，对于多个应用程序上下文使用缓存的用例（在 Web 应用程序中很常见），请将此值设置为。`close``true``false`
将属性设置为（默认值为）允许断开连接的Apache Geode成员自动重新连接并重新加入 Apache Geode 集群。有关更多详细信息，请参阅 Apache Geode产品文档。`enable-auto-reconnect``true``false`
将属性设置为（默认为）仅在两者同时适用 Spring （XML）配置元数据和用于配置 Apache Geode 缓存节点的 Apache Geodeis（无论是客户端还是对等方）。此选项允许 Apache Geode 组件（例如）表示为 inbe 自动连接到 Spring 应用程序上下文中定义的 bean（例如）。此选项通常是与一起使用。`use-bean-factory-locator``true``false``cache.xml``CacheLoader``cache.xml``DataSource``cache-xml-location`
将属性设置为（默认值为）使 Apache Geode 成员能够从定位器检索基于群集的通用共享配置。有关更多详细信息，请参阅 Apache Geode产品文档。`use-cluster-configuration``true``false`
使用 Bean 引用的回调声明示例。引用的 Bean 必须实现TransactionListener。可以实现 A 来处理与事务相关的事件（例如 afterCommit 和 afterRollback）。`TransactionListener``TransactionListener`
使用内 Bean 声明的回调声明示例。Bean 必须实现TransactionWriter。这是一个可以否决事务的回调。`TransactionWriter``TransactionWriter`
使用 Bean 引用的回调声明示例。引用的 bean 必须实现https://geode.apache.org/releases/latest/javadoc/org/apache/geode/cache/util/GatewayConflictResolver.html[网关冲突解决程序]。 Ais a级插件，被要求决定如何处理事件源自其他系统并通过 WAN 网关到达。提供分布式区域创建服务。`GatewayConflictResolver``GatewayConflictResolver``Cache`
声明 JNDI 绑定以在 Apache Geode 事务中登记外部数据源。

启用 PDX 序列化

前面的示例包括许多与 Apache Geode 的增强型序列化框架 PDX 相关的属性。虽然对 PDX 的完整讨论超出了本参考指南的范围，但请务必注意 PDX 通过注册 a 启用，这是通过设置属性指定的。PdxSerializerpdx-serializer

Apache Geode 提供了一个实现类（），它使用 Java Reflection。但是，开发人员通常会提供自己的实现。属性的值只是对实现接口的 Spring Bean 的引用。org.apache.geode.pdx.ReflectionBasedAutoSerializerPdxSerializer

有关序列化支持的更多信息，请参阅使用 Apache Geode 序列化。

启用自动重新连接

将属性设置为时应小心。<gfe:cache enable-auto-reconnect="[true|false*]>true

通常，只有在使用 Spring Data for Apache Geode 的 XML 命名空间进行配置的情况下，才应启用“自动重新连接”。并引导添加到集群的新的非应用程序 Apache Geode 服务器。换句话说，“自动重新连接” 当使用 Apache Geode 的 Spring 数据来开发和构建 Apache Geode 应用程序时，不应启用，该应用程序也会发生成为 Apache Geode 集群的对等成员。Cache

此限制的主要原因是大多数 Apache Geode 应用程序使用对 Apache Geodeor 区域的引用来执行数据访问操作。这些引用由 Spring 容器“注入” 到应用程序组件（如存储库）中以供应用程序使用。当对等成员被强制时与集群的其余部分断开连接，可能是因为对等成员变得无响应或网络分区将一个或多个对等成员分隔到一个太小而无法作为独立成员运行的组中分布式系统，对等成员关闭，所有 Apache Geode 组件引用（缓存、区域、等）无效。Cache

本质上，每个对等成员中的当前强制断开连接处理逻辑从头开始拆除系统。 JGroups 堆栈关闭，分布式系统进入关闭状态，最后关闭缓存。实际上，所有内存引用都会过时并丢失。

与分布式系统断开连接后，对等成员进入“重新连接”状态，并定期尝试重新加入分布式系统。如果对等成员成功重新连接，则成员将重建其“视图” 来自现有成员的分布式系统，并接收新的分布式系统 ID。此外，所有缓存，重建区域和其他 Apache Geode 组件。因此，所有旧的参考文献，可能是由 Spring 容器注入到应用程序中，现在已过时且不再有效。

Apache Geode 不保证（即使使用 Apache Geode 公共 Java API）应用程序缓存，区域或其他组件参照由重新连接操作自动刷新。因此，Apache Geode 应用程序必须注意刷新自己的引用。

遗憾的是，无法收到断开连接事件以及随后的重新连接事件的通知。如果是这样的话，您将有一种干净的方式来知道何时打电话，如果它甚至适用于应用程序这样做，这就是为什么Apache Geode的这个“功能”不是建议对等应用程序使用。ConfigurableApplicationContext.refresh()Cache

有关“自动重新连接”的更多信息，请参阅 Apache Geode的产品文档。

使用基于群集的配置

Apache Geode 的集群配置服务是任何加入集群的对等成员获取的便捷方式通过使用定位器维护的共享持久配置的集群的“一致视图”。使用基于集群的配置可确保对等成员的配置与 Apache Geode 兼容成员加入时的分布式系统。

Spring Data for Apache Geode（将属性设置为）的此功能以相同的方式工作作为属性，除了 Apache Geode 配置元数据的来源来自通过定位器从网络，而不是驻留在本地文件系统中的本机文件。use-cluster-configurationtruecache-xml-locationcache.xml

所有 Apache Geode 本机配置元数据，无论是来自还是来自集群配置服务，在任何 Spring （XML）配置元数据之前应用。因此，Spring 的配置用于“增强”（本机 Apache Geode 配置元数据，并且很可能特定于应用程序。cache.xml

同样，要启用此功能，请在Spring XML配置中指定以下内容：

<gfe:cache use-cluster-configuration="true"/>

虽然某些Apache Geode工具（如Gfsh）在类似模式的更改时会“记录”其操作。是（例如，），Apache Geode配置元数据的Spring Data 不记录。直接使用 Apache Geode 的公共 Java API 时也是如此。它也没有被记录下来。`gfsh>create region --name=Example --type=PARTITION`

有关 Apache Geode 的集群配置服务的更多信息，请参阅产品文档。

5.4.2. 配置一个 Apache Geode 缓存服务器

Spring Data for Apache Geode 包括对配置CacheServer 的专用支持，允许通过 Spring 容器进行完整配置，如以下示例所示：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:gfe="https://www.springframework.org/schema/geode"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
    https://www.springframework.org/schema/geode https://www.springframework.org/schema/geode/spring-geode.xsd
">

  <gfe:cache/>

  <!-- Example depicting serveral Apache Geode CacheServer configuration options -->
  <gfe:cache-server  auto-startup="true"
       bind-address="localhost" host-name-for-clients="localhost" port="${gemfire.cache.server.port}"
       load-poll-interval="2000" max-connections="22" max-message-count="1000" max-threads="16"
       max-time-between-pings="30000" groups="test-server">

    <gfe:subscription-config eviction-type="ENTRY" capacity="1000" disk-store="file://${java.io.tmpdir}"/>

  </gfe:cache-server>

  <context:property-placeholder location="classpath:cache-server.properties"/>

</beans>

前面的配置显示了元素和许多可用选项。cache-server

此配置不是对端口进行硬编码，而是使用 Spring 的上下文命名空间来声明 a。属性占位符读取一个或多个属性文件，然后在运行时将属性占位符替换为值。这样做可以让管理员无需接触主应用程序配置即可更改值。Spring 还提供了SpEL和环境抽象，以支持从主代码库外部化特定于环境的属性，从而简化跨多台机器的部署。`property-placeholder`

为了避免初始化问题，Spring Data for Apache Geode 的启动在 Spring 容器之后启动已完全初始化。这样做可以让潜在的区域、侦听器、编写器或实例化定义以声明方式在服务器开始接受连接之前完全初始化和注册。请记住这一点以编程方式配置这些元素时，因为服务器可能会在组件之前启动，因此看不到由客户端立即连接。`CacheServer`

5.4.3. 配置 Apache Geode 客户端缓存

除了定义 Apache Geode 对等缓存之外， Spring Data for Apache Geode 还支持在 Spring 容器中定义 Apache GeodeClientCache。Adefinition在配置和使用上类似于Apache Geode对等缓存，并且受支持。ClientCacheorg.springframework.data.gemfire.client.ClientCacheFactoryBean

使用默认配置的 Apache Geode 缓存客户端的最简单定义如下：

<beans>
  <gfe:client-cache/>
</beans>

client-cache支持许多与缓存元素相同的选项。然而，相反对于成熟的对等成员，缓存客户端通过池连接到远程缓存服务器。默认情况下，创建池以连接到在端口上运行和侦听的服务器。使用默认池由所有客户端区域提供，除非该区域配置为使用特定池。Cachelocalhost40404

可以使用元素定义池。此客户端池可用于配置直接连接到单个实体的服务器或通过一个或多个定位器用于整个缓存。pool

例如，要自定义使用的默认池，开发人员需要定义一个池并连接它到缓存定义，如以下示例所示：client-cache

<beans>
  <gfe:client-cache  pool-name="myPool"/>

  <gfe:pool  subscription-enabled="true">
    <gfe:locator host="${gemfire.locator.host}" port="${gemfire.locator.port}"/>
  </gfe:pool>
</beans>

该元素也有属性。如果该属性设置为，则客户端缓存初始化包括对ClientCache.readyForEvents（）的调用。<client-cache>ready-for-eventstrue

客户端区域更详细地介绍了客户端配置。

Apache Geode 的默认池和 Apache Geode 池定义的 Spring 数据

如果 Apache Geodeis 仅限本地，则不需要池定义。例如，您可以定义以下内容：ClientCache

<gfe:client-cache/>

<gfe:client-region  shortcut="LOCAL"/>

在这种情况下，“示例”区域是，并且客户端和服务器之间不会分布任何数据。因此不需要游泳池。这适用于任何客户端，仅限本地的区域，如Apache Geode的ClientRegionShortcut（allshortcuts）所定义的那样。LOCALLOCAL_*

但是，如果客户端区域是服务器端区域的（缓存）代理，则需要池。在这种情况下，有几种方法可以定义和使用池。

当一个、一个池和一个基于代理的区域都已定义但未明确标识时，Spring Data for Apache Geode 自动解析引用，如以下示例所示：ClientCache

<gfe:client-cache/>

<gfe:pool>
  <gfe:locator host="${geode.locator.host}" port="${geode.locator.port}"/>
</gfe:pool>

<gfe:client-region  shortcut="PROXY"/>

在前面的示例中，标识为，池为，和客户端区域作为“示例”。但是，初始化Apache Geode的Pool 从，和客户端区域使用时在客户端之间分发数据和服务器。ClientCachegemfireCachegemfirePoolClientCacheDEFAULTgemfirePoolgemfirePool

基本上，Spring Data for Apache Geode 将上述配置解析为以下内容：

<gfe:client-cache  pool-name="gemfirePool"/>

<gfe:pool >
  <gfe:locator host="${geode.locator.host}" port="${geode.locator.port}"/>
</gfe:pool>

<gfe:client-region  cache-ref="gemfireCache" pool-name="gemfirePool" shortcut="PROXY"/>

Apache Geode 仍然创建了一个名为 Pool 的 Pool。Apache Geode 的 Spring 数据导致 Pool 被初始化从。在定义了多个池和客户端区域的情况下，这样做很有用正在使用单独的池，或者根本不声明池。DEFAULTDEFAULTgemfirePool

请考虑以下事项：

<gfe:client-cache pool-name="locatorPool"/>

<gfe:pool >
  <gfe:locator host="${geode.locator.host}" port="${geode.locator.port}"/>
</gfe:pool>

<gfe:pool >
  <gfe:server host="${geode.server.host}" port="${geode.server.port}"/>
</gfe:pool>

<gfe:client-region  pool-name="serverPool" shortcut="PROXY"/>

<gfe:client-region  shortcut="CACHING_PROXY"/>

<gfe:client-region  shortcut="LOCAL"/>

在此设置中，Apache Geodepool 初始化自，由属性指定。Apache Geode定义的没有弹簧数据，因为两个池分别被明确标识（命名）和。client-cacheDEFAULTlocatorPoolpool-namegemfirePoollocatorPoolserverPool

“示例”区域明确引用并专门使用。区域使用 Apache Geode'sPool，同样，它是从基于客户端缓存配置的 Bean 定义的属性。serverPoolAnotherExampleDEFAULTlocatorPoolpool-name

最后，区域不使用池，因为它是。YetAnotherExampleLOCAL

区域将首先查找名为池豆，但这需要匿名池 Bean（即）或显式命名的池 Bean 的定义（例如，）。`AnotherExample``gemfirePool``<gfe:pool/>``gemfirePool``<gfe:pool />`

如果我们更改名称oftoor使池豆定义是匿名的，它将具有与上述配置相同的效果。`locatorPool``gemfirePool`

5.5. 配置地域

需要区域才能从接口 cache.is 存储和检索数据扩展和使用熟悉的键值语义启用基本数据访问。界面连接到需要它的应用程序类中，以便实际区域类型与编程模型分离。通常，每个区域都与一个域对象相关联，类似于关系数据库中的表。org.apache.geode.cache.Regionjava.util.MapRegion

Apache Geode 实现了以下类型的区域：

复制 - 数据在定义区域的集群中的所有缓存成员之间复制。这提供了非常高的读取性能，但执行复制需要更长的写入时间。
PARTITION- 数据在集群中的许多缓存成员之间分区为存储桶（分片），这些缓存成员定义区域。这提供了很高的读写性能，适用于太大的大型数据集。对于单个节点。
本地 - 数据仅存在于本地节点上。
客户端 - 从技术上讲，客户端区域是一个本地区域，充当复制或分区区域的代理托管在群集中的缓存服务器上。它可以保存在本地创建或获取的数据。或者，它可以为空。本地更新将同步到缓存服务器。此外，客户端区域可以订阅事件，以便与访问同一服务器区域的远程进程产生的更改保持同步。

有关各种区域类型及其功能以及配置选项的更多信息，请参考 Apache Geode 关于区域类型的文档。

5.5.1. 使用外部配置的区域

要引用已在 Apache Geode 本机文件中配置的区域，请使用 theelement。只需使用属性声明目标区域名称即可。例如，声明标识的 Bean 定义对于命名的现有区域，您可以使用以下 Bean 定义：cache.xmllookup-regionnameordersRegionOrders

<gfe:lookup-region  name="Orders"/>

未指定 ifis，则 bean 将用作区域的名称。上面的示例变为：nameid

<!-- lookup for a Region called 'Orders' -->
<gfe:lookup-region />

如果该区域不存在，将引发初始化异常。要配置新区域，继续执行下面的相应部分。

在前面的示例中，由于没有显式定义缓存名称，因此默认命名约定（）被使用了。或者，可以使用属性引用缓存 bean：gemfireCachecache-ref

<gfe:cache />
<gfe:lookup-region  name="Orders" cache-ref="myCache"/>

lookup-region允许您检索现有的预配置区域，而无需公开区域语义或设置基础结构。

5.5.2. 自动区域查找

auto-region-lookup允许您将 Apache Geode 本机文件中定义的所有区域导入到 a 春天当你在元素上使用属性时。cache.xmlApplicationContextcache-xml-location<gfe:cache>

例如，请考虑以下文件：cache.xml

<?xml version="1.0" encoding="UTF-8"?>
<cache xmlns="https://geode.apache.org/schema/cache"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://geode.apache.org/schema/cache https://geode.apache.org/schema/cache/cache-1.0.xsd"
       version="1.0">

  <region name="Parent" ref>
    <region name="Child" ref/>
  </region>

</cache>

您可以按如下方式导入前面的文件：cache.xml

<gfe:cache cache-xml-location="cache.xml"/>

然后，您可以使用元素（例如）来引用特定区域作为 Spring 容器中的 bean，或者您可以选择使用以下方法导入中定义的所有区域：<gfe:lookup-region><gfe:lookup-region />cache.xml

<gfe:auto-region-lookup/>

Apache Geode 的 Spring Data 会自动为所有 Apache Geode 区域中定义的 bean 创建尚未使用显式 bean 声明显式添加到 Spring 容器中。cache.xml<gfe:lookup-region>

重要的是要认识到，Spring Data for Apache Geode 使用 SpringBeanPostProcessor在创建和初始化缓存以确定 Apache Geode 中定义的区域后处理缓存。在春天添加为豆子。ApplicationContext

您可以注入这些“自动查找”的区域，就像注入春季中定义的任何其他 bean 一样，除了一个例外：您可能需要定义与 'gemfireCache' bean 的关联，如下所示：ApplicationContextdepends-on

package example;

import ...

@Repository("appDao")
@DependsOn("gemfireCache")
public class ApplicationDao extends DaoSupport {

    @Resource(name = "Parent")
    private Region<?, ?> parent;

    @Resource(name = "/Parent/Child")
    private Region<?, ?> child;

    ...
}

前面的示例仅适用于使用 Spring 的功能。component-scan

如果使用 Spring XML 配置声明组件，则需要执行以下操作：

<bean class="example.ApplicationDao" depends-on="gemfireCache"/>

这样做可确保 Apache Geode 缓存和之前创建的所有区域定义的 inget 使用元素时具有自动连线引用的任何组件。cache.xml<gfe:auto-region-lookup>

5.5.3. 配置区域

Spring Data for Apache Geode 通过以下元素为配置任何类型的区域提供了全面的支持：

本地区域：<local-region>
分区区域：<partitioned-region>
复制区域：<replicated-region>
客户区域：<client-region>

有关区域类型的全面说明，请参阅 Apache Geode 文档。

公共区域属性

下表列出了可用于所有区域类型的属性：

Table 1. Common Region Attributes

名字	值	描述
缓存引用	Apache Geode Cache Bean 参考	定义 Apache Geode Cache 的 Bean 的名称（默认情况下，“gemfireCache”）。
已启用克隆	布尔值（默认值：`false`)	当更新应用于值的克隆，然后将克隆保存到缓存时。何时，在缓存中就地修改值。`true``false`
关闭	布尔值（默认值：`false`)	确定是否应在关闭时关闭区域。
启用并发检查	布尔值（默认值：`true`)	确定成员是否执行检查以对分布式区域的并发更新或无序更新提供一致的处理。
数据策略	请参阅 Apache Geode的数据策略。	该地区的数据政策。请注意，并非所有区域类型都支持所有数据策略。
摧毁	布尔值（默认值：`false`)	确定是否应在关闭时销毁区域。
磁盘存储参考	已配置磁盘存储的名称。	对通过元素创建的 Bean 的引用。`disk-store`
磁盘同步	布尔值（默认值：`true`)	确定磁盘存储写入是否同步。
编号	任何有效的 Bean 名称。	默认区域名称（如果指定了 noattribute）。`name`
忽略如果存在	布尔值（默认值：`false`)	如果缓存中已存在区域，则忽略此 Bean 定义，从而导致查找。
忽略-JTA	布尔值（默认值：`false`)	确定此区域是否参与 JTA（Java 事务 API）事务。
索引更新类型	`synchronous`或（默认：`asynchronous``synchronous`)	确定索引是在创建条目时同步更新还是异步更新。
初始容量	整数（默认值：16）	区域条目数的初始内存分配。
键约束	任何有效的完全限定的 Java 类名。	预期的密钥类型。
负载系数	浮点数（默认值：.75）	设置用于存储区域条目的底层的初始参数。`java.util.ConcurrentHashMap`
名字	任何有效的区域名称。	区域的名称。如果未指定，则假定属性的值（即 Bean 名称）。`id`
持续	*布尔值（默认值：`false`)	确定区域是否将条目保存到本地磁盘（磁盘存储）。
捷径	请参阅https://geode.apache.org/releases/latest/javadoc/org/apache/geode/cache/RegionShortcut.html	对于这个地区。允许根据预定义的默认值轻松初始化区域。`RegionShortcut`
统计学	布尔值（默认值：`false`)	确定区域是否报告统计信息。
模板	区域模板的名称。	对通过其中一个元素创建的 Bean 的引用。`*region-template`
值约束	任何有效的完全限定的 Java 类名。	预期值类型。

`CacheListener`实例

CacheListener实例注册到区域以处理区域事件，例如创建条目时，更新、销毁等。A可以是实现CacheListener接口的任何 bean。一个区域可以有多个侦听器，使用嵌套在包含元素中的元素声明。CacheListenercache-listener*-region

下面的示例声明了两个。第一个引用一个命名的*春豆。第二个是匿名的内豆定义。CacheListener’s

<bean  class="org.example.app.geode.cache.SimpleCacheListener"/>

<gfe:replicated-region >
  <gfe:cache-listener>
    <!-- nested CacheListener bean reference -->
    <ref bean="myListener"/>
    <!-- nested CacheListener bean definition -->
    <bean class="org.example.app.geode.cache.AnotherSimpleCacheListener"/>
  </gfe:cache-listener>
</gfe:replicated-region>

下面的示例使用具有属性的元素的替代形式。这样做可以在定义单个时进行更简洁的配置。cache-listenerrefCacheListener

注意：XML 命名空间只允许单个元素，因此必须使用前面的示例或以下示例中的样式。cache-listener

<beans>
  <gfe:replicated-region >
    <gfe:cache-listener ref="myListener"/>
  </gfe:replicated-region>

  <bean  class="example.CacheListener"/>
</beans>

在元素中使用和嵌套声明是非法的。这两个选项是互斥的，在同一元素中使用这两个选项会导致异常。`ref``cache-listener`

Bean 引用约定 Theelement 是 XML 命名空间中使用的常见模式的示例 Apache Geode 提供要实现的回调接口，以便调用自定义代码以响应缓存或区域事件。当你使用Spring的IoC容器时，实现是一个标准的Spring bean。为了简化配置，架构允许元素的单次出现，但是，如果允许多个实例，它可以包含嵌套的 Bean 引用和内部 Bean 定义以任意组合。惯例是使用单数形式（即，vs），反映最常见的情况是，事实上，单个实例。我们已经在高级缓存配置示例中看到了此模式的示例。`cache-listener``cache-listener``cache-listener``cache-listeners`

CacheLoaders 和 CacheWriters

类似于，XML 命名空间提供要注册的沙元素这些区域的 Apache Geode 组件。cache-listenercache-loadercache-writer

AI 在缓存未命中时调用，以允许从外部数据源（如数据库）加载条目。在创建或更新条目之前调用的 AIS，以允许将条目同步到外部数据源。主要区别在于 Apache Geode 最多支持一个 andper 区域的实例。但是，可以使用任一声明样式。CacheLoaderCacheWriterCacheLoaderCacheWriter

以下示例声明了一个同时包含 a 和 a 的区域：CacheLoaderCacheWriter

<beans>
  <gfe:replicated-region >
    <gfe:cache-loader ref="myLoader"/>
    <gfe:cache-writer>
      <bean class="example.CacheWriter"/>
    </gfe:cache-writer>
  </gfe:replicated-region>

  <bean  class="example.CacheLoader">
    <property name="dataSource" ref="mySqlDataSource"/>
  </bean>

  <!-- DataSource bean definition -->
</beans>

有关更多详细信息，请参阅 Apache Geode 文档中的CacheLoader和CacheWriter。

5.5.4. 压缩

Apache Geode 区域也可以压缩，以便将 JVM 内存消耗和压力降低到避免使用全局 GC。为某个区域启用压缩时，将压缩该区域内存中存储的所有值，而键和索引保持未压缩状态。新值放入区域时被压缩，所有值从区域读回时自动解压缩。值持久保存到磁盘时不压缩或通过线路发送给其他对等成员或客户端时。

以下示例显示启用了压缩的区域：

<beans>
  <gfe:replicated-region >
    <gfe:compressor>
      <bean class="org.apache.geode.compression.SnappyCompressor"/>
    </gfe:compressor>
  </gfe:replicated-region>
</beans>

有关区域压缩的更多信息，请参阅 Apache Geode 的文档。

5.5.5. 堆外

Apache Geode 区域也可以配置为将区域值存储在堆外内存中，这是不受垃圾回收（GC）约束的 JVM 内存。通过避免昂贵的气相色谱循环，您的应用可以将更多时间花在重要的事情上，例如处理请求。

使用堆外内存非常简单，只需声明要使用的内存量，然后启用区域使用堆外内存，如以下配置所示：

<util:properties >
    <prop key="off-heap-memory-size">200G</prop>
</util:properties>

<gfe:cache properties-ref="gemfireProperties"/>

<gfe:partitioned-region  off-heap="true"/>

您可以通过设置以下 Apache Geode 配置来控制堆外内存管理的其他方面使用元素的属性：S<gfe:cache>

<gfe:cache critical-off-heap-percentage="90" eviction-off-heap-percentage"80"/>

Apache Geode将使用这两个阈值（&）以大致相同的方式更有效地管理堆外内存就像 JVM 在管理堆内存时所做的那样。Apache Geode将阻止缓存通过逐出旧数据来消耗过多的堆外内存。如果堆外管理器无法跟上，然后，将添加内容融合到缓存中，直到堆外内存管理器释放为止足够的内存量。ResourceManagercritical-off-heap-percentageeviction-off-heap-percentageResourceManagerResourceManager

有关管理堆和堆外内存的更多信息，请参阅 Apache Geode 的文档。

具体而言，请阅读管理堆外内存部分。

5.5.6. 次区域

Spring Data for Apache Geode 还支持子区域，允许区域以分层关系排列。

例如，Apache Geode 允许 aRegion 和不同的区域。此外，子区域可能有自己的子区域和配置。子区域不继承属性来自其父区域。区域类型可以根据 Apache Geode 约束进行混合和匹配。一个次区域自然被声明为区域的子元素。子区域的属性是简单名称。前面的示例可以按如下方式配置：/Customer/Address/Employee/Addressname

<beans>
  <gfe:replicated-region name="Customer">
    <gfe:replicated-region name="Address"/>
  </gfe:replicated-region>

  <gfe:replicated-region name="Employee">
    <gfe:replicated-region name="Address"/>
  </gfe:replicated-region>
</beans>

请注意，子区域不允许使用该属性。使用 Bean 名称创建子区域（在本例中分别为 /客户/地址和/员工/地址）。因此，它们可以注入其他应用程序使用区域的完整路径名需要它们的 bean，例如 a。完整路径名的区域也应该在 OQL 查询字符串中使用。Monospaced ([id])GemfireTemplate

5.5.7. Region Templates

Spring Data for Apache Geode also supports Region templates.

This feature allows developers to define common Region configuration and attributes once and reuse the configuration among many Region bean definitions declared in the Spring .ApplicationContext

Spring Data for Apache Geode includes five Region template tags in its namespace:

Table 2. Region Template Tags

标签名称	描述
`<gfe:region-template>`	定义通用泛型区域属性。扩展 XML 命名空间。`regionType`
`<gfe:local-region-template>`	定义通用的“本地”区域属性。扩展 XML 命名空间。`localRegionType`
`<gfe:partitioned-region-template>`	定义通用的“分区”区域属性。扩展 XML 命名空间。`partitionedRegionType`
`<gfe:replicated-region-template>`	定义通用的“复制”区域属性。扩展 XML 命名空间。`replicatedRegionType`
`<gfe:client-region-template>`	定义常见的“客户端”区域属性。扩展 XML 命名空间。`clientRegionType`

除了标签，具体元素（以及抽象元素）具有用于定义区域模板的属性，区域从中继承其配置。区域模板甚至可以从其他区域模板继承。<gfe:*-region><gfe:*-region-template>template

以下示例显示了一种可能的配置：

<beans>
  <gfe:async-event-queue  persistent="false" parallel="false" dispatcher-threads="4">
    <gfe:async-event-listener>
      <bean class="example.AeqListener"/>
    </gfe:async-event-listener>
  </gfe:async-event-queue>

  <gfe:region-template  initial-capacity="51" load-factor="0.85" persistent="false" statistics="true"
      key-constraint="java.lang.Long" value-constraint="java.lang.String">
    <gfe:cache-listener>
      <bean class="example.CacheListenerOne"/>
      <bean class="example.CacheListenerTwo"/>
    </gfe:cache-listener>
    <gfe:entry-ttl timeout="600" action="DESTROY"/>
    <gfe:entry-tti timeout="300 action="INVLIDATE"/>
  </gfe:region-template>

  <gfe:region-template  template="BaseRegionTemplate" load-factor="0.55">
    <gfe:cache-loader>
      <bean class="example.CacheLoader"/>
    </gfe:cache-loader>
    <gfe:cache-writer>
      <bean class="example.CacheWriter"/>
    </gfe:cache-writer>
    <gfe:async-event-queue-ref bean="AEQ"/>
  </gfe:region-template>

  <gfe:partitioned-region-template  template="ExtendedRegionTemplate"
      copies="1" load-factor="0.70" local-max-memory="1024" total-max-memory="16384" value-constraint="java.lang.Object">
    <gfe:partition-resolver>
      <bean class="example.PartitionResolver"/>
    </gfe:partition-resolver>
    <gfe:eviction type="ENTRY_COUNT" threshold="8192000" action="OVERFLOW_TO_DISK"/>
  </gfe:partitioned-region-template>

  <gfe:partitioned-region  template="PartitionRegionTemplate"
      copies="2" local-max-memory="8192" persistent="true" total-buckets="91"/>
</beans>

区域模板也适用于子区域。请注意，“TemplateBasedPartitionRegion”扩展了“PartitionRegionTemplate”，它扩展了“ExtendedRegionTemplate”，扩展了“BaseRegionTemplate”。中定义的属性和子元素随后继承的区域 Bean 定义将覆盖父区域 Bean 定义中的内容。

模板的工作原理

Spring Data for Apache Geode 在解析 Springconfiguration 元数据时应用区域模板，因此，区域模板必须按继承顺序声明。换句话说，必须在之前定义父模板子模板。这样做可确保应用正确的配置，尤其是在元素属性时或覆盖子元素。ApplicationContext

	同样重要的是要记住，区域类型只能继承自其他类似类型的区域。例如，ato 不可能从 a 继承。`<gfe:replicated-region>``<gfe:partitioned-region-template>`

	区域模板是单一继承的。

有关区域、子区域和查找的注意事项

以前，底层属性之一,,, 和 Spring Data for Apache Geode XML 命名空间中的元素是先执行查找，然后再尝试创建区域。这是在区域已经存在的情况下进行的，如果定义了区域，就会出现这种情况在导入的 Apache Geode 本机配置文件中。因此，首先执行了查找以避免任何错误。这是设计使然，可能会发生变化。replicated-regionpartitioned-regionlocal-regionclient-regioncache.xml

此行为已更改，默认行为现在是先创建区域。如果区域已存在，则创建逻辑快速失败并引发相应的异常。但是，与DDL语法非常相似，Apache GeodeXML命名空间元素的Spring Data现在包括 aattribute，通过首先执行现有区域的查找来恢复旧行为在尝试创建区域之前按名称标识。如果按名称找到现有区域并设置为，则忽略 Spring 配置中定义的区域 Bean 定义。CREATE TABLE IF NOT EXISTS …<gfe:*-region>ignore-if-existsignore-if-existstrue

Spring团队强烈建议,,, 和 XML 命名空间元素仅用于定义新区域。可能出现的一个问题当这些元素定义的区域已存在并且区域元素首先执行查找时，如果您在应用程序配置，则区域定义可能不匹配，并且可能表现出与所需行为相反的行为通过应用程序。更糟糕的是，您可能希望将区域定义为分布式区域（例如，）事实上，现有区域定义仅为本地定义。`replicated-region``partitioned-region``local-region``client-region``PARTITION`

建议的做法 - 仅使用,,,和 XML 命名空间元素来定义新区域。`replicated-region``partitioned-region``local-region``client-region`

请考虑以下本机 Apache Geodeconfiguration 文件：cache.xml

<?xml version="1.0" encoding="UTF-8"?>
<cache xmlns="https://geode.apache.org/schema/cache"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://geode.apache.org/schema/cache https://geode.apache.org/schema/cache/cache-1.0.xsd"
       version="1.0">

  <region name="Customers" ref>
    <region name="Accounts" ref>
      <region name="Orders" ref>
        <region name="Items" ref/>
      </region>
    </region>
  </region>

</cache>

此外，考虑到您可能已经按如下方式定义了一个应用程序 DAO：

public class CustomerAccountDao extends GemDaoSupport {

    @Resource(name = "Customers/Accounts")
    private Region customersAccounts;

    ...
}

在这里，我们在应用程序 DAO 中注入对 Region 的引用。因此，它是开发人员在Spring XML配置中为部分或全部这些区域定义bean的情况并不少见元数据如下：Customers/Accounts

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:gfe="https://www.springframework.org/schema/geode"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
    https://www.springframework.org/schema/geode https://www.springframework.org/schema/geode/spring-geode.xsd
">

  <gfe:cache cache-xml-location="classpath:cache.xml"/>

  <gfe:lookup-region name="Customers/Accounts"/>
  <gfe:lookup-region name="Customers/Accounts/Orders"/>

</beans>

TheandRegions 在 Spring 容器中被引用为 bean 分别是阿桑德。使用 theelement 和相应的语法（如前所述）的好处是，它允许您直接引用子区域，而无需不必要地为父区域定义 Bean（在本例中为）。Customers/AccountsCustomers/Accounts/OrdersCustomers/AccountsCustomers/Accounts/Orderslookup-regionCustomers

请考虑以下错误示例，该示例将配置元数据语法更改为使用嵌套格式：

<gfe:lookup-region name="Customers">
  <gfe:lookup-region name="Accounts">
    <gfe:lookup-region name="Orders"/>
  </gfe:lookup-region>
</gfe:lookup-region>

现在考虑另一个不好的例子，它使用*元素以及设置为首先执行查找的属性：replicated-regionignore-if-exists

<gfe:replicated-region name="Customers" persistent="true" ignore-if-exists="true">
  <gfe:replicated-region name="Accounts" persistent="true" ignore-if-exists="true">
    <gfe:replicated-region name="Orders" persistent="true" ignore-if-exists="true"/>
  </gfe:replicated-region>
</gfe:replicated-region>

Spring 中定义的 Region bean 由以下内容组成：这意味着依赖注入的引用前面的例子（即）现在被破坏了，因为实际上没有定义带有 nameis 的 bean。因此，您不应按中所示配置区域前面两个示例。ApplicationContext{ "Customers", "/Customers/Accounts", "/Customers/Accounts/Orders" }.@Resource(name = "Customers/Accounts")Customers/Accounts

Apache Geode可以灵活地引用父区域和子区域，无论是否具有前导斜线。例如，可以引用父 asor和子 asor。但是，Apache Geode 的 Spring 数据在以区域命名 bean 时非常具体。它总是使用正斜杠（/）表示子区域（例如，）。/CustomersCustomers/Customers/AccountsCustomers/Accounts/Customers/Accounts

因此，应使用前面所示的非嵌套语法或使用定义直接引用前导正斜杠（/），如下所示：lookup-region

<gfe:lookup-region name="/Customers/Accounts"/>
<gfe:lookup-region name="/Customers/Accounts/Orders"/>

前面的示例（其中嵌套元素用于引用子区域）显示前面提到的问题。客户、账户和订单区域和子区域是否持续存在？它们不是持久性的，因为区域是在本机 Apache Geodeprofile 文件中定义的 asand 在缓存 Bean 初始化之前就存在（一旦元素被处理）。replicated-regioncache.xmlREPLICATE<gfe:cache>

5.5.8. 数据逐出（带溢出）

根据各种约束，每个区域都可以制定逐出策略，用于从内存中逐出数据。目前，在 Apache Geode 中，逐出适用于最近最少使用的条目（也称为LRU）。被驱逐的条目将被销毁或分页到磁盘（称为“溢出到磁盘”）。

Spring Data for Apache Geode 支持分区区域、复制区域、和客户端，使用嵌套元素的本地区域。eviction

例如，要将分区区域配置为在内存大小超过 512 MB 时溢出到磁盘，您可以指定以下配置：

<gfe:partitioned-region >
  <gfe:eviction type="MEMORY_SIZE" threshold="512" action="OVERFLOW_TO_DISK"/>
</gfe:partitioned-region>

副本无法使用逐出，因为这会使它们失效。有关更多信息，请参阅 Apache Geode 文档。`local destroy`

为溢出配置区域时，应通过元素配置存储实现最高效率。disk-store

有关逐出策略的详细说明，请参阅有关逐出的 Apache Geode 文档。

5.5.9. 数据过期

Apache Geode 允许您控制条目在缓存中存在多长时间。过期由经过的时间驱动，与逐出相反，逐出由条目计数或堆或内存使用情况驱动。一旦条目过期，可能不再从缓存中访问它。

Apache Geode 支持以下过期类型：

生存时间（TTL）：对象在上次创建后可能保留在缓存中的时间量（以秒为单位）或更新。对于条目，创建和放置操作的计数器设置为零。区域计数器在以下情况下重置创建区域以及条目何时重置计数器。
空闲超时（TTI）：对象在上次访问后可能保留在缓存中的时间量（以秒为单位）。每当重置对象的 TTL 计数器时，都会重置对象的空闲超时计数器。此外，条目的每当通过 get 操作或访问条目时，都会重置空闲超时计数器。每当某个条目重置其某个条目的空闲超时时，区域的空闲超时计数器就会重置。netSearch

其中每一项都可能适用于区域本身或区域中的条目。Spring Data for Apache Geode 提供,,, 和 Region 子元素来指定超时值和过期操作。<region-ttl><region-tti><entry-ttl><entry-tti>

以下示例显示了设置了过期值的区域：PARTITION

<gfe:partitioned-region >
  <gfe:region-ttl timeout="30000" action="INVALIDATE"/>
  <gfe:entry-tti timeout="600" action="LOCAL_DESTROY"/>
</gfe:replicated-region>

有关过期策略的详细说明，请参阅有关过期的 Apache Geode 文档。

基于注释的数据过期

使用 Spring Data for Apache Geode，您可以定义各个区域条目值的过期策略和设置（或者，将它不同，直接在应用程序域对象上）。例如，您可以在 a 基于会话的应用程序域对象，如下所示：

@Expiration(timeout = "1800", action = "INVALIDATE")
public class SessionBasedApplicationDomainObject {
  ...
}

您还可以分别使用空闲超时（TTI）和生存时间（TTL）过期的注释，在区域条目上指定特定于过期类型的设置，如以下示例所示：@IdleTimeoutExpiration@TimeToLiveExpiration

@TimeToLiveExpiration(timeout = "3600", action = "LOCAL_DESTROY")
@IdleTimeoutExpiration(timeout = "1800", action = "LOCAL_INVALIDATE")
@Expiration(timeout = "1800", action = "INVALIDATE")
public class AnotherSessionBasedApplicationDomainObject {
  ...
}

Bothand优先于通用注释指定了多个过期批注类型时，如前面的示例所示。两者都不凌驾于另一个之上。相反，他们互相赞美配置了不同的区域条目过期策略（例如 TTL 和 TTI）时。@IdleTimeoutExpiration@TimeToLiveExpiration@Expiration@IdleTimeoutExpiration@TimeToLiveExpiration

基于全部的注释仅适用于区域条目值。区域到期时间不在 Spring Data for Apache Geode 的过期注释支持。但是，Apache Geode 和 Spring Data for Apache Geode 确实允许您设置区域过期时间。通过使用 SDG XML 命名空间，如下所示：`@Expiration` <gfe:-region persistent="false"> <gfe:region-ttl timeout="600" action="DESTROY"/> <gfe:region-tti timeout="300" action="INVALIDATE"/> </gfe:-region>

Spring Data for Apache Geode'sannotation support是通过Apache Geode的CustomExpiry接口实现的。有关更多详细信息，请参阅 Apache Geode 关于配置数据过期的文档@Expiration

Apache Geodeclass（和实现）的Spring Data负责处理 SDG注释并为区域适当应用过期策略配置条目根据请求过期。AnnotationBasedExpirationCustomExpiry@Expiration

使用 Spring Data for Apache Geode 配置特定的 Apache Geode 区域以适当地将过期策略应用于使用基于批注的应用程序域对象必须：@Expiration

在 Springof 类型中定义 Bean，方法是使用适当的构造函数或方便的工厂方法之一。为特定过期类型配置过期时，例如空闲超时（TTI）或生存时间（TTL），则应在类，如下所示：ApplicationContextAnnotationBasedExpirationAnnotationBasedExpiration

<bean  class="org.springframework.data.gemfire.expiration.AnnotationBasedExpiration"
      factory-method="forTimeToLive"/>

<gfe:partitioned-region  persistent="false">
    <gfe:custom-entry-ttl ref="ttlExpiration"/>
</gfe:partitioned-region>

若要改为配置空闲超时（TTI）过期，请使用工厂方法以及设置TTI的元素。`forIdleTimeout``<gfe:custom-entry-tti ref="ttiExpiration"/>`

（可选）使用过期策略批注存储在区域中的应用程序域对象以及使用用于 Apache Geode 的 Sannotations 的 Spring 数据之一的自定义设置：，，或@Expiration@Expiration@IdleTimeoutExpiration@TimeToLiveExpiration
（可选）如果特定的应用程序域对象根本没有使用 Spring Data for Apache Geode 的 sannotations 进行注释，但 Apache Geode 区域配置为使用 SDG 的自定义类来确定存储在区域中的对象的过期策略和设置，您可以通过执行以下操作在 Bean 上设置“默认”过期属性：@ExpirationAnnotationBasedExpirationAnnotationBasedExpiration

<bean  class="org.apache.geode.cache.ExpirationAttributes">
    <constructor-arg value="600"/>
    <constructor-arg value="#{T(org.apache.geode.cache.ExpirationAction).DESTROY}"/>
</bean>

<bean  class="org.springframework.data.gemfire.expiration.AnnotationBasedExpiration"
      factory-method="forIdleTimeout">
    <constructor-arg ref="defaultExpirationAttributes"/>
</bean>

<gfe:partitioned-region  persistent="false">
    <gfe:custom-entry-tti ref="ttiExpiration"/>
</gfe:partitioned-region>

您可能已经注意到，Spring Data for Apache Geode'sannotations 使用 aas 属性类型，而不是而不是，也许更恰当的是，强类型——例如，用于“超时”和可持续发展目标用于“操作”。为什么？@ExpirationStringintExpirationActionType

好吧，输入Apache Geode其他功能的Spring Data之一，利用Spring的核心基础设施来简化配置：属性占位符和弹簧表达式语言（SpEL）表达式。

例如，开发人员可以使用属性占位符指定过期“超时”和“操作” 在注释属性中，如以下示例所示：@Expiration

@TimeToLiveExpiration(timeout = "${geode.region.entry.expiration.ttl.timeout}"
    action = "${geode.region.entry.expiration.ttl.action}")
public class ExampleApplicationDomainObject {
  ...
}

然后，在Spring XML配置或JavaConfig中，您可以声明以下bean：

<util:properties >
  <prop key="geode.region.entry.expiration.ttl.timeout">600</prop>
  <prop key="geode.region.entry.expiration.ttl.action">INVALIDATE</prop>
  ...
</util:properties>

<context:property-placeholder properties-ref="expirationProperties"/>

当多个应用程序域对象可能共享类似的过期策略时，以及当您希望外部化配置。

但是，您可能需要由正在运行的系统的状态确定的更多动态过期配置。这是哪里 SpEL的强大功能开始发挥作用，实际上是推荐的方法。你不仅可以参考豆子在 Spring 容器中并访问 Bean 属性、调用方法等，但过期值为“超时” 并且“操作”可以强类型化。请考虑以下示例（该示例基于前面的示例构建）：

<util:properties >
  <prop key="geode.region.entry.expiration.ttl.timeout">600</prop>
  <prop key="geode.region.entry.expiration.ttl.action">#{T(org.springframework.data.gemfire.expiration.ExpirationActionType).DESTROY}</prop>
  <prop key="geode.region.entry.expiration.tti.action">#{T(org.apache.geode.cache.ExpirationAction).INVALIDATE}</prop>
  ...
</util:properties>

<context:property-placeholder properties-ref="expirationProperties"/>

然后，在应用程序域对象上，可以定义超时和操作，如下所示：

@TimeToLiveExpiration(timeout = "@expirationSettings['geode.region.entry.expiration.ttl.timeout']"
    action = "@expirationSetting['geode.region.entry.expiration.ttl.action']")
public class ExampleApplicationDomainObject {
  ...
}

你可以想象，'expirationSettings' bean 可能是一个比一个简单的更有趣和有用的对象的实例。在前面的示例中，元素（）使用 SpEL 将操作值基于实际枚举类型，快速导致已识别的故障如果枚举类型发生更改。java.util.PropertiespropertiesexpirationSettingsExpirationAction

例如，所有这些都已在 Spring Data for Apache Geode 测试套件中进行了演示和测试。有关更多详细信息，请参阅来源。

Apache Geode 的 Spring Data（数据）

5.5.10. 数据持久化

区域可以是永久性的。Apache Geode 确保您放入配置的所有数据因为持久性以下次重新创建区域时可恢复的方式写入磁盘。这样做可以让在机器或进程发生故障后，甚至在有序关闭和随后重新启动 Apache Geode 数据节点。

要启用 Spring Data for Apache Geode 的持久性，请将属性设置为任何元素，如以下示例所示：persistenttrue<*-region>

<gfe:partitioned-region  persistent="true"/>

持久性也可以通过设置属性来配置。为此，请将属性的值设置为Apache Geode 的数据策略设置之一，如以下示例所示：data-policy

<gfe:partitioned-region  />

必须与区域类型匹配，并且还必须与属性一致，如果它也是显式设置。如果属性设置为但指定了持久性（例如 asor），则会引发初始化异常。DataPolicypersistentpersistentfalseDataPolicyPERSISTENT_REPLICATEPERSISTENT_PARTITION

为了在持久化区域时获得最大效率，您应该通过元素配置存储。通过使用属性引用的。此外，该区域可能会执行磁盘写入同步或异步。以下示例显示了一个同步：disk-storeDiskStoredisk-store-refDiskStore

<gfe:partitioned-region  persistent="true"
    disk-store-ref="myDiskStore" disk-synchronous="true"/>

配置磁盘存储中将对此进行进一步讨论。

5.5.11. 订阅政策

Apache Geode 允许配置对等（P2P）事件消息传递，以控制区域接收的入口事件。Spring Data for Apache Geode 提供了要设置的子元素订阅策略和区域到任一。以下示例显示其订阅策略设置为的区域：<gfe:subscription/>REPLICATEPARTITIONALLCACHE_CONTENTCACHE_CONTENT

<gfe:partitioned-region >
  <gfe:subscription type="CACHE_CONTENT"/>
</gfe:partitioned-region>

5.5.12. 本地区域

Spring Data for Apache Geode 提供了一个用于创建本地区域的专用元素。本地区域，顾名思义，是独立的，这意味着它们不与任何其他分布式系统成员共享数据。除此之外，所有常见的区域配置选项适用。local-region

下面的示例显示了一个最小声明（同样，该示例依赖于 Spring Data for Apache Geode XML 命名空间命名连接缓存的约定）：

<gfe:local-region />

在前面的示例中，将创建一个本地区域（如果尚不存在同名区域）。的名称区域与 Bean ID （）相同，并且 Bean 假定存在 Apache Geode 缓存命名。exampleLocalRegiongemfireCache

5.5.13. 复制区域

常见的区域类型之一是区域或“副本”。简而言之，当区域配置为 a，托管区域的每个成员都会在本地存储区域条目的副本。任何更新 a区域分发到区域的所有副本。创建副本时，它会通过一个初始化阶段，在该阶段中，它会发现其他副本并自动复制所有条目。当一个副本正在初始化时，您仍然可以继续使用其他副本。REPLICATEREPLICATEREPLICATE

所有常见配置选项都可用于复制区域。Spring Data for Apache Geode 提供了 aelement。下面的示例演示一个最小声明：replicated-region

<gfe:replicated-region />

有关更多详细信息，请参阅 Apache Geode 关于分布式和复制区域的文档。

5.5.14. 分区区域

Spring Data for Apache Geode XML 命名空间也支持 Regions。PARTITION

引用Apache Geode文档：

“分区区域是一个区域，其中数据在托管该区域的对等服务器之间划分，以便每个对等方存储数据的子集。使用分区区域时，应用程序会显示逻辑视图看起来像包含该区域中所有数据的单个地图的区域。读取或写入此映射以透明方式路由到承载作为操作目标的条目的对等方。Apache Geode 将哈希码的域划分为存储桶。每个存储桶都分配给特定的对等方，但可以重新定位随时到另一个对等方，以提高整个集群的资源利用率。

ARegion是使用元素创建的。它的配置选项类似于的添加分区特定的功能，例如冗余副本的数量，最大内存总数、存储桶数、分区解析程序等。PARTITIONpartitioned-regionreplicated-region

以下示例显示如何使用两个冗余副本设置区域：PARTITION

<gfe:partitioned-region  copies="2" total-buckets="17">
  <gfe:partition-resolver>
    <bean class="example.PartitionResolver"/>
  </gfe:partition-resolver>
</gfe:partitioned-region>

有关更多详细信息，请参阅 Apache Geode 关于分区区域的文档。

分区区域属性

下表提供了特定于区域的配置选项的快速概述。这些选项是对常见区域配置选项的补充前面描述过。PARTITION

Table 3. partitioned-region attributes

名字	值	描述
副本	0..4	每个分区的副本数以实现高可用性。默认情况下，不会创建任何副本，这意味着没有冗余。每个副本都以额外的存储空间为代价提供额外的备份。
共置	有效的区域名称	与此新创建的区域并置的区域的名称。`PARTITION``PARTITION`
本地最大内存	正整数	区域在此过程中使用的最大内存量（以 MB 为单位）。
总最大内存	任何整数值	区域在所有进程中使用的最大内存量（以 MB 为单位）。
分区侦听器	豆名	此区域用于处理分区事件的名称。`PartitionListener`
分区解析程序	豆名	此区域用于自定义分区的名称。`PartitionResolver`
恢复延迟	任何多头值	现有成员在另一个成员崩溃后满足冗余之前等待的延迟（以毫秒为单位）。 -1（默认值）表示故障后未恢复冗余。
启动-恢复-延迟	任何多头值	新成员在满足冗余之前等待的延迟（以毫秒为单位）。 -1 表示添加新成员不会触发冗余恢复。默认值是恢复冗余添加新成员时立即添加。

5.5.15. 客户端区域

Apache Geode 支持用于管理和分发数据的各种部署拓扑。主题 Apache Geode 拓扑超出了本文档的范围。然而，快速回顾一下，Apache Geode的支持的拓扑可分为：对等（P2P）、客户端-服务器和广域网（WAN）。在最后两种配置，通常声明连接到缓存服务器的客户端区域。

Spring Data for Apache Geode 通过其客户端缓存元素为每个配置提供专门的支持：and。顾名思义，定义客户端区域，同时定义各客户端区域使用和共享的连接池。client-regionpoolclient-regionpool

以下示例显示了典型的客户端区域配置：

<bean  class="example.CacheListener"/>

<!-- client Region using the default SDG gemfirePool Pool -->
<gfe:client-region >
  <gfe:cache-listener ref="myListener"/>
</gfe:client-region>

<!-- client Region using its own dedicated Pool -->
<gfe:client-region  pool-name="myPool">
  <gfe:cache-listener ref="myListener"/>
</gfe:client-region>

<!-- Pool definition -->
<gfe:pool  subscription-enabled="true">
  <gfe:locator host="remoteHost" port="12345"/>
</gfe:pool>

与其他区域类型一样，支持实例以及 aand a。它还需要一个连接才能连接到一组定位器或服务器。每个客户端区域可以有自己的区域，也可以共享同一个客户端区域。如果未指定池，则将使用“默认”池。client-regionCacheListenerCacheLoaderCacheWriterPoolPool

在前面的示例中，配置了定位器。定位器是用于发现的单独过程分布式系统中的缓存服务器和对等数据成员，建议用于生产系统。它也是可以配置The通过使用元素直接连接到一个或多个缓存服务器。`Pool``Pool``server`

有关要在客户端上（尤其是在客户端上）设置的选项的完整列表，请参阅 Spring Data for Apache Geode schema （“Spring Data for Apache Geode Schema”）和 Apache Geode 关于客户端-服务器配置的文档。Pool

客户兴趣

为了最大限度地减少网络流量，每个客户端可以单独定义自己的“兴趣”策略，指示 Apache Geode它实际需要的数据。在Apache Geode的Spring Data中，可以为每个客户端区域定义“兴趣” 分别。支持基于键和基于正则表达式的兴趣类型。

下面的示例演示基于键和基于正则表达式的类型：interest

<gfe:client-region  pool-name="myPool">
    <gfe:key-interest durable="true" result-policy="KEYS">
        <bean  class="java.lang.String">
             <constructor-arg value="someKey"/>
        </bean>
    </gfe:key-interest>
    <gfe:regex-interest pattern=".*" receive-values="false"/>
</gfe:client-region>

特殊密钥表示为所有密钥注册“利息”。同样可以完成通过使用正则表达式，。ALL_KEYS".\*"

键和正则表达式元素支持三个属性：，，和。<gfe:*-interest>durablereceive-valuesresult-policy

durable指示客户端连接时是否为客户端创建的“兴趣”策略和订阅队列跨客户端会话维护群集中的一个或多个服务器。如果客户离开并回来，客户端的服务器上的订阅队列在客户端断开连接时保持。当客户端重新连接，客户端接收客户端与服务器断开连接时发生的任何事件在群集中。durable

为客户端中定义的每个连接维护群集中服务器上的订阅队列其中订阅也已为此“启用”。订阅队列用于存储（并且可能合并）发送到客户端的事件。如果订阅队列是持久的，它将在客户端会话之间保留（即连接），可能最多达到指定的超时。如果客户端未在给定的时间范围内返回销毁客户端池订阅队列以减少群集中服务器上的资源消耗。如果订阅队列不是，则在客户端断开连接时立即销毁。你需要决定客户端是否应接收断开连接时发生的事件，或者是否只需要接收最新的事件重新连接后的事件。PoolPooldurable

属性指示是否收到创建和更新事件的条目值。如果，则接收到值。如果，则仅接收失效事件。receive-valuestruefalse

最后，“结果策略”是：，和的枚举。默认值为。控制客户端首次连接以初始化本地缓存时的初始转储，实质上是使用与兴趣策略匹配的所有条目的事件为客户端设定种子。KEYSKEYS_VALUENONEKEYS_VALUESresult-policy

如前所述，客户端利益注册如果不启用订阅，就没有多大好处。事实上，在未启用订阅的情况下尝试兴趣注册是错误的。以下示例显示如何操作：Pool

<gfe:pool ... subscription-enabled="true">
  ...
</gfe:pool>

除此之外，您还可以设置，，and.is 用于控制如何订阅队列的许多副本应由群集中的服务器维护。如果冗余大于一个，“主”订阅队列（即服务器）关闭，然后是“辅助”订阅队列接管，防止客户端在 HA 方案中丢失事件。subscription-enabledsubscription-ack-intervalsubscription-message-tracking-timeoutsubscription-redundancysubscription-redundancy

除了设置之外，服务器端区域还使用其他属性，以控制发送到客户端的事件的合并。这也有助于进一步减少网络流量在应用程序只关心条目的最新值的情况下很有用。但是，当应用程序保留发生的事件的时间序列，合并将阻碍该用例。默认值是。以下示例显示了服务器上的区域配置，其客户端包含与此服务器区域中的密钥感兴趣的相应客户端区域：Poolenable-subscription-conflationfalse[CACHING_]PROXY

<gfe:partitioned-region name="ServerSideRegion" enable-subscription-conflation="true">
  ...
</gfe:partitioned-region>

控制在客户端与群集中的服务器断开连接，在元素上设置属性，如下所示：durable-client-timeout<gfe:client-cache>

<gfe:client-cache durable-client-timeout="600">
  ...
</gfe:client-cache>

关于客户利益如何运作和能力的全面深入讨论超出了本文档的范围。

有关更多详细信息，请参阅 Apache Geode 关于客户端到服务器事件分发的文档。

5.5.16. JSON 支持

Apache Geode支持在区域中缓存JSON文档，以及查询存储的JSON的能力。使用 Apache Geode OQL（对象查询语言）的文档。JSON 文档在内部存储为Pdx实例类型通过使用JSONFormatter类以执行与 JSON 文档之间的转换（作为 a）。String

Apache Geode 的 Spring 数据提供了元素，使AOP组件能够建议适当的代理区域操作，它有效地封装了，从而使您的应用程序直接使用 JSON 字符串。<gfe-data:json-region-autoproxy/>JSONFormatter

此外，写入 JSON 配置区域的 Java 对象会使用 Jackson 的自动转换为 JSON。读回这些值时，它们将作为 JSON 字符串返回。ObjectMapper

默认情况下，对所有区域执行转换。应用此功能到选定的区域，在属性中提供以逗号分隔的区域 Bean ID 列表。其他属性包括 aflag（默认为）和。<gfe-data:json-region-autoproxy/>region-refspretty-printfalseconvert-returned-collections

此外，默认情况下，将针对已配置的区域转换 andRegion 操作的结果。这是通过在本地内存中创建并行数据结构来完成的。这可能会产生大量的开销，因为大型集合，因此设置如果您想禁用自动转换对于这些区域操作。getAll()values()convert-returned-collectionsfalse

某些区域操作（特别是那些使用 Apache Geode 专有操作的操作，例如：，andtype）不是 AOP 建议的目标。另外方法（返回 a）也不受影响。`Region.Entry``entries(boolean)``entrySet(boolean)``getEntry()``entrySet()``Set<java.util.Map.Entry<?, ?>>`

以下示例配置显示了如何设置和属性：pretty-printconvert-returned-collections

<gfe-data:json-region-autoproxy region-refs="myJsonRegion" pretty-print="true" convert-returned-collections="false"/>

此功能还可以与操作无缝协作，前提是声明了模板作为春豆。目前不支持本机操作。GemfireTemplateQueryService

5.6. 配置索引

Apache Geode允许在区域数据上创建索引（有时也复数为索引）以提高 OQL（对象查询语言）查询的性能。

在 Apache Geode 的 Spring 数据中，索引是用元素声明的，如以下示例所示：index

<gfe:index  expression="someField" from="/SomeRegion" type="HASH"/>

在 Apache Geode 的 XML 模式（也称为 SDG XML 命名空间）的 Spring 数据中，Bean 声明没有绑定。到一个区域，不像Apache Geode的本地。相反，它们是类似于元素的*元素。这允许您在任何区域上声明任意数量的索引，无论它们是刚刚创建的或者已经存在 - 对Apache Geode的原生格式的重大改进。indexcache.xml<gfe:cache>cache.xml

安必须有一个名字。您可以使用属性指定显式名称。否则，bean 定义的 bean 名称（即属性的值）用作名称。IndexIndexnameidindexIndex

Theand子句构成一个的主要组成部分，标识要索引的数据（即子句中标识的区域）以及使用什么标准（即，）为数据编制索引。应基于谓词中使用的应用程序域对象字段的应用程序定义的 OQL 查询，用于查询和查找存储在区域中的对象。expressionfromIndexfromexpressionexpression

考虑以下示例，该示例具有属性：lastName

@Region("Customers")
class Customer {

  @Id
  Long id;

  String lastName;
  String firstName;

  ...
}

现在考虑以下示例，该示例具有应用程序定义的 SDG 存储库查询对象：Customer

interface CustomerRepository extends GemfireRepository<Customer, Long> {

  Customer findByLastName(String lastName);

  ...
}

SDG 存储库查找器/查询方法会导致生成并运行以下 OQL 语句：

SELECT * FROM /Customers c WHERE c.lastName = '$1'

因此，您可能希望创建类似于以下内容的语句：Index

<gfe:index  name="CustomersLastNameIndex" expression="lastName" from="/Customers" type="HASH"/>

该子句必须引用有效的现有区域，并且是 anget 应用于区域的方式。这不是特定于 Apache Geode 的 Spring Data。这是Apache Geode的一个功能。fromIndex

这可能是Spring Data为Apache Geode的IndexType枚举定义的三个枚举值之一：，和。IndextypeFUNCTIONALHASHPRIMARY_KEY

每个枚举值对应于在创建实际值（或“定义”）时调用的QueryService方法之一 — 您可以找到有关“定义”索引的更多信息，请参阅下一节）。例如，如果是，那么QueryService.createKeyIndex（..）被调用以创建 A。create[|Key|Hash]IndexIndexIndexTypePRIMARY_KEYKEYIndex

默认值 isand 会导致调用其中一个方法。请参阅的 Spring Data for Apache Geode XML schema 提供全套选项。FUNCTIONALQueryService.createIndex(..)

有关在 Apache Geode 中建立索引的更多信息，请参阅“使用索引” 在Apache Geode的用户指南中。

5.6.1. 定义索引

除了创建索引之外，asbean 定义还由 Spring Data 在 Spring 容器上为 Apache Geode 处理初始化时，您还可以在使用属性创建所有应用程序索引之前定义它们，如下所示：Indexdefine

<gfe:index  expression="someField" from="/SomeRegion" define="true"/>

当设置为（默认为）时，它实际上不会在那一刻创建。所有“定义的”索引都是一次创建的，当 Springis “刷新”时，或者说，把它放到一起不同，当 AI 由 Spring 容器发布时。Apache Geode 的 Spring Data 将自身注册为听着。触发时，Spring Data for Apache Geode 调用QueryService.createDefinedIndexes（）。definetruefalseIndexApplicationContextContextRefreshedEventApplicationListenerContextRefreshedEvent

定义索引并一次创建索引可提高创建索引时的速度和效率。

请参阅“一次创建多个索引” 了解更多详情。

5.6.2.和`IgnoreIfExists``Override`

Apache地理取消配置选项的两个弹簧数据值得特别提及：和。IndexignoreIfExistsoverride

这些选项对应于元素上的和属性分别在 Spring Data 中为 Apache Geode 的 XML 命名空间。ignore-if-existsoverride<gfe:index>

在使用这些选项中的任何一个之前，请确保您绝对了解自己在做什么。这些选项可以影响应用程序在运行时消耗的性能和资源（如内存）。结果，两者都默认情况下，这些选项在 SDG 中处于禁用状态（设置为）。`false`

这些选项仅在 Spring Data for Apache Geode 中可用，用于解决 Apache Geode 的已知限制。 Apache Geode没有等效的选项或功能。

每个选项的行为都有很大不同，完全取决于 Apache Geodeexception 的类型扔。这也意味着，如果未引发 Apache Geode 索引类型的异常，则这两个选项都没有任何影响。这些选项旨在专门处理 Apache Geodeand实例，这些实例可能由于各种有时模糊的原因而发生。异常有以下原因：IndexIndexExistsExceptionIndexNameConflictException

当存在另一个具有相同定义但名称不同的示例时，将抛出IndexExistsException，当尝试创建一个。IndexIndex
当存在另一个具有相同名称但可能不同定义时，会抛出IndexNameConflictException时，尝试创建一个。IndexIndex

Spring Data for Apache Geode的默认行为是始终快速失败。因此，默认情况下不会“处理”这两个异常。这些例外被包装在SDG中并重新抛出。如果您希望获得 Apache Geode 的 Spring 数据要为您处理它们，您可以将这些Bean定义选项中的任何一个设置为。IndexIndexGemfireIndexExceptionIndextrue

IgnoreIfExists始终优先，主要是因为它使用的资源较少，仅仅是因为在这两种特殊情况下，它都返回“现有”。OverrideIndex

`IgnoreIfExists`行为

当 anis 抛出 andis 设置为（或）时，那么由这个BEAN定义或声明创建的那个被简单地忽略了，和现有的是返回的。IndexExistsExceptionignoreIfExiststrue<gfe:index ignore-if-exists="true">IndexindexIndex

返回现有的几乎没有什么后果，因为 thebean 定义是相同的，由Apache Geode本身决定，而不是SDG。Indexindex

但是，这也意味着 nowith 在 bean定义或声明中指定的“名称” 实际上从Apache Geode的角度来看存在（即使用QueryService.getIndexes（））。因此，在编写使用查询提示的 OQL 查询语句时应小心，尤其是查询提示引用被忽略的应用程序。这些查询提示需要更改。IndexindexIndex

当 anis 抛出 andis 设置为（或）时，该由这个豆定义或声明创建的也被忽略，而“存在”再次返回，就像阿尼斯扔的时候一样。IndexNameConflictExceptionignoreIfExiststrue<gfe:index ignore-if-exists="true">IndexindexIndexIndexExistsException

但是，返回现有并忽略应用程序对何时抛出的 anis 的定义存在更大的风险。对于a，而名称冲突索引是相同的，定义可能不同。这种情况可能会对 OQL 查询产生影响特定于应用程序，您假定索引是专门使用应用程序定义的考虑数据访问模式和查询。但是，如果同名索引的定义不同，则可能不是案子。因此，您应该验证您的姓名。IndexIndexIndexNameConflictExceptionIndexNameConflictExceptionIndex

SDG尽最大努力通知用户何时被忽略明显不同在其定义中来自现有的。然而，为了使可持续发展目标实现这一目标，它必须能够查找现有的，这是使用 Apache Geode API 查找的（唯一可用的方法）。`Index``Index``Index`

`Override`行为

当 anis 抛出 andis 设置为（或）时，这是有效的重命名。请记住，当存在多个索引时抛出具有相同的定义但不同的名称。IndexExistsExceptionoverridetrue<gfe:index override="true">IndexIndexExistsExceptions

Spring Data for Apache Geode 只能通过使用 Apache Geode 的 API 来实现这一点，首先删除现有的，然后用新名称重新创建。删除或后续创建调用都可能可能会失败。无法以原子方式执行这两个操作，如果任一操作失败，则无法回滚此联合操作。IndexIndex

但是，如果成功，那么您会遇到与以前相同的问题。任何现有的 OQL 必须更改使用引用 oldby 名称的查询提示的查询语句。ignoreIfExistsIndex

当 anis 抛出 andis 设置为（或）时，现有可以重新定义。我们说“潜在”是因为有可能同名的，存在在抛出 Anis 时具有完全相同的定义和名称。IndexNameConflictExceptionoverridetrue<gfe:index override="true">IndexIndexIndexNameConflictException

如果是这样，SDG是聪明的，并且返回现有的原样，甚至打开。没有伤害在此行为中，因为名称和定义完全相同。当然，可持续发展目标只能当SDG能够找到依赖于Apache Geode的API的现有API时，就可以完成此操作。如果找不到，则不会发生任何事情，并抛出一个包裹的SDGIS。IndexoverrideIndexGemfireIndexExceptionIndexNameConflictException

但是，当现有的定义不同时，SDG尝试通过使用bean定义中指定的定义来重新创建。确保这是您想要的，并确保该Bean 定义符合您的期望和应用程序要求。IndexIndexIndexindexindex

实际是如何发生的？`IndexNameConflictExceptions`

抛出的可能并不罕见，尤其是在多个配置时源用于配置 Apache Geode（Spring Data for Apache Geode、Apache Geode Cluster Config、Apache Geode native 、API 等）。您绝对应该更喜欢一种配置方法并坚持下去。IndexExistsExceptionscache.xml

但是，什么时候扔的？IndexNameConflictException

一种特殊情况是在区域（PR）上定义的。当在区域上定义 anis 时（例如，），Apache Geode将定义（和名称）分发给其他对等成员在同时托管相同区域（即“X”）的集群中。此定义的分布 thisby 对等成员的创建以及随后的创建是在需要知道的基础上（即，由对等成员托管相同的 PR）异步执行。IndexPARTITIONIndexPARTITIONXIndexPARTITIONIndexIndex

在这段时间内，Apache Geode 可能无法识别这些挂起的 PR，例如使用 QueryService.getIndexes（）调用QueryService.getIndexes（）和QueryService.getIndexes（：Region），甚至使用QueryService.getIndex（：Region， indexName：String）。Indexes

因此，SDG或其他Apache Geode缓存客户端应用程序（不涉及Spring）的唯一途径确定是尝试创建。如果它失败了，甚至并且，应用程序知道存在问题。这是因为创造等待挂起的定义，而其他 Apache Geode API 调用则不会。IndexIndexNameConflictExceptionIndexExistsExceptionQueryServiceIndexIndex

无论如何，可持续发展目标都会尽最大努力，并试图告知您已经发生或正在发生的事情，并告诉您纠正措施。鉴于所有 Apache 大地测量方法都是同步的，阻塞操作，Apache Geode 的状态应该是一致的，并且在这些索引类型中的任何一个之后都可以访问引发异常。因此，SDG可以检查系统的状态并采取相应的行动，根据您的配置。QueryService.createIndex(..)

在所有其他情况下，可持续发展目标都采用快速失败战略。

5.7. 配置磁盘存储

Spring Data for Apache Geode 支持通过元素进行配置和创建，如以下示例所示：DiskStoredisk-store

<gfe:disk-store  auto-compact="true" max-oplog-size="10"
                queue-size="50" time-interval="9999">
    <gfe:disk-dir location="/disk/location/one" max-size="20"/>
    <gfe:disk-dir location="/disk/location/two" max-size="20"/>
</gfe:disk-store>

DiskStore实例由区域用于文件系统持久备份和逐出条目溢出以及 WAN 网关的持久备份。多个 Apache Geode 组件可以共享相同的组件。此外，可以为单个文件系统目录定义多个文件系统目录，如前面的示例。DiskStoreDiskStore

请参阅 Apache Geode 的文档，了解持久性和溢出以及实例上的配置选项的完整说明。DiskStore

5.8. 配置快照服务

Spring Data for Apache Geode 通过使用Apache Geode 的快照服务支持缓存和区域快照。开箱即用的快照服务支持提供了几个方便的功能，以简化Apache Geode的缓存和区域快照服务API的使用。

正如Apache Geode文档所解释的那样，快照允许您保存并随后重新加载缓存的数据，这对于在环境，例如从生产环境到过渡或测试环境，以便重现与数据相关的问题在受控环境中。您可以结合Spring Data来支持Apache Geode的快照服务。使用Spring 的 Bean 定义配置文件，根据需要加载特定于环境的快照数据。

Spring Data for Apache Geode 对 Apache Geode 快照服务的支持始于元素从 XML 命名空间。<gfe-data:snapshot-service><gfe-data>

例如，您可以使用几个快照导入来定义要加载和保存的缓存范围的快照以及数据导出定义，如下所示：

<gfe-data:snapshot-service >
  <gfe-data:snapshot-import location="/absolute/filesystem/path/to/import/fileOne.snapshot"/>
  <gfe-data:snapshot-import location="relative/filesystem/path/to/import/fileTwo.snapshot"/>
  <gfe-data:snapshot-export
      location="/absolute/or/relative/filesystem/path/to/export/directory"/>
</gfe-data:snapshot-service>

您可以根据需要定义任意数量的导入和导出。只能定义导入或仅定义导出。文件位置目录路径可以是绝对的，也可以是相对于 Spring Data for Apache Geode 应用程序的路径，这是 JVM 进程的工作目录。

前面的示例非常简单，在这种情况下定义的快照服务是指 Apache Geode 默认名称为（如配置缓存中所述）的缓存实例。如果您命名缓存 Bean 定义不是默认的，您可以使用属性来引用缓存 Bean 按名称，如下所示：gemfireCachecache-ref

<gfe:cache />
...
<gfe-data:snapshot-service  cache-ref="myCache">
  ...
</gfe-data:snapshot-service>

您还可以通过指定属性为特定区域定义快照服务，如下所示：region-ref

<gfe:partitioned-region  persistent="false" .../>
...
<gfe-data:snapshot-service  region-ref="Example">
  <gfe-data:snapshot-import location="relative/path/to/import/example.snapshot/>
  <gfe-data:snapshot-export location="/absolute/path/to/export/example.snapshot/>
</gfe-data:snapshot-service>

指定属性后，Apache Geode's 的 Spring Data 会将属性值解析为 Spring 容器中定义的区域 bean，并创建RegionSnapshotService。快照导入和导出定义的工作方式相同。但是，必须引用文件在导出时。region-refSnapshotServiceFactoryBeanregion-reflocation

Apache Geode 对导入的快照文件在被引用之前实际存在非常严格。对于导出，Apache Geode 会创建快照文件。如果要导出的快照文件已存在，数据将被覆盖。

Apache Geode 的 Spring 数据包括元素上的属性以禁止配置的快照服务在初始化时尝试将数据导入缓存或区域。例如，当从一个区域导出的数据用于馈送另一个区域的导入时，这样做很有用。`suppress-import-on-init``<gfe-data:snapshot-service>`

5.8.1. 快照位置

使用基于缓存的快照服务（即缓存快照服务）您通常会向其传递一个目录，其中包含要加载的所有快照文件，而不是单个快照文件，如 API 中的重载加载方法所示。CacheSnapshotService

当然，您可以使用重载方法来获取特定关于要将哪些快照文件加载到 Apache Geode 缓存中。`load(:File[], :SnapshotFormat, :SnapshotOptions)`

但是，Spring Data for Apache Geode认识到，典型的开发人员工作流程可能是提取和导出数据。从一个环境到多个快照文件中，将所有文件压缩起来，然后方便地移动 zip 文件到另一个环境进行导入。

因此，Spring Data for Apache Geode 允许您在导入时为基于 a 的快照服务指定 jar 或 zip 文件，如下所示：cache

<gfe-data:snapshot-service  cache-ref="gemfireCache">
    <gfe-data:snapshot-import location="/path/to/snapshots.zip"/>
  </gfe-data:snapshot-service>

Spring Data for Apache Geode 可以方便地提取提供的 zip 文件，并将其视为目录导入（加载）。

5.8.2. 快照过滤器

定义多个快照导入和导出的真正功能是通过使用快照筛选器实现的。快照过滤器实现了Apache Geode的快照过滤器接口并用于过滤区域条目，以便在导入时包含在区域中以及包含在快照中在出口时。

Spring Data for Apache Geode 允许您使用属性或匿名在导入和导出时使用快照过滤器，嵌套 Bean 定义，如以下示例所示：filter-ref

<gfe:cache/>

<gfe:partitioned-region  persistent="false"/>
<gfe:partitioned-region  persistent="false"/>

<bean  class="example.gemfire.snapshot.filter.ActiveUsersFilter/>

<gfe-data:snapshot-service  region-ref="Admins">
  <gfe-data:snapshot-import location="/path/to/import/users.snapshot">
    <bean class="example.gemfire.snapshot.filter.AdminsFilter/>
  </gfe-data:snapshot-import>
  <gfe-data:snapshot-export location="/path/to/export/active/admins.snapshot" filter-ref="activeUsersFilter"/>
</gfe-data:snapshot-service>

<gfe-data:snapshot-service  region-ref="Guests">
  <gfe-data:snapshot-import location="/path/to/import/users.snapshot">
    <bean class="example.gemfire.snapshot.filter.GuestsFilter/>
  </gfe-data:snapshot-import>
  <gfe-data:snapshot-export location="/path/to/export/active/guests.snapshot" filter-ref="activeUsersFilter"/>
</gfe-data:snapshot-service>

此外，还可以使用 class 表示更复杂的快照筛选器。此类实现 Apache Geode 的SnapshotFilter接口以及复合软件设计模式。ComposableSnapshotFilter

简而言之，复合软件设计模式允许您组合相同类型的多个对象，并将聚合视为对象类型的单个实例 — a 强大而有用的抽象。

ComposableSnapshotFilter有两种工厂方法，并且。它们允许您在逻辑上组合单个快照分别使用 AND 和 OR 逻辑运算符进行筛选。工厂方法采用列表。andorSnapshotFilters

以下示例显示了 a 的定义：ComposableSnapshotFilter

<bean  class="org.springframework.data.gemfire.snapshot.filter.ComposableSnapshotFilter"
      factory-method="and">
  <constructor-arg index="0">
    <list>
      <bean class="org.example.app.gemfire.snapshot.filter.ActiveUsersFilter"/>
      <bean class="org.example.app.gemfire.snapshot.filter.UsersSinceFilter"
            p:since="2015-01-01"/>
    </list>
  </constructor-arg>
</bean>

然后，您可以继续使用与另一个过滤器结合使用，如下所示：activesUsersSinceFilteror

<bean  class="org.springframework.data.gemfire.snapshot.filter.ComposableSnapshotFilter"
      factory-method="or">
  <constructor-arg index="0">
    <list>
      <ref bean="activeUsersSinceFilter"/>
      <bean class="example.gemfire.snapshot.filter.CovertUsersFilter"/>
    </list>
  </constructor-arg>
</bean>

5.8.3. 快照事件

默认情况下，Spring Data for Apache Geode 在启动时使用 Apache Geode 的快照服务来导入数据和关机。以导出数据。但是，您可能希望为导入或导出触发基于事件的定期快照，从您的 Spring 应用程序中。

为此，Spring Data for Apache Geode 定义了两个额外的 Spring 应用程序事件，分别扩展了 Spring 的ApplicationEvent类以进行导入和导出：and。ImportSnapshotApplicationEventExportSnapshotApplicationEvent

这两个应用程序事件可以针对整个 Apache Geode 缓存或单个 Apache Geode 地区。这些类中的构造函数接受可选的区域路径名（例如）以及零或更多实例。/ExampleSnapshotMetadata

数组覆盖由 andsub-elements 定义的快照元数据，这些元数据用于快照应用程序事件不明确规定。每个单独的实例都可以定义自己的属性。SnapshotMetadata<gfe-data:snapshot-import><gfe-data:snapshot-export>SnapshotMetadataSnapshotMetadatalocationfilters

在 Springget 导入和导出快照中定义的所有快照服务 Bean 应用程序事件。但是，只有匹配的快照服务Bean才会处理导入和导出事件。ApplicationContext

基于区域的匹配项（如果快照服务 Bean 定义了）是 a及其区域引用（由属性确定）匹配快照应用程序事件指定的区域的路径名。[Import|Export]SnapshotApplicationEventRegionSnapshotServiceregion-ref

基于缓存（即没有区域路径名的快照应用程序事件）触发所有快照服务Bean（包括anybean）执行导入或导出，分别。[Import|Export]SnapshotApplicationEventRegionSnapshotService

您可以使用 Spring 的ApplicationEventPublisher接口从应用程序中触发导入和导出快照应用程序事件，如下所示：

@Component
public class ExampleApplicationComponent {

  @Autowired
  private ApplicationEventPublisher eventPublisher;

  @Resource(name = "Example")
  private Region<?, ?> example;

  public void someMethod() {

    ...

    File dataSnapshot = new File(System.getProperty("user.dir"), "/path/to/export/data.snapshot");

    SnapshotFilter myFilter = ...;

    SnapshotMetadata exportSnapshotMetadata =
        new SnapshotMetadata(dataSnapshot, myFilter, null);

    ExportSnapshotApplicationEvent exportSnapshotEvent =
        new ExportSnapshotApplicationEvent(this, example.getFullPath(), exportSnapshotMetadata)

    eventPublisher.publishEvent(exportSnapshotEvent);

    ...
  }
}

在前面的示例中，只有区域的快照服务 Bean 选取并处理导出事件，将过滤后的“/示例”区域的数据保存到应用程序子目录中的文件工作目录。/Exampledata.snapshot

使用 Spring 应用程序事件和消息传递子系统是保持应用程序松散耦合的好方法。您还可以使用Spring的调度服务来触发定期快照应用程序事件。

5.9. 配置函数服务

Spring Data for Apache Geode 为实现、注册和执行提供注释支持 Apache Geode Functions。

Spring Data for Apache Geode 还提供 XML 命名空间支持，用于注册 Apache Geode函数以进行远程函数执行。

有关函数执行框架的更多信息，请参阅Apache Geode 的文档。

Apache Geode 函数被声明为 Spring bean，必须实现接口或扩展。org.apache.geode.cache.execute.Functionorg.apache.geode.cache.execute.FunctionAdapter

命名空间使用熟悉的模式来声明 Functions，如以下示例所示：

<gfe:function-service>
  <gfe:function>
      <bean class="example.FunctionOne"/>
      <ref bean="function2"/>
  </gfe:function>
</gfe:function-service>

<bean  class="example.FunctionTwo"/>

5.10. 配置 WAN 网关

WAN 网关提供了一种跨地理位置同步 Apache Geode 分布式系统的方法。 Spring Data for Apache Geode 为配置 WAN 网关提供了 XML 命名空间支持，如以下示例所示。

5.10.1. Apache Geode 7.0 中的 WAN 配置

在以下示例中，通过添加子元素为 aRegion 进行配置（和）到区域。阿梅注册和。GatewaySendersPARTITIONgateway-sendergateway-sender-refGatewaySenderEventFiltersTransportFilters

以下示例还显示了的示例配置，该配置也必须自动连线到区域（未显示）：AsyncEventQueue

<gfe:partitioned-region  >
    <gfe:gateway-sender remote-distributed-system->
        <gfe:event-filter>
            <bean class="org.springframework.data.gemfire.example.SomeEventFilter"/>
        </gfe:event-filter>
        <gfe:transport-filter>
            <bean class="org.springframework.data.gemfire.example.SomeTransportFilter"/>
        </gfe:transport-filter>
    </gfe:gateway-sender>
    <gfe:gateway-sender-ref bean="gateway-sender"/>
</gfe:partitioned-region>

<gfe:async-event-queue  batch-size="10" persistent="true" disk-store-ref="diskstore"
        maximum-queue-memory="50">
    <gfe:async-event-listener>
        <bean class="example.AsyncEventListener"/>
    </gfe:async-event-listener>
</gfe:async-event-queue>

<gfe:gateway-sender  remote-distributed-system->
    <gfe:event-filter>
        <ref bean="event-filter"/>
        <bean class="org.springframework.data.gemfire.example.SomeEventFilter"/>
    </gfe:event-filter>
    <gfe:transport-filter>
        <ref bean="transport-filter"/>
        <bean class="org.springframework.data.gemfire.example.SomeTransportFilter"/>
    </gfe:transport-filter>
</gfe:gateway-sender>

<bean  class="org.springframework.data.gemfire.example.AnotherEventFilter"/>
<bean  class="org.springframework.data.gemfire.example.AnotherTransportFilter"/>

在 ais 的另一端，对应于接收网关事件。也可以配置与，如下所示：GatewaySenderGatewayReceiverGatewayReceiverEventFiltersTransportFilters

<gfe:gateway-receiver  start-port="12345" end-port="23456" bind-address="192.168.0.1">
    <gfe:transport-filter>
        <bean class="org.springframework.data.gemfire.example.SomeTransportFilter"/>
    </gfe:transport-filter>
</gfe:gateway-receiver>

有关所有配置选项的详细说明，请参阅 Apache Geode文档。

Apache Geode 的 Spring Data（数据）

1. 简介

2. 要求

3. 新功能

3.1. 2.0 版本中的新功能

3.2. 2.1 版本中的新功能

3.3. 2.2 版本中的新功能

参考指南

4. 文档结构

5. 使用弹簧容器引导 Apache Geode

5.1. 使用 Spring 优于 Apache Geode 的优势​​cache.xml​​

5.2. 使用核心命名空间

5.3. 使用数据访问命名空间

5.3.1. 连接到 Apache Geode 的简单方法

5.4. 配置缓存

5.4.1. 高级缓存配置

启用 PDX 序列化

启用自动重新连接

使用基于群集的配置

5.4.2. 配置一个 Apache Geode 缓存服务器

5.4.3. 配置 Apache Geode 客户端缓存

Apache Geode 的默认池和 Apache Geode 池定义的 Spring 数据

5.5. 配置地域

5.5.1. 使用外部配置的区域

5.5.2. 自动区域查找

5.5.3. 配置区域

公共区域属性

​​CacheListener​​实例

CacheLoaders 和 CacheWriters

5.5.4. 压缩

5.5.5. 堆外

5.5.6. 次区域

5.5.7. Region Templates

模板的工作原理

有关区域、子区域和查找的注意事项

5.5.8. 数据逐出（带溢出）

5.5.9. 数据过期

基于注释的数据过期

5.5.10. 数据持久化

5.5.11. 订阅政策

5.5.12. 本地区域

5.5.13. 复制区域

5.5.14. 分区区域

分区区域属性

5.5.15. 客户端区域

客户兴趣

5.5.16. JSON 支持

5.6. 配置索引

5.6.1. 定义索引

5.6.2.和​​IgnoreIfExists​​​​Override​​

​​IgnoreIfExists​​行为

​​Override​​行为

实际是如何发生的？​​IndexNameConflictExceptions​​

5.7. 配置磁盘存储

5.8. 配置快照服务

5.8.1. 快照位置

5.8.2. 快照过滤器

5.8.3. 快照事件

5.9. 配置函数服务

5.10. 配置 WAN 网关

5.10.1. Apache Geode 7.0 中的 WAN 配置

相关文章

5.1. 使用 Spring 优于 Apache Geode 的优势`cache.xml`

`CacheListener`实例

5.6.2.和`IgnoreIfExists``Override`

`IgnoreIfExists`行为

`Override`行为

实际是如何发生的？`IndexNameConflictExceptions`