Apache Geode 的 Spring Data（数据）（二）

6. 使用注释使用弹簧容器引导 Apache Geode

Spring Data for Apache Geode （SDG） 2.0 引入了一个新的基于注释的配置模型 使用 Spring 容器配置和引导 Apache Geode。

引入基于注释的方法进行Apache Geode配置的主要动机 在 Spring 上下文中，是使 Spring 应用程序开发人员能够尽可能快速、轻松地启动和运行。

让我们开始吧！

6.1. 简介

考虑到所有配置属性和不同的配置选项，Apache Geode 可能难以正确设置和使用：

• 爪哇接口
• cache.xml
• 具有群集配置的 Gfsh
• 基于 Spring XML/Java 的配置

不同的受支持拓扑带来了进一步的复杂性：

• (客户端/服务器
• P2P
• 广域网)
• 分布式系统设计模式（如无共享体系结构）。

基于注释的配置模型旨在简化所有这些以及更多。

基于注释的配置模型是使用 Spring Data for Apache Geode 的 XML 命名空间的基于 XML 的配置的替代方法。 使用 XML，您可以使用 XML 架构进行配置，使用 XML 架构进行数据访问。 有关更多详细信息，请参阅“使用 Spring 容器引导 Apache Geode”。​​gfe​​​​gfe-data​​

与Spring Boot一样，Apache Geode基于注释的配置模型的Spring Data被设计为一个固执己见的。 使用 Apache Geode 的约定配置方法。事实上，这种基于注释的配置模型 灵感来自Spring Boot以及其他几个Spring 和 Spring Data 项目。

按照约定，所有注释为所有配置属性提供合理且合理的默认值。 给定注释属性的默认值直接对应于 中提供的默认值 Apache Geode 用于相同的配置属性。

目的是让您通过声明适当的 在 Springorclass 上进行注释，而无需进行不必要的配置 大量属性只是为了使用该功能或服务。​​@Configuration​​​​@SpringBootApplication​​

同样，快速轻松地入门是主要目标​。

但是，如果需要，可以选择自定义Apache Geode的配置元数据和行为， Apache Geode基于注释的配置的Spring Data悄悄地退缩了。您只需指定配置属性 您希望调整。此外，正如我们将在本文档后面看到的那样，有几种方法可以配置 Apache Geode 使用注释的功能或嵌入式服务。

您可以在软件包中找到所有新的SDG Java。​​Annotations​​​​org.springframework.data.gemfire.config.annotation​​

6.2. 使用 Spring 配置 Apache Geode 应用程序

像所有以注释应用程序类开始的 Spring 引导应用程序一样， Spring Boot 应用程序可以通过声明三个中的任何一个来轻松成为 Apache Geode 缓存应用程序 主要注释：​​@SpringBootApplication​​

• ​​@ClientCacheApplication​​
• ​​@PeerCacheApplication​​
• ​​@CacheServerApplication​​

这三个注释是Spring应用程序开发人员在使用Apache Geode时的起点。

要实现这些注释背后的意图，您必须了解有两种类型的缓存实例 可以使用Apache Geode创建：客户端缓存或对等缓存。

您可以将 Spring Boot 应用程序配置为具有以下实例的 Apache Geode 缓存客户端： 它可以与用于管理应用程序数据的现有 Apache Geode 服务器集群进行通信。 客户端-服务器拓扑是使用 Apache Geode 时最常用的系统体系结构，您可以 使您的 Spring 引导应用程序成为缓存客户端，只需通过注释它即可。​​ClientCache​​​​ClientCache​​​​@ClientCacheApplication​​

或者，Spring Boot 应用程序可以是 Apache Geode 集群的对等成员。也就是说，应用程序 本身只是管理数据的服务器集群中的另一台服务器。Spring 引导应用程序创建 一个“嵌入式”的对等实例，当您用来批注应用程序类时。​​Cache​​​​@PeerCacheApplication​​

通过扩展，对等缓存应用程序也可以充当atoo，允许缓存客户端连接 并在服务器上执行数据访问操作。这是通过在 中注释应用程序类来实现的，这将创建一个对等实例以及 这允许缓存客户端连接。​​CacheServer​​​​@CacheServerApplication​​​​@PeerCacheApplication​​​​Cache​​​​CacheServer​​

例如，如果要创建 Spring Boot 缓存客户端应用程序，请从以下内容开始：

基于弹簧的阿帕奇大地测量应用​​ClientCache​​

@SpringBootApplication
@ClientCacheApplication
class ClientApplication { .. }

或者，如果要创建具有嵌入式对等实例的 Spring Boot 应用程序，其中应用程序 将是Apache Geode形成的集群（分布式系统）的服务器和对等成员， 从以下内容开始：​​Cache​​

基于弹簧的Apache Geode嵌入式对等应用程序​​Cache​​

@SpringBootApplication
@PeerCacheApplication
class ServerApplication { .. }

或者，您可以使用注释代替创建 嵌入式对等实例以及 Arun On，侦听默认值 缓存服务器端口，如下所示：​​@CacheServerApplication​​​​@PeerCacheApplication​​​​Cache​​​​CacheServer​​​​localhost​​​​40404​​

基于弹簧的Apache Geode嵌入式对等应用程序​​Cache​​​​CacheServer​​

@SpringBootApplication
@CacheServerApplication
class ServerApplication { .. }

6.3. 客户端/服务器应用程序详细信息

客户端可以通过多种方式连接到 Apache Geode 集群中的服务器并与之通信。 最常见和推荐的方法是使用 Apache Geode 定位器。

默认情况下，Apache Geode 设置了一个“默认”连接到 arunon， 在端口上侦听创建实例时。在港口等待， 接受所有系统网卡上的连接。您无需执行任何特殊操作即可使用客户端-服务器拓扑。 只需注释您的服务器端 Spring 启动应用程序和您的客户端 弹簧启动应用程序，你准备好了。​​Pool​​​​CacheServer​​​​localhost​​​​40404​​​​ClientCache​​​​CacheServer​​​​40404​​​​@CacheServerApplication​​​​@ClientCacheApplication​​

如果你愿意，你甚至可以用Gfsh的命令启动你的服务器。您的 Spring Boot 仍然可以连接到服务器，无论它是如何启动的。但是，您可能更愿意配置并启动您的 服务器通过使用 Spring Data for Apache Geode 方法，因为正确注释的 Spring Boot 应用程序类更加直观 并且更易于调试。​​start server​​​​@ClientCacheApplication​​

作为应用程序开发人员，您无疑希望自定义Apache Geode设置的“DEFAULT”。 以可能连接到一个或多个定位器，如以下示例所示：​​Pool​​

使用定位器的基于弹簧的阿帕奇地理退缩应用​​ClientCache​​

@SpringBootApplication
@ClientCacheApplication(locators = {
    @Locator(host = "boombox" port = 11235),
    @Locator(host = "skullbox", port = 12480)
})
class ClientApplication { .. }

除了属性，theannotation 也有属性。 该属性可用于指定一个或多个嵌套批注，这些批注允许缓存客户端 如有必要，直接连接到一台或多台服务器。​​locators​​​​@ClientCacheApplication​​​​servers​​​​servers​​​​@Server​​

您还可以配置其他实例（除了Apache Geode提供的“DEFAULT”） 当使用theannotations创建实例时）。​​Pool​​​​Pool​​​​ClientCache​​​​@ClientCacheApplication​​​​@EnablePool​​​​@EnablePools​​

以下示例使用注释：​​@EnablePool​​​​@EnablePools​​

基于弹簧的阿帕奇大地勘测应用，使用多个命名​​ClientCache​​​​Pools​​

@SpringBootApplication
@ClientCacheApplication(logLevel = "info")
@EnablePool(name = "VenusPool", servers = @Server(host = "venus", port = 48484),
    min-connections = 50, max-connections = 200, ping-internal = 15000,
    prSingleHopEnabled = true, readTimeout = 20000, retryAttempts = 1,
    subscription-enable = true)
@EnablePools(pools = {
    @EnablePool(name = "SaturnPool", locators = @Locator(host="skullbox", port=20668),
        subsription-enabled = true),
    @EnablePool(name = "NeptunePool", severs = {
            @Server(host = "saturn", port = 41414),
            @Server(host = "neptune", port = 42424)
        }, min-connections = 25))
})
class ClientApplication { .. }

属性是注释的唯一必需属性。正如我们稍后将看到的，该值 的属性对应于在 Spring 容器中创建的 bean 的名称以及 用于引用相应配置属性的名称。它也是注册的名称 并被Apache Geode使用。​​name​​​​@EnablePool​​​​name​​​​Pool​​​​Pool​​

同样，在服务器上，您可以配置客户端可以连接到的多个，如下所示：​​CacheServers​​

基于弹簧的阿帕奇大地勘测应用，使用多个命名​​CacheServer​​​​CacheServers​​

@SpringBootApplication
@CacheSeverApplication(logLevel = "info", autoStartup = true, maxConnections = 100)
@EnableCacheServer(name = "Venus", autoStartup = true,
    hostnameForClients = "venus", port = 48484)
@EnableCacheServers(servers = {
    @EnableCacheServer(name = "Saturn", hostnameForClients = "saturn", port = 41414),
    @EnableCacheServer(name = "Neptune", hostnameForClients = "neptune", port = 42424)
})
class ServerApplication { .. }

细心的读者可能已经注意到的一件事是，在所有情况下，您都为所有指定了硬编码值 主机名、端口和面向配置的注释属性。当应用程序得到时，这并不理想 提升并部署到不同的环境，例如从 DEV 到 QA 再到暂存再到 PROD。

下一节介绍如何处理在运行时确定的动态配置。

6.4. 配置和引导定位器

除了Apache Geode Cache应用程序，您还可以创建Apache Geode Locator应用程序。

Apache Geode 定位器是一个 JVM 进程，它允许节点作为对等成员加入 Apache Geode 集群。 定位符还使客户端能够发现群集中的服务器。定位器向客户提供元数据，以统一 平衡集群中成员之间的负载，启用单跃点数据访问操作以及其他功能。

有关定位器的完整讨论超出了本文档的范围。鼓励读者阅读 Apache Geode用户指南，了解有关定位器及其在集群中的角色的更多详细信息。

要配置和引导独立定位器进程，请执行以下操作：

Spring Boot， Apache Geode 定位器应用程序

@SpringBootApplication
@LocatorApplication(port = 12345)
class LocatorApplication { ... }

您可以在集群中启动多个定位符。唯一的要求是成员名称必须是唯一的 在群集中。使用注记的属性命名成员定位器 相应地在集群中。或者，您可以在Spring Boot中设置该属性。​​name​​​​@LocatorApplication​​​​spring.data.gemfire.locator.name​​​​application.properties​​

此外，如果在同一定位器上分叉多个定位器，则必须确保每个定位器在唯一的端口上启动 机器。设置注释属性或属性。​​port​​​​spring.data.gemfire.locator.port​​

然后，您可以在由定位器或定位器加入的集群中启动 1 个或多个 Apache Geode 对等缓存成员， 还使用 Spring 进行配置和引导，如下所示：

Spring Boot， Apache GeodeApplication 由定位器连接， 端口​​CacheServer​​​​localhost​​​​12345​​

@SpringBootApplication
@CacheServerApplication(locators = "localhost[12345]")
class ServerApplication { ... }

同样，您可以根据需要开始任意数量的课程，并通过上面的定位器加入。 您只需要确保成员是唯一命名的。​​ServerApplication​​

​​@LocatorApplication​​用于配置和引导独立的 Apache Geode 定位器应用程序进程。 此过程只能是定位器，不能是其他任何内容。如果您尝试使用缓存实例启动定位器，SDG 将 抛出错误。

如果要同时启动缓存实例以及嵌入式定位器，则应使用 取而代之的是注释。​​@EnableLocator​​

在开发过程中启动嵌入式定位器非常方便。但是，强烈建议您独立运行 生产中的定位器流程可实现高可用性。如果集群中的所有定位符都关闭，则集群 将保持不变，但是，没有新成员能够加入集群，这对于线性横向扩展非常重要 以满足需求。

有关更多详细信息，请参阅配置嵌入式定位器部分。

6.5. 运行时配置​​Configurers​​

设计基于注释的配置模型时的另一个目标是在注释中保持类型安全性 属性。例如，如果配置属性可以表示为 an（例如端口号）， 则属性的类型应为 an。​​int​​​​int​​

遗憾的是，这不利于运行时的动态和可解析配置。

Spring 的一个更精细的功能是能够使用属性占位符和 SpEL 表达式。 在 Spring 容器中配置 Bean 时配置元数据的属性或属性中。 但是，这将要求所有注释属性都是类型，从而放弃类型安全性， 这是不可取的。​​String​​

因此，Apache Geode 的 Spring 数据借鉴了 Spring 中另一种常用的模式。Spring Web MVC中提供了许多不同的接口，包括org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer。​​Configurers​​​​Configurer​​

设计模式使应用程序开发人员能够接收回调以自定义配置 启动时的组件或 Bean。框架回调用户提供的代码以调整配置 在运行时。此模式更常见的用途之一是提供基于 应用程序的运行时环境。​​Configurers​​

Spring Data for Apache Geode 提供了多个回调接口来自定义基于注释的不同方面 运行时的配置元数据，在初始化注释创建的 Spring 托管 Bean 之前：​​Configurer​​

• ​​CacheServerConfigurer​​
• ​​ClientCacheConfigurer​​
• ​​ContinuousQueryListenerContainerConfigurer​​
• ​​DiskStoreConfigurer​​
• ​​IndexConfigurer​​
• ​​PeerCacheConfigurer​​
• ​​PoolConfigurer​​
• ​​RegionConfigurer​​
• ​​GatewayReceiverConfigurer​​
• ​​GatewaySenderConfigurer​​

例如，您可以使用 theand来自定义端口号 分别由您的 Spring 引导和应用程序使用。​​CacheServerConfigurer​​​​ClientCacheConfigurer​​​​CacheServer​​​​ClientCache​​

请考虑来自服务器应用程序的以下示例：

使用​​CacheServer​​​​CacheServerConfigurer​​

@SpringBootApplication
@CacheServerApplication(name = "SpringServerApplication")
class ServerApplication {

  @Bean
  CacheServerConfigurer cacheServerPortConfigurer(
          @Value("${gemfire.cache.server.host:localhost}") String cacheServerHost
          @Value("${gemfire.cache.server.port:40404}") int cacheServerPort) {

      return (beanName, cacheServerFactoryBean) -> {
          cacheServerFactoryBean.setBindAddress(cacheServerHost);
          cacheServerFactoryBean.setHostnameForClients(cacheServerHost);
          cacheServerFactoryBean.setPort(cacheServerPort);
      };
  }
}

接下来，考虑客户端应用程序中的以下示例：

使用​​ClientCache​​​​ClientCacheConfigurer​​

@SpringBootApplication
@ClientCacheApplication
class ClientApplication {

  @Bean
  ClientCacheConfigurer clientCachePoolPortConfigurer(
          @Value("${gemfire.cache.server.host:localhost}") String cacheServerHost
          @Value("${gemfire.cache.server.port:40404}") int cacheServerPort) {

      return (beanName, clientCacheFactoryBean) ->
          clientCacheFactoryBean.setServers(Collections.singletonList(
              new ConnectionEndpoint(cacheServerHost, cacheServerPort)));
  }
}

通过使用提供的，您可以接收回调以进一步自定义配置 这是在运行时启动期间由关联的注释启用的。​​Configurers​​

此外，当theis在Spring容器中声明为bean时，bean定义可以利用 其他 Spring 容器功能，例如属性占位符、使用注释的 SpEL 表达式 在工厂方法参数上，依此类推。​​Configurer​​​​@Value​​

全部由 Spring Data 为 Apache Geode 提供 在回调中获取两位信息：创建的 bean 的名称 在 Spring 容器中通过注释和引用 theused 由注释到 创建并配置 Apache Geode 组件（例如，创建实例 并配置了）。​​Configurers​​​​FactoryBean​​​​ClientCache​​​​ClientCacheFactoryBean​​

鉴于 acan 可以像任何其他 POJO 一样声明为常规 bean 定义，您可以组合不同的 弹簧配置选项，例如使用弹簧配置文件使用这两个属性占位符 和 SpEL 表达式。这些和其他漂亮的功能使您可以创建更复杂，更灵活的配置。​​Configurer​​​​Conditions​​

但是，并不是唯一的选择。​​Configurers​​

6.6. 运行时配置​​Properties​​

此外，基于注释的配置模型中的每个注释属性都与 一个相应的配置属性（前缀），可以在 Spring 引导文件中声明。​​Configurers​​​​spring.data.gemfire.​​​​application.properties​​

在前面的示例的基础上，客户端的文件将定义以下内容 属性集：​​application.properties​​

客户​​application.properties​​

spring.data.gemfire.cache.log-level=info
spring.data.gemfire.pool.Venus.servers=venus[48484]
spring.data.gemfire.pool.Venus.max-connections=200
spring.data.gemfire.pool.Venus.min-connections=50
spring.data.gemfire.pool.Venus.ping-interval=15000
spring.data.gemfire.pool.Venus.pr-single-hop-enabled=true
spring.data.gemfire.pool.Venus.read-timeout=20000
spring.data.gemfire.pool.Venus.subscription-enabled=true
spring.data.gemfire.pool.Saturn.locators=skullbox[20668]
spring.data.gemfire.pool.Saturn.subscription-enabled=true
spring.data.gemfire.pool.Neptune.servers=saturn[41414],neptune[42424]
spring.data.gemfire.pool.Neptune.min-connections=25

相应服务器的文件将定义以下属性：​​application.properties​​

服务器​​application.properties​​

spring.data.gemfire.cache.log-level=info
spring.data.gemfire.cache.server.port=40404
spring.data.gemfire.cache.server.Venus.port=43434
spring.data.gemfire.cache.server.Saturn.port=41414
spring.data.gemfire.cache.server.Neptune.port=41414

然后，您可以将类简化为以下内容：​​@ClientCacheApplication​​

春季班​​@ClientCacheApplication​​

@SpringBootApplication
@ClientCacheApplication
@EnablePools(pools = {
    @EnablePool(name = "Venus"),
    @EnablePool(name = "Saturn"),
    @EnablePool(name = "Neptune")
})
class ClientApplication { .. }

此外，该类将变为以下内容：​​@CacheServerApplication​​

春季班​​@CacheServerApplication​​

@SpringBootApplication
@CacheServerApplication(name = "SpringServerApplication")
@EnableCacheServers(servers = {
    @EnableCacheServer(name = "Venus"),
    @EnableCacheServer(name = "Saturn"),
    @EnableCacheServer(name = "Neptune")
})
class ServerApplication { .. }

前面的示例说明了为什么“命名”基于注释的 Bean 很重要（除了因为它是必需的 在某些情况下）。这样做可以从XML，属性，引用Spring容器中的bean，属性， 和爪哇。甚至可以将注释定义的 bean 注入到应用程序类中，无论出于何种目的， 如以下示例所示：

@Component
class MyApplicationComponent {

  @Resource(name = "Saturn")
  CacheServer saturnCacheServer;

  ...
}

同样，命名注释定义的 Bean 允许您编写代码以自定义特定的“命名”Bean 由于 2 个参数中的 1 个传递给回调。​​Configurer​​​​beanName​​

通常，关联的注释属性采用两种形式：“命名”属性以及 “未命名”属性。

以下示例显示了这样的安排：

spring.data.gemfire.cache.server.bind-address=10.105.20.1
spring.data.gemfire.cache.server.Venus.bind-address=10.105.20.2
spring.data.gemfire.cache.server.Saturn...
spring.data.gemfire.cache.server.Neptune...

虽然上面有三个命名的，但也有一个未命名的属性提供 该属性的任何未指定值的默认值，即使对于“命名”。所以，虽然“金星” 设置并覆盖自己的“土星”和“海王星”继承自“未命名”属性。​​CacheServers​​​​CacheServer​​​​CacheServers​​​​bind-address​​​​spring.data.gemfire.cache.server.bind-address​​

查看注解的 Javadoc，其中注解属性支持基于属性的配置 以及它们是否支持“命名”属性而不是默认的“未命名”属性。

6.6.1. of ​​Properties​​​​Properties​​

在通常的春季时尚中，您甚至可以用其他语言来表达，无论是通过 下面的示例演示在 anfile 中设置的嵌套属性：​​Properties​​​​Properties​​​​application.properties​​

属性的属性

spring.data.gemfire.cache.server.port=${gemfire.cache.server.port:40404}

以下示例显示了在 Java 中设置的嵌套属性：

属性放置者嵌套

@Bean
CacheServerConfigurer cacheServerPortConfigurer(
    @Value("${gemfire.cache.server.port:${some.other.property:40404}}")
    int cacheServerPort) {
  ...
}

6.7. 配置嵌入式服务

Apache Geode提供了启动应用程序所需的许多不同的嵌入式服务的能力， 取决于用例。

6.7.1. 配置嵌入式定位器

如前所述，客户端使用 Apache Geode 定位器连接到群集中的服务器并查找服务器。 此外，加入现有集群的新成员使用定位器查找其对等方。

对于应用程序开发人员来说，这通常很方便，因为他们正在为Apache Geode开发Spring Boot和Spring Data。 用于启动包含两个或三个 Apache Geode 服务器的小型集群的应用程序。而不是开始 一个单独的定位器进程，你可以用以下方法注释你的 Spring 引导类， 如下：​​@CacheServerApplication​​​​@EnableLocator​​

Spring， Apache Geodeapplication 运行嵌入式定位器​​CacheServer​​

@SpringBootApplication
@CacheServerApplication
@EnableLocator
class ServerApplication { .. }

Theannotation在Spring Apache大地勘测应用中启动嵌入式定位器 运行，侦听默认定位器端口，。您可以自定义（绑定地址） 并且嵌入式定位器通过使用相应的注释属性绑定到。​​@EnableLocator​​​​CacheServer​​​​localhost​​​​10334​​​​host​​​​port​​

或者，您可以通过设置相应的属性来设置属性。​​@EnableLocator​​​​spring.data.gemfire.locator.host​​​​spring.data.gemfire.locator.port​​​​application.properties​​

然后，您可以通过连接到此启动来启动其他启用 Spring Boot 的应用程序 具有以下功能的定位器：​​@CacheServerApplication​​

春天，连接到定位器的阿帕奇大地测量应用程序​​CacheServer​​

@SpringBootApplication
@CacheServerApplication(locators = "localhost[10334]")
class ServerApplication { .. }

您甚至可以将前面显示的两个应用程序类合并到一个类中，并使用 IDE 创建不同的类 运行配置文件配置以启动同一类的不同实例，并稍作修改配置 通过使用 Java 系统属性，如下所示：

运行嵌入式定位器并连接到定位器的 Spring应用程序​​CacheServer​​

@SpringBootApplication
@CacheServerApplication(locators = "localhost[10334]")
public class ServerApplication {

  public static void main(String[] args) {
    SpringApplication.run(ServerApplication.class);
  }

  @EnableLocator
  @Profile("embedded-locator")
  static class Configuration { }

}

然后，对于每个运行配置文件，可以设置和更改以下系统属性：

IDE 运行配置文件配置

spring.data.gemfire.name=SpringCacheServerOne
spring.data.gemfire.cache.server.port=41414
spring.profiles.active=embedded-locator

只有 1 个类的运行配置文件应设置 Java 系统属性。然后，您可以更改 andfor 其他每个运行配置文件 并在本地系统上运行一个由 Apache Geode 服务器组成的小型集群（分布式系统）。​​ServerApplication​​​​-Dspring.profiles.active=embedded-locator​​​​..name​​​​..cache.server.port​​

有关Apache Geode定位器如何工作的更多详细信息，请参阅此处。

6.7.2. 配置嵌入式管理器

Apache Geode Manager 是集群中负责集群“管理”的另一个对等成员或节点。 管理包括创建,,,以及监视运行时 群集组件的操作和行为。​​Regions​​​​Indexes​​​​DiskStores​​

管理器允许启用了 JMX 的客户端（例如Gfshshell 工具）连接到管理器以管理集群。 也可以使用JDK提供的工具（如JConsole或JVisualVM）连接到管理器，因为它们是 两个启用 JMX 的客户端也是如此。

也许您还想以经理的身份更早地启用 Springshow。为此， 注释你的 Springorclass 与。​​@CacheServerApplication​​​​@Configuration​​​​@SpringBootApplication​​​​@EnableManager​​

默认情况下，管理器绑定到，侦听默认管理器端口。几个方面 可以使用注释属性或相应的属性配置管理器。​​localhost​​​​1099​​

以下示例演示如何在 Java 中创建嵌入式管理器：

运行嵌入式管理器的 Spring应用程序​​CacheServer​​

@SpringBootApplication
@CacheServerApplication(locators = "localhost[10334]")
public class ServerApplication {

  public static void main(String[] args) {
    SpringApplication.run(ServerApplication.class);
  }

  @EnableLocator
  @EnableManager
  @Profile("embedded-locator-manager")
  static class Configuration { }

}

使用前面的类，您甚至可以使用Gfsh连接到小型集群并对其进行管理，如下所示：

$ gfsh
    _________________________     __
   / _____/ ______/ ______/ /____/ /
  / /  __/ /___  /_____  / _____  /
 / /__/ / ____/  _____/ / /    / /
/______/_/      /______/_/    /_/    1.2.1

Monitor and Manage {data-store-name}

gfsh>connect
Connecting to Locator at [host=localhost, port=10334] ..
Connecting to Manager at [host=10.99.199.5, port=1099] ..
Successfully connected to: [host=10.99.199.5, port=1099]

gfsh>list members
         Name          | Id
---------------------- | ----------------------------------------------------
SpringCacheServerOne   | 10.99.199.5(SpringCacheServerOne:14842)<ec><v0>:1024
SpringCacheServerTwo   | 10.99.199.5(SpringCacheServerTwo:14844)<v1>:1025
SpringCacheServerThree | 10.99.199.5(SpringCacheServerThree:14846)<v2>:1026

由于我们还启用了嵌入式定位器，因此可以通过定位器间接连接到管理器。 定位器允许 JMX 客户端连接并在集群中查找管理器。如果不存在，定位器将代入角色 的经理。但是，如果不存在定位器，则需要使用以下方法直接连接到管理器：

Gfsh命令直接连接到管理器​​connect​​

gfsh>connect --jmx-manager=localhost[1099]

有关Apache Geode管理和监控的更多详细信息，请参见此处。

6.7.3. 配置嵌入式 HTTP 服务器

Apache Geode还能够运行嵌入式HTTP服务器。当前的实现由Eclipse Jetty支持。

嵌入式HTTP服务器用于托管Apache Geode的管理（管理员）REST API（不是公开宣传的API）。 开发者 REST API， 和脉搏监测 Web 应用程序。

但是，要使用任何这些 Apache Geode 提供的 Web 应用程序，您必须完整安装 Apache Geode 安装在您的系统上，您必须将环境变量设置为 您的安装目录。​​GEODE_HOME​​

要启用嵌入式 HTTP 服务器，请将注释添加到 anyorannotated 类，如下所示：​​@EnableHttpService​​​​@PeerCacheApplication​​​​@CacheServerApplication​​

运行嵌入式HTTP服务器的Spring应用程序​​CacheServer​​

@SpringBootApplication
@CacheServerApplication
@EnableHttpService
public class ServerApplication { .. }

默认情况下，嵌入式 HTTP 服务器在端口上侦听 HTTP 客户端请求。当然，您可以使用 注释属性或相应的配置属性，以根据需要调整端口。​​7070​​

请按照前面的链接了解有关 HTTP 支持和所提供服务的更多详细信息。

6.7.4. 配置嵌入式内存缓存服务器 （gemcached）

Apache Geode还实现了Memcached协议，能够为Memcached客户端提供服务。那是 Memcached 客户端可以连接到 Apache Geode 集群并执行 Memcached 操作，就像 集群中的Apache Geode服务器是实际的Memcached服务器。

要启用嵌入式 Memcached 服务，请将注释添加到 anyorannotated 类，如下所示：​​@EnableMemcachedServer​​​​@PeerCacheApplication​​​​@CacheServerApplication​​

运行嵌入式内存缓存服务器的 Spring应用程序​​CacheServer​​

@SpringBootApplication
@CacheServerApplication
@EnabledMemcachedServer
public class ServerApplication { .. }

有关Apache Geode的Memcached服务（称为“Gemcached”）的更多详细信息，请参见此处。

6.7.5. 配置嵌入式 Redis 服务器

Apache Geode还实现了Redis服务器协议，该协议使Redis客户端能够连接到并与之通信。 使用Apache Geode服务器集群来发出Redis命令。在撰写本文时，Redis 服务器协议 Apache Geode中的支持仍处于实验阶段。

要启用嵌入式 Redis 服务，请将注释添加到 anyorannotated 类，如下所示：​​@EnableRedisServer​​​​@PeerCacheApplication​​​​@CacheServerApplication​​

运行嵌入式 Redis 服务器的 Spring应用程序​​CacheServer​​

@SpringBootApplication
@CacheServerApplication
@EnableRedisServer
public class ServerApplication { .. }

有关Apache Geode的Redis适配器的更多详细信息，请参见此处。

6.8. 配置日志记录

通常，有必要打开日志记录，以便准确了解Apache Geode正在做什么以及何时做。

若要启用日志记录，请对应用程序类进行批注并设置适当的属性 或关联的属性，如下所示：​​@EnableLogging​​

启用了日志记录的 Spring 应用程序​​ClientCache​​

@SpringBootApplication
@ClientCacheApplication
@EnableLogging(logLevel="info", logFile="/absolute/file/system/path/to/application.log)
public class ClientApplication { .. }

虽然可以使用所有基于缓存的应用程序注释指定属性 （例如，），使用 自定义日志记录行为更容易 注释。​​logLevel​​​​@ClientCacheApplication(logLevel="info")​​​​@EnableLogging​​

此外，您可以通过设置属性来配置 在。​​log-level​​​​spring.data.gemfire.logging.level​​​​application.properties​​

有关更多详细信息，请参阅@EnableLogging注释 Javadoc。

6.9. 配置统计

要在运行时更深入地了解 Apache Geode，您可以启用统计信息。收集统计数据 在复杂问题（通常分布在自然界中）时便于系统分析和故障排除 在时机是一个关键因素的地方，发生。

启用统计信息后，您可以使用Apache Geode的VSD（可视化统计信息显示）工具 分析收集的统计数据。

若要启用统计信息，请使用以下命令批注应用程序类：​​@EnableStatistics​​

启用了统计的 Spring 应用程序​​ClientCache​​

@SpringBootApplication
@ClientCacheApplication
@EnableStatistics
public class ClientApplication { .. }

在评估性能时，在服务器上启用统计信息特别有价值。为此， 注释你的类。​​@PeerCacheApplication​​​​@CacheServerApplication​​​​@EnableStatistics​​

您可以使用注释属性或关联属性来自定义 统计信息收集和收集过程。​​@EnableStatistics​​

有关更多详细信息，请参阅@EnableStatistics注释 Javadoc。

有关Apache Geode统计数据的更多详细信息可以在这里找到。

6.10. 配置 PDX

Apache Geode的一个更强大的功能是PDX序列化。 虽然对 PDX 的完整讨论超出了本文档的范围，但使用 PDX 进行序列化要好得多 可替代 Java 序列化，具有以下优点：

• PDX 使用集中式类型注册表来使对象的序列化字节更加紧凑。
• PDX 是一种中性序列化格式，允许 Java 和本机客户端对同一数据集进行操作。
• PDX 支持版本控制，允许在不影响现有应用程序的情况下添加或删除对象字段 使用已更改的较旧版本或较新版本的 PDX 序列化对象，而不会丢失数据。
• PDX 允许在 OQL 查询投影和谓词中单独访问对象字段，而无需对象 需要先反序列化。

通常，每当数据传入或传出客户端和服务器时，都需要在 Apache Geode 中进行序列化 或在正常分发和复制过程中以及数据溢出期间在集群中的对等方之间 或持久保存到磁盘。

启用 PDX 序列化比修改要实现的所有应用程序域对象类型要简单得多，尤其是在不希望对 应用程序域模型，或者您对要序列化的对象没有任何控制权，尤其是 使用第三方库时为 true（例如，考虑具有类型的地理空间 API）。​​java.io.Serializable​​​​Coordinate​​

要启用 PDX，请使用以下命令批注应用程序类：​​@EnablePdx​​

启用了 PDX 的 Spring应用程序​​ClientCache​​

@SpringBootApplication
@ClientCacheApplication
@EnablePdx
public class ClientApplication { .. }

通常，应用程序的域对象类型要么实现org.apache.geode.pdx.PdxSerializable接口，要么实现并注册org.apache.geode.pdx.PdxSerializer接口的非侵入式实现，以处理需要序列化的所有应用程序域对象类型。

不幸的是，Apache Geode只允许注册一个人，这表明所有应用程序 域对象类型需要由单个实例处理。然而，这是一个严重的反模式 以及无法维持的做法。​​PdxSerializer​​​​PdxSerializer​​

即使只能向 Apache Geode 注册单个实例，创建一个 每个应用程序域对象类型的单个实现。​​PdxSerializer​​​​PdxSerializer​​

通过使用复合软件设计模式，您可以提供 接口的实现，它聚合所有特定于应用程序域对象类型的实例，但充当单个实例并注册它。​​PdxSerializer​​​​PdxSerializer​​​​PdxSerializer​​

您可以在 Spring 容器中将此复合声明为托管 Bean，并使用属性在注释中通过其 Bean 名称引用此复合。Apache Geode 的春季数据 负责代表您向Apache Geode注册它。​​PdxSerializer​​​​PdxSerializer​​​​@EnablePdx​​​​serializerBeanName​​

以下示例演示如何创建自定义复合：​​PdxSerializer​​

启用了 PDX 的 Spring应用程序，使用自定义复合​​ClientCache​​​​PdxSerializer​​

@SpringBootApplication
@ClientCacheApplication
@EnablePdx(serializerBeanName = "compositePdxSerializer")
public class ClientApplication {

  @Bean
  PdxSerializer compositePdxSerializer() {
      return new CompositePdxSerializerBuilder()...
  }
}

也可以在 Spring 上下文中将 Apache Geode 的org.apache.geode.pdx.ReflectionBasedAutoSerializer声明为 Bean 定义。

或者，您应该将Spring Data用于Apache Geode更健壮的org.springframework.data.gemfire.mapping.MappingPdxSerializer。 它使用应用于序列化过程的 Spring 数据映射元数据和基础设施来提高效率 处理比单独反射。

PDX 的许多其他方面和功能都可以使用注释属性进行调整 或关联的配置属性。@EnablePdx

有关更多详细信息，请参阅@EnablePdx注释 Javadoc。

6.11. 配置 Apache Geode 属性

虽然许多gemfire.properties在基于 SDG 注释的注释中方便地封装和抽象 配置模型，不太常用的Apache Geode属性仍然可以从 注释。​​@EnableGemFireProperties​​

用 注释应用程序类很方便，是创建应用程序的一个很好的替代方法 afile 或在命令行上将 Apache Geode 属性设置为 Java 系统属性 启动应用程序时。​​@EnableGemFireProperties​​​​gemfire.properties​​

一些您通常不必担心的不太常见的 Apache Geode 属性的示例包括： 但不限于：,,,等。​​ack-wait-threshold​​​​disable-tcp​​​​socket-buffer-size​​

要单独设置任何 Apache Geode 属性，请对应用程序类进行批注，并设置要从 Apache Geode 设置的默认值更改的 Apache Geode 属性 具有相应的属性，如下所示：​​@EnableGemFireProperties​​

设置了特定 Apache Geode 属性的 Springapplication​​ClientCache​​

@SpringBootApplication
@ClientCacheApplication
@EnableGemFireProperties(conflateEvents = true, socketBufferSize = 16384)
public class ClientApplication { .. }

请记住，某些 Apache Geode 属性是特定于客户端的（例如， 而其他是特定于服务器的（例如,,,,,等）。​​conflateEvents​​​​distributedSystemId​​​​enableNetworkPartitionDetection​​​​enforceUniqueHost​​​​memberTimeout​​​​redundancyZone​​

有关Apache Geode属性的更多详细信息，请参见此处。

6.12. 配置区域

到目前为止，在PDX之外，我们的讨论集中在配置Apache Geode的更多管理功能上： 创建缓存实例、启动嵌入式服务、启用日志记录和统计信息、配置 PDX 以及用于影响低级配置和行为。虽然所有这些配置选项都很重要， 它们都与您的应用程序没有直接关系。换句话说，我们仍然需要一些地方来存储我们的应用程序数据 并使其普遍可用和可访问。​​gemfire.properties​​

Apache Geode将缓存中的数据组织到区域中。 您可以将区域视为关系数据库中的表。通常，一个区域应该只存储一种类型的对象， 这使得它更有利于构建有效的索引和编写查询。稍后我们将介绍索引。

以前，Apache Geode用户的Spring Data需要显式定义和声明其应用程序用于存储数据的区域。 通过编写非常冗长的 Spring 配置元数据，无论是使用 SDG 来自 API 使用 Spring 基于Java 的容器配置或使用XML。​​FactoryBeans​​

以下示例演示了如何在 Java 中配置区域 Bean：

使用 Spring 基于 Java 的容器配置的示例区域 Bean 定义

@Configuration
class GemFireConfiguration {

  @Bean("Example")
  PartitionedRegionFactoryBean exampleRegion(GemFireCache gemfireCache) {

      PartitionedRegionFactoryBean<Long, Example> exampleRegion =
          new PartitionedRegionFactoryBean<>();

      exampleRegion.setCache(gemfireCache);
      exampleRegion.setClose(false);
      exampleRegion.setPersistent(true);

      return exampleRegion;
  }

  ...
}

以下示例演示如何在 XML 中配置相同的区域 Bean：

使用 SDG 的 XML 命名空间的示例区域 Bean 定义

<gfe:partitioned-region id="exampleRegion" name="Example" persistent="true">
    ...
</gfe:partitioned-region>

虽然 Java 和 XML 配置都不难指定，但任何一个都可能很麻烦，特别是如果 应用程序需要大量区域。许多基于关系数据库的应用程序可能有数百个 甚至数千张桌子。

手动定义和声明所有这些区域将很麻烦且容易出错。好吧，现在有更好的方法了。

现在，您可以根据区域的应用程序域对象（实体）本身来定义和配置区域。不再做 你需要在 Spring 配置元数据中显式定义 Bean 定义，除非你需要 更细粒度的控制。​​Region​​

为了简化区域创建，Spring Data for Apache Geode将Spring Data Repository的使用与富有表现力的 使用新注释的基于注释的配置的强大功能。​​@EnableEntityDefinedRegions​​

首先，应用程序开发人员首先定义应用程序的域对象（实体），如下所示：

应用程序域对象类型建模书籍

@Region("Books")
class Book {

  @Id
  private ISBN isbn;

  private Author author;

  private Category category;

  private LocalDate releaseDate;

  private Publisher publisher;

  private String title;

}

接下来，通过扩展 Spring 数据共享接口定义一个基本存储库，如下所示：​​Books​​​​org.springframework.data.repository.CrudRepository​​

图书存储库

interface BookRepository extends CrudRepository<Book, ISBN> { .. }

这是一个提供基本数据访问的数据访问对象（DAO） 操作 （CRUD） 以及对简单查询（例如）的支持。您可以定义其他， 通过在存储库接口上声明查询方法进行更复杂的查询 （例如，）。​​org.springframe.data.repository.CrudRepository​​​​findById(..)​​​​List<BooK> findByAuthor(Author author);​​

在后台，Spring Data for Apache Geode 提供了应用程序存储库接口的实现，当 Spring 容器是自举的。SDG 甚至实现了您定义的查询方法，只要您遵循 公约。

现在，当您定义类时，您还指定了映射（存储）实例的区域 通过在实体类型上声明 Apache Geode 映射注释的 Spring 数据。当然，如果实体类型（， 在本例中）在存储库接口的类型参数中引用（在本例中为 没有批注，名称派生自实体类型的简单类名（也， 在这种情况下）。​​Book​​​​Book​​​​@Region​​​​Book​​​​BookRepository​​​​@Region​​​​Book​​

Spring Data for Apache Geode 使用映射上下文，其中包含应用程序中定义的所有实体的映射元数据， 以确定运行时所需的所有区域。

若要启用和使用此功能，请使用以下内容对应用程序类进行批注：​​@EnableEntityDefinedRegions​​

实体定义的区域配置

@SpringBootApplication
@ClientCacheApplication
@EnableEntityDefinedRegions(basePackages = "example.app.domain")
@EnableGemfireRepositories(basePackages = "example.app.repo")
class ClientApplication { .. }

默认情况下，注释以递归方式扫描实体类，从 声明注释的配置类的包。​​@EnableEntityDefinedRegions​​​​@EnableEntityDefinedRegions​​

但是，通常通过在扫描期间通过设置属性来限制搜索 包含应用程序实体类的包名称。​​basePackages​​

或者，可以使用更安全的类型属性来指定要扫描的包 通过将属性设置为包含实体类的包中的实体类型，或使用非实体 专门为标识要扫描的包而创建的占位符类。​​basePackageClasses​​

下面的示例演示如何指定要扫描的实体类型：

使用实体类类型的实体定义区域配置

@SpringBootApplication
@ClientCacheApplication
@EnableGemfireRepositories
@EnableEntityDefinedRegions(basePackageClasses = {
    example.app.books.domain.Book.class,
    example.app.customers.domain.Customer.class
})
class ClientApplication { .. }

除了指定从哪里开始扫描（如 Spring 的 sannotation）之外，您还可以使用所有相同的注释语义来指定和过滤器。​​@ComponentScan​​​​include​​​​exclude​​​​org.springframework.context.annotation.ComponentScan.Filter​​

有关更多详细信息，请参阅@EnableEntityDefinedRegions注释 Javadoc。

6.12.1. 配置特定类型的区域

Apache Geode支持许多不同类型的区域。 每种类型对应于区域的数据策略， 这决定了区域中数据的管理方式（即分布式、复制等）。

当您使用泛型映射注释注释应用程序域对象类型时，Spring Data for Apache Geode 决定 要创建的区域类型。SDG 的默认策略在以下情况下考虑缓存类型 确定要创建的区域类型。​​@Region​​

例如，如果使用注释将应用程序声明为 a， SDG 默认创建客户端。或者，如果将应用程序声明为 使用任一理论注释的对等， SDG 默认创建一个服务器。​​ClientCache​​​​@ClientCacheApplication​​​​PROXY​​​​Region​​​​Cache​​​​@PeerCacheApplication​​​​@CacheServerApplication​​​​PARTITION​​​​Region​​

当然，您始终可以在必要时覆盖默认值。要覆盖 Spring Data 为 Apache Geode 应用的默认值， 引入了四个新的区域映射注释：

• ​​@ClientRegion​​
• ​​@LocalRegion​​
• ​​@PartitionRegion​​
• ​​@ReplicateRegion​​

映射批注特定于客户端应用程序。所有其他区域映射注释 上面列出的只能在具有嵌入式对等方的服务器应用程序中使用。​​@ClientRegion​​​​Cache​​

客户端应用程序有时需要创建和使用仅限本地的区域，可能需要聚合数据 从其他地区，以便在本地分析数据并执行应用程序执行的某些功能 代表用户。在这种情况下，数据不需要分发回服务器，除非其他 应用程序需要访问结果。该区域甚至可能是临时的，并在使用后丢弃，这可能是 通过区域本身的空闲超时 （TTI） 和生存时间 （TTL） 过期策略完成。 （有关过期策略的更多信息，请参阅“配置过期”。

在任何情况下，如果您想创建一个仅本地客户端区域，其中数据不会分发回 服务器上同名的对应区域，可以声明映射标注 并将属性设置为，如下所示：​​@ClientRegion​​​​shortcut​​​​ClientRegionShortcut.LOCAL​​

具有仅限本地的客户端区域的 Spring 应用程序​​ClientCache​​

@ClientRegion(shortcut = ClientRegionShortcut.LOCAL)
class ClientLocalEntityType { .. }

所有特定于区域类型的注释都提供跨区域类型通用的其他属性 以及仅特定于该类型的区域。例如，和属性 在标注中仅适用于服务器端，仅限区域。​​collocatedWith​​​​redundantCopies​​​​PartitionRegion​​​​PARTITION​​

有关 Apache Geode 区域类型的更多详细信息，请参阅此处。

6.12.2. 配置的集群定义区域

除了theannotation，Spring Data for Apache Geode还提供了反向注释。而不是将您的区域基于定义和驱动的实体类 您的应用程序用例 （UC） 和要求（最常见和最合乎逻辑的方法），或者，您可以 从您的应用程序到的集群中已定义的区域声明您的区域 将连接。​​@EnableEntityDefinedRegions​​​​@EnableClusterDefinedRegions​​​​ClientCache​​

这允许您使用服务器集群作为数据定义的主要来源来集中配置 并确保群集的所有客户端应用程序具有一致的配置。这特别有用 快速纵向扩展同一客户端应用程序的大量实例以处理增加的负载时 在云托管环境中。

这个想法是，用户定义区域，而不是驱动数据字典的客户端应用程序。 使用 Apache Geode 的GfshCLI shell 工具。这具有额外的优势，即当添加其他对等体时 对于集群，它们也将拥有并共享相同的配置，因为它被Apache Geode的集群配置服务记住。

例如，用户可以在Gfsh 中定义一个区域，如下所示：

使用 Gfsh 定义区域

gfsh>create region --name=Books --type=PARTITION
 Member   | Status
--------- | --------------------------------------
ServerOne | Region "/Books" created on "ServerOne"
ServerTwo | Region "/Books" created on "ServerTwo"

gfsh>list regions
List of regions
---------------
Books

gfsh>describe region --name=/Books
..........................................................
Name            : Books
Data Policy     : partition
Hosting Members : ServerTwo
                  ServerOne

Non-Default Attributes Shared By Hosting Members

 Type  |    Name     | Value
------ | ----------- | ---------
Region | size        | 0
       | data-policy | PARTITION

使用 Apache Geode 的集群配置服务，任何其他对等成员都可以添加到服务器集群中 处理增加的负载（在后端）也将具有相同的配置，例如：

向集群添加其他对等成员

gfsh>list members
  Name    | Id
--------- | ----------------------------------------------
Locator   | 10.0.0.121(Locator:68173:locator)<ec><v0>:1024
ServerOne | 10.0.0.121(ServerOne:68242)<v3>:1025
ServerTwo | 10.0.0.121(ServerTwo:68372)<v4>:1026

gfsh>start server --name=ServerThree --log-level=config --server-port=41414
Starting a Geode Server in /Users/you/geode/cluster/ServerThree...
...
Server in /Users/you/geode/cluster/ServerThree... on 10.0.0.121[41414] as ServerThree is currently online.
Process ID: 68467
Uptime: 3 seconds
Geode Version: 1.2.1
Java Version: 1.8.0_152
Log File: /Users/you/geode/cluster/ServerThree/ServerThree.log
JVM Arguments: -Dgemfire.default.locators=10.0.0.121[10334]
  -Dgemfire.use-cluster-configuration=true
  -Dgemfire.start-dev-rest-api=false
  -Dgemfire.log-level=config
  -XX:OnOutOfMemoryError=kill -KILL %p
  -Dgemfire.launcher.registerSignalHandlers=true
  -Djava.awt.headless=true
  -Dsun.rmi.dgc.server.gcInterval=9223372036854775806
Class-Path: /Users/you/geode/cluster/apache-geode-1.2.1/lib/geode-core-1.2.1.jar
  :/Users/you/geode/cluster/apache-geode-1.2.1/lib/geode-dependencies.jar

gfsh>list members
   Name     | Id
----------- | ----------------------------------------------
Locator     | 10.0.0.121(Locator:68173:locator)<ec><v0>:1024
ServerOne   | 10.0.0.121(ServerOne:68242)<v3>:1025
ServerTwo   | 10.0.0.121(ServerTwo:68372)<v4>:1026
ServerThree | 10.0.0.121(ServerThree:68467)<v5>:1027

gfsh>describe member --name=ServerThree
Name        : ServerThree
Id          : 10.0.0.121(ServerThree:68467)<v5>:1027
Host        : 10.0.0.121
Regions     : Books
PID         : 68467
Groups      :
Used Heap   : 37M
Max Heap    : 3641M
Working Dir : /Users/you/geode/cluster/ServerThree
Log file    : /Users/you/geode/cluster/ServerThree/ServerThree.log
Locators    : 10.0.0.121[10334]

Cache Server Information
Server Bind              :
Server Port              : 41414
Running                  : true
Client Connections       : 0

如您所见，“ServerThree”现在具有“书籍”区域。如果任何或所有服务器出现故障，他们将拥有 相同的配置以及“书籍”区域何时恢复。

在客户端，许多书店客户端应用程序实例可能会启动以处理针对 书店在线服务。“书籍”区域可能是需要实施的众多不同区域之一 书店应用程序服务。SDG不必单独创建和配置每个区域 方便地允许从集群定义客户端应用程序区域，如下所示：

使用 从集群定义客户端区域​​@EnableClusterDefinedRegions​​

@ClientCacheApplication
@EnableClusterDefinedRegions
class BookStoreClientApplication {

    public static void main(String[] args) {
        ....
    }

    ...
}

然后，在应用程序中使用“书籍”区域变得简单。您可以注入“书籍”区域 直接，如下所示：

使用“书籍”区域

@org.springframework.stereotype.Repository
class BooksDataAccessObject {

    @Resource(name = "Books")
    private Region<ISBN, Book> books;

    // implement CRUD and queries with the "Books" Region
}

或者，甚至根据应用程序域类型（实体）定义 Spring 数据存储库定义， 映射到“书籍”区域，如下所示：​​Book​​

将“书籍”区域与 SD 存储库结合使用

interface BookRepository extends CrudRepository<Book, ISBN> {
    ...
}

然后，您可以将自定义器注入到应用程序服务中 执行任何业务功能所需的组件。​​BooksDataAccessObject​​​​BookRepository​​

6.12.3. 配置逐出

使用 Apache Geode 管理数据是一项活动任务。通常需要调整，并且必须采用组合 的功能（例如，逐出和过期） 使用 Apache Geode 有效地管理内存中的数据。

鉴于Apache Geode是一个内存数据网格（IMDG），数据在内存中管理并分发到其他节点 参与集群，以最大程度地减少延迟，最大化吞吐量并确保数据高度可用。 由于并非所有应用程序的数据通常都能放入内存中（即使跨整个节点群集， 在单个节点上要少得多），您可以通过向群集添加新节点来增加容量。这通常被称为 作为线性横向扩展（而不是纵向扩展，这意味着添加更多内存、更多 CPU、更多磁盘、 或更多的网络带宽 — 基本上每个系统资源的更多，以便处理负载）。

尽管如此，即使有一个节点集群，通常也只能将最重要的数据保存在内存中。 内存不足，甚至接近满负荷，很少（如果有的话）是一件好事。停止世界指导性案例 或者更糟糕的是，会使您的应用程序尖叫停止。​​OutOfMemoryErrors​​

因此，为了帮助管理内存并保留最重要的数据，Apache Geode支持最近最少使用（LRU）。 驱逐。也就是说，Apache Geode 根据上次访问区域条目的时间逐出这些条目，方法是使用 最近最少使用的算法。

若要启用逐出，请使用以下内容批注应用程序类：​​@EnableEviction​​

启用了逐出的春季应用程序

@SpringBootApplication
@PeerCacheApplication
@EnableEviction(policies = {
    @EvictionPolicy(regionNames = "Books", action = EvictionActionType.INVALIDATE),
    @EvictionPolicy(regionNames = { "Customers", "Orders" }, maximum = 90,
        action = EvictionActionType.OVERFLOW_TO_DISK,
        type = EvictonPolicyType.HEAP_PERCENTAGE)
})
class ServerApplication { .. }

逐出策略通常在服务器中的区域上设置。

如前所述，该属性可以指定一个或多个嵌套注释，每个嵌套注释 单独迎合一个或多个需要应用驱逐策略的区域。​​policies​​​​@EvictionPolicy​​

此外，您可以引用Apache Geode的org.apache.geode.cache.util.ObjectSizer接口的自定义实现。 它可以定义为 Spring 容器中的 bean，并使用属性按名称引用。​​objectSizerName​​

您可以定义用于评估和确定存储在区域中的对象大小的条件。​​ObjectSizer​​

有关逐出配置选项的完整列表，请参阅@EnableEviction注释 Javadoc。

有关Apache Geode驱逐的更多详细信息，请参见此处。