Spring/spring-boot-data-geode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Replace references to 'Pivotal GemFire' with 'VMware Tanzu GemFire'.

Browse Source 
Fix compiler syntax errors in code snippets.

Introduce documentation variables where applicable.

Format source code.

Optimize imports.
This commit is contained in:
John Blum
2020-09-17 17:48:57 -07:00
parent 998d37d8ae
commit 8fb0c2112b
117 changed files with 712 additions and 776 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CONTRIBUTING.adoc
View File

@@ -1,6 +1,6 @@
= Contributing to Spring Boot for Apache Geode & Pivotal GemFire
= Contributing to Spring Boot for Apache Geode & VMware Tanzu GemFire
Spring Boot for Apache Geode & Pivotal GemFire (SBDG) is released under the Apache 2.0 license. If you would like to
Spring Boot for Apache Geode & VMware Tanzu GemFire (SBDG) is released under the Apache 2.0 license. If you would like to
contribute something, or simply want to hack on the code this document should help you get started.
== Sign the Contributor License Agreement

36
README.adoc
View File

@@ -1,45 +1,45 @@
image:https://api.travis-ci.org/spring-projects/spring-boot-data-geode.svg?branch=master["Build Status", link="https://travis-ci.org/spring-projects/spring-boot-data-geode"]
[[about]]
== Spring Boot for Apache Geode & Pivotal GemFire
== Spring Boot for Apache Geode & VMware Tanzu GemFire
_Spring Boot for Apache Geode & Pivotal GemFire_ extends https://projects.spring.io/spring-boot/[_Spring Boot_] with
_Spring Boot for Apache Geode & VMware Tanzu GemFire_ extends https://projects.spring.io/spring-boot/[_Spring Boot_] with
_auto-configuration_ support as well as other _convention or configuration_ features to simplify the development
of _Spring_ applications using either https://geode.apache.org/[Apache Geode] or https://pivotal.io/pivotal-gemfire[Pivotal GemFire]
of _Spring_ applications using either https://geode.apache.org/[Apache Geode] or https://pivotal.io/pivotal-gemfire[VMware Tanzu GemFire]
in a _Spring_ context.
This project builds on both https://github.com/spring-projects/spring-data-geode[_Spring Data for Apache Geode_]
and https://projects.spring.io/spring-data-gemfire/[_Spring Data for Pivotal GemFire_]
and https://projects.spring.io/spring-data-gemfire/[_Spring Data for VMware Tanzu GemFire_]
as well as https://spring.io/projects/spring-boot[Spring Boot].
[[project-goals]]
=== Project Goals
This project adds _Spring Boot_ **auto-configuration** support for both https://geode.apache.org/[Apache Geode]
and https://pivotal.io/pivotal-gemfire[Pivotal GemFire].
and https://pivotal.io/pivotal-gemfire[VMware Tanzu GemFire].
Among other things, this project builds on https://projects.spring.io/spring-boot/[_Spring Boot_]
as well as https://projects.spring.io/spring-data-gemfire/[_Spring Data for Apache Geode & Pivotal GemFire_]
as well as https://projects.spring.io/spring-data-gemfire/[_Spring Data for Apache Geode & VMware Tanzu GemFire_]
and additionally offers...
1. _Auto-configures_ an _Apache Geode_ or _Pivotal GemFire_ (PCC)
1. _Auto-configures_ an _Apache Geode_ or _VMware Tanzu GemFire_ (PCC)
https://geode.apache.org/releases/latest/javadoc/org/apache/geode/cache/client/ClientCache.html[ClientCache]
instance automatically when either _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_
instance automatically when either _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_
are on the application's CLASSPATH.
2. _Auto-configures_ either _Apache Geode_ or _Pivotal GemFire_ (PCC) as a _caching provider_ in
2. _Auto-configures_ either _Apache Geode_ or _VMware Tanzu GemFire_ (PCC) as a _caching provider_ in
https://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#cache[_Spring's Cache Abstraction_]
when either _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_ are on the application's CLASSPATH.
when either _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_ are on the application's CLASSPATH.
3. _Auto-configures_ _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_
3. _Auto-configures_ _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_
https://docs.spring.io/spring-data-gemfire/docs/current/reference/html/#gemfire-repositories[Repositories]
when _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_ are on the application's CLASSPATH
when _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_ are on the application's CLASSPATH
and _Spring Boot_ detects SDG _Repositories_ in your _Spring Boot_ application.
4. Provides additional support for _Spring Boot_/_Spring Data for Apache Geode_/_Pivotal GemFire_ applications
4. Provides additional support for _Spring Boot_/_Spring Data for Apache Geode_/_VMware Tanzu GemFire_ applications
deployed to PCF using Pivotal Cloud Cache (PCC). Additionally, if your application requires (HTTP) Session State
Caching services, you can also take advantage of
https://github.com/spring-projects/spring-session-data-geode[_Spring Session for Apache Geode/Pivotal GemFire_].
https://github.com/spring-projects/spring-session-data-geode[_Spring Session for Apache Geode/VMware Tanzu GemFire_].
This, along with many other benefits, are provided by this project.
@@ -66,17 +66,17 @@ This, along with many other benefits, are provided by this project.
=== Examples
The single, most relevant "_source of truth_" on how to get started quickly and effectively, using Spring Boot
for Apache Geode & Pivotal GemFire (SBDG) to solve problems, is to start with the
for Apache Geode & VMware Tanzu GemFire (SBDG) to solve problems, is to start with the
https://docs.spring.io/spring-boot-data-geode-build/current/reference/html5/#geode-samples[Samples].
There, you will find different examples with documentation and code showing you how to use SBDG to appropriately
handle specific application concerns, like Caching.
You can find an example of using SBDG in the Pivotal Cloud Cache (PCC) https://github.com/pivotal-cf/PCC-Sample-App-PizzaStore[Pizza Store]
GitHub repository, which is a Spring Boot, Pivotal GemFire `ClientCache` application that connects to PCC when the app
GitHub repository, which is a Spring Boot, VMware Tanzu GemFire `ClientCache` application that connects to PCC when the app
is deployed to PCF.
The https://github.com/jxblum/contacts-application/tree/master/boot-example[boot-example] found in the
_Contacts Application Reference Implementation_ for _Spring Data for Apache Geode & Pivotal GemFire_ (SDG) uses SBDG
_Contacts Application Reference Implementation_ for _Spring Data for Apache Geode & VMware Tanzu GemFire_ (SDG) uses SBDG
to manage Books in a _System of Record_ Use Case.
Then, there is a series of examples that walks a user through a series of steps starting by building a simple,
@@ -112,5 +112,5 @@ Please see our https://github.com/spring-projects/spring-boot-data-geode/securit
[[license]]
== License
_Spring Boot_, _Spring Boot for Apache Geode_ and _Spring Boot for Pivotal GemFire_ is Open Source Software
_Spring Boot_, _Spring Boot for Apache Geode_ and _Spring Boot for VMware Tanzu GemFire_ is Open Source Software
released under the https://www.apache.org/licenses/LICENSE-2.0.html[Apache 2.0 license].

2
build.gradle
View File

@@ -12,7 +12,7 @@ buildscript {
apply plugin: 'io.spring.convention.root'
group = 'org.springframework.geode'
description = 'Spring Boot for Apache Geode & Pivotal GemFire'
description = 'Spring Boot for Apache Geode & VMware Tanzu GemFire'
//ext['spring.version'] = "$springVersion"
//ext['spring-framework.version'] = "$springVersion"

2
spring-gemfire-starter-actuator/spring-gemfire-starter-actuator.gradle
View File

@@ -1,7 +1,7 @@
apply plugin: 'io.spring.convention.spring-module'
apply from: MAVEN_POM_EDITOR_GRADLE
description = "Spring Boot Actuator Starter for Pivotal GemFire"
description = "Spring Boot Actuator Starter for VMware Tanzu GemFire"
dependencies {

2
spring-gemfire-starter-logging/spring-gemfire-starter-logging.gradle
View File

@@ -1,7 +1,7 @@
apply plugin: 'io.spring.convention.spring-module'
apply from: MAVEN_POM_EDITOR_GRADLE
description = "Spring Boot Logging Starter for Pivotal GemFire with Logback as the logging provider and adaptation of Log4j to SLF4J"
description = "Spring Boot Logging Starter for VMware Tanzu GemFire with Logback as the logging provider and adaptation of Log4j to SLF4J"
dependencies {

2
spring-gemfire-starter-session/spring-gemfire-starter-session.gradle
View File

@@ -1,7 +1,7 @@
apply plugin: 'io.spring.convention.spring-module'
apply from: MAVEN_POM_EDITOR_GRADLE
description = "Spring Boot Starter for Spring Session using Pivotal GemFire"
description = "Spring Boot Starter for Spring Session using VMware Tanzu GemFire"
dependencies {

2
spring-gemfire-starter-test/spring-gemfire-starter-test.gradle
View File

@@ -1,7 +1,7 @@
apply plugin: 'io.spring.convention.spring-module'
apply from: MAVEN_POM_EDITOR_GRADLE
description = "Spring Boot Test Starter for Pivotal GemFire"
description = "Spring Boot Test Starter for VMware Tanzu GemFire"
dependencies {

2
spring-gemfire-starter/spring-gemfire-starter.gradle
View File

@@ -1,7 +1,7 @@
apply plugin: 'io.spring.convention.spring-module'
apply from: MAVEN_POM_EDITOR_GRADLE
description = "Spring Boot Starter for Pivotal GemFire"
description = "Spring Boot Starter for VMware Tanzu GemFire"
dependencies {

2
spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/GeodeHealthIndicatorAutoConfiguration.java
View File

@@ -32,7 +32,7 @@ import org.springframework.geode.boot.actuate.autoconfigure.config.PeerCacheHeal
import org.springframework.geode.boot.autoconfigure.ClientCacheAutoConfiguration;
/**
* Spring Boot {@link EnableAutoConfiguration auto-configuration} for Apache Geode/Pivotal GemFire
* Spring Boot {@link EnableAutoConfiguration auto-configuration} for Apache Geode
* {@link HealthIndicator HealthIndicators}.
*
* @author John Blum

2
spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/BaseGeodeHealthIndicatorConfiguration.java
View File

@@ -29,7 +29,7 @@ import org.springframework.geode.boot.actuate.GeodeIndexesHealthIndicator;
import org.springframework.geode.boot.actuate.GeodeRegionsHealthIndicator;
/**
* Spring {@link Configuration @Configuration} class declaring Spring beans for general Apache Geode/Pivotal GemFire
* Spring {@link Configuration @Configuration} class declaring Spring beans for general Apache Geode
* peer {@link Cache} and {@link ClientCache} {@link HealthIndicator HealthIndicators}.
*
* @author John Blum

2
spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/ClientCacheHealthIndicatorConfiguration.java
View File

@@ -33,7 +33,7 @@ import org.springframework.geode.boot.actuate.GeodeContinuousQueriesHealthIndica
import org.springframework.geode.boot.actuate.GeodePoolsHealthIndicator;
/**
* Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode/Pivotal GemFire
* Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode
* {@link ClientCache} {@link HealthIndicator HealthIndicators}.
*
* @author John Blum

4
spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/PeerCacheHealthIndicatorConfiguration.java
View File

@@ -43,8 +43,8 @@ import org.springframework.geode.core.util.ObjectUtils;
import org.springframework.lang.Nullable;
/**
* Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode/Pivotal GemFire
* peer {@link Cache} {@link HealthIndicator HealthIndicators}.
* Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode peer {@link Cache}
* {@link HealthIndicator HealthIndicators}.
*
* @author John Blum
* @see org.apache.geode.cache.Cache

4
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/CacheNameAutoConfiguration.java
View File

@@ -36,8 +36,8 @@ import org.springframework.util.StringUtils;
/**
* Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure the Apache Geode
* / Pivotal GemFire {@link ClientCache} application or peer {@link Cache} member node name
* (i.e. {@literal gemfire.name}) with the Spring Boot {@literal spring.application.name} property.
* {@link ClientCache} application or peer {@link Cache} member node name (i.e. {@literal gemfire.name})
* with the Spring Boot {@literal spring.application.name} property.
*
* @author John Blum
* @see org.apache.geode.cache.Cache

2
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/GemFirePropertiesAutoConfiguration.java
View File

@@ -30,7 +30,7 @@ import org.springframework.geode.boot.autoconfigure.configuration.GemFirePropert
/**
* Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure Spring Boot
* {@link ConfigurationProperties @ConfigurationProperites} classes and beans from the Spring {@link Environment}
* containing Apache Geode / Pivotal GemFire configuration properties.
* containing Apache Geode configuration properties.
*
* @author John Blum
* @see org.apache.geode.cache.GemFireCache

2
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/LoggingAutoConfiguration.java
View File

@@ -26,7 +26,7 @@ import org.springframework.data.gemfire.CacheFactoryBean;
import org.springframework.data.gemfire.config.annotation.EnableLogging;
/**
* Spring Boot {@link EnableAutoConfiguration Auto-Configuration} for Apache Geode and Pivotal GemFire logging.
* Spring Boot {@link EnableAutoConfiguration Auto-Configuration} for Apache Geode logging.
*
* @author John Blum
* @see org.springframework.boot.autoconfigure.EnableAutoConfiguration

4
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/RegionTemplateAutoConfiguration.java
View File

@@ -65,8 +65,8 @@ import org.springframework.util.StringUtils;
/**
* Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure a {@link GemfireTemplate}
* for each Apache Geode / Pivotal GemFire {@link Region} declared/defined in
* the Spring {@link ConfigurableApplicationContext} in order to perform {@link Region} data access operations.
* for each Apache Geode {@link Region} declared/defined in the Spring {@link ConfigurableApplicationContext}
* in order to perform {@link Region} data access operations.
*
* @author John Blum
* @see org.apache.geode.cache.GemFireCache

2
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionAutoConfiguration.java
View File

@@ -48,7 +48,7 @@ import org.springframework.util.StringUtils;
/**
* Spring Boot {@link EnableAutoConfiguration auto-configuration} for configuring either Apache Geode
* or Pivotal GemFire as an (HTTP) {@link Session} state management provider in Spring Session.
* as an (HTTP) {@link Session} state management provider in Spring Session.
*
* @author John Blum
* @see java.util.Properties

4
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionPropertiesAutoConfiguration.java
View File

@@ -32,8 +32,8 @@ import org.springframework.session.data.gemfire.config.annotation.web.http.GemFi
/**
* Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure Spring Boot
* {@link ConfigurationProperties @ConfigurationProperites} classes and beans from the Spring {@link Environment}
* containing Spring Session configuration properties used to configure either Apache Geode or Pivotal GemFire
* to manage (HTTP) Session state.
* containing Spring Session configuration properties used to configure either Apache Geode to manage (HTTP) Session
* state.
*
* @author John Blum
* @see org.apache.geode.cache.GemFireCache

4
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/GemFireProperties.java
View File

@@ -33,8 +33,8 @@ import org.springframework.geode.boot.autoconfigure.configuration.support.Securi
import org.springframework.geode.boot.autoconfigure.configuration.support.ServiceProperties;
/**
* Spring Boot {@link ConfigurationProperties} for well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* Spring Boot {@link ConfigurationProperties} for well-known, documented Spring Data for Apache Geode(SDG)
* {@link Properties}.
*
* This class assists the application developer in the auto-completion / content-assist of the well-known, documented
* SDG {@link Properties}.

6
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/SpringSessionProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration;
import org.apache.geode.cache.RegionShortcut;
@@ -23,9 +22,8 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Spring Session for Apache Geode or Pivotal GemFire
* (SSDG) in order to manage (HTTP) Session state with Spring Session, backed by either Apache Geode
* or Pivotal GemFire.
* Spring Boot {@link ConfigurationProperties} used to configure Spring Session for Apache Geode (SSDG) in order to
* manage (HTTP) Session state with Spring Session, backed by Apache Geode.
*
* @author John Blum
* @see org.springframework.boot.context.properties.ConfigurationProperties

9
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -27,11 +26,11 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire peer {@link Cache},
* {@link ClientCache} and {@link CacheServer} objects.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode peer {@link Cache}, {@link ClientCache}
* and {@link CacheServer} objects.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

7
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheServerProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -25,10 +24,10 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.data.gemfire.server.SubscriptionEvictionPolicy;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire {@link CacheServer}.
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode {@link CacheServer}.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

5
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientCacheProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -23,9 +22,9 @@ import org.apache.geode.cache.client.ClientCache;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire {@link ClientCache}.
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode {@link ClientCache}.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode
* (SDG) {@link Properties}.
*
* @author John Blum

9
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientSecurityProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -23,11 +22,11 @@ import org.apache.geode.cache.client.ClientCache;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire {@link ClientCache}
* Security (authentication & authorization).
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode {@link ClientCache} Security
* (authentication & authorization).
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

7
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClusterProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -26,10 +25,10 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure the {@link DataPolicy} of all {@link Region Regions}
* in an Apache Geode / Pivotal GemFire cluster.
* in an Apache Geode cluster.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

6
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/DiskStoreProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -24,10 +23,9 @@ import org.apache.geode.cache.DiskStoreFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire
* {@link DiskStore DiskStores}.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode {@link DiskStore DiskStores}.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode
* (SDG) {@link Properties}.
*
* @author John Blum

7
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/EntityProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -25,10 +24,10 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure the application base {@link Package package}
* containing the application entity classes. The entity classes are then used to create and configure
* Apache Geode / Pivotal GemFire {@link Region Regions}.
* Apache Geode {@link Region Regions}.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

8
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LocatorProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -23,14 +22,13 @@ import org.apache.geode.distributed.Locator;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode / Pivotal GemFire
* {@link Locator}.
* Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode {@link Locator}.
*
* A {@link Locator} enables location services used by nodes to join an existing cluster as a peer member
* and is also used by clients to discover servers in the cluster.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

5
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LoggingProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -21,9 +20,9 @@ import java.util.Properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire logging.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode logging.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode
* (SDG) {@link Properties}.
*
* @author John Blum

6
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagementProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -21,10 +20,9 @@ import java.util.Properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire management services,
* such as HTTP.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode management services, such as HTTP.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode
* (SDG) {@link Properties}.
*
* @author John Blum

6
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagerProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -21,12 +20,11 @@ import java.util.Properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode / Pivotal GemFire
* {@literal Manager}.
* Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode {@literal Manager}.
*
* A {@literal Manager} allows users to manage a cluster with tools like {@literal Gfsh} or {@literal Pulse}.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode
* (SDG) {@link Properties}.
*
* @author John Blum

17
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PdxProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -21,17 +20,15 @@ import java.util.Properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire
* {@literal PDX} serialization.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode {@literal PDX} serialization.
*
* PDX serialization is an alternative serialization format to Java Serialization provided by
* Apache Geode / Pivotal GemFire. PDX enables interoperability with native language clients (e.g. C++),
* enables objects stored in GemFire/Geode to be queried without causing deserialization and is a more efficient
* format than Java Serialization. While PDX is more robust in some ways, it is less robust in others. For example,
* PDX does not handle cyclic references in the object graph.
* PDX serialization is an alternative serialization format to Java Serialization provided by Apache Geode. PDX enables
* interoperability with native language clients (e.g. C++), enables objects stored in GemFire/Geode to be queried
* without causing deserialization and is a more efficient format than Java Serialization. While PDX is more robust
* in some ways, it is less robust in others. For example, PDX does not handle cyclic references in the object graph.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

7
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerCacheProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -23,10 +22,10 @@ import org.apache.geode.cache.Cache;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire peer {@link Cache}.
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode peer {@link Cache}.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

9
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerSecurityProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -23,11 +22,11 @@ import org.apache.geode.cache.Cache;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire peer {@link Cache}
* Security (authentication & authorization).
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode peer {@link Cache} Security
* (authentication & authorization).
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

6
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PoolProperties.java
View File

@@ -23,10 +23,10 @@ import org.apache.geode.cache.client.PoolFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire peer {@link Pool}.
* Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode client {@link Pool}.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

7
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SecurityProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -22,13 +21,13 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire Security.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode Security.
*
* Security configuration covers Authentication & Authorization (AUTH) as well as Secure Transport using SSL
* (i.e. securing data in motion). Securing data at rest (e.g. disk based encryption) is not yet supported.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* (SDG) {@link Properties}.
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG)
* {@link Properties}.
*
* @author John Blum
* @see java.util.Properties

5
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ServiceProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -22,12 +21,12 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.data.gemfire.config.annotation.EnableMemcachedServer;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire embedded services.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode embedded services.
*
* Currently, the supported embedded services include HTTP service (Jetty), Memcached (protocol) server
* and a Redis (protocol) server.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode
* (SDG) {@link Properties}.
*
* @author John Blum

5
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SslProperties.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.configuration.support;
import java.util.Properties;
@@ -23,12 +22,12 @@ import org.springframework.boot.context.properties.NestedConfigurationProperty;
import org.springframework.data.gemfire.config.annotation.EnableSsl;
/**
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire Socket layer SSL.
* Spring Boot {@link ConfigurationProperties} used to configure Apache Geode Socket layer SSL.
*
* The SSL configuration is used to secure communications and data in motion between clients and servers
* as well as between peers in a cluster.
*
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire
* The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode
* (SDG) {@link Properties}.
*
* @author John Blum

2
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/package-info.java
View File

@@ -15,6 +15,6 @@
*/
/**
* Spring Boot auto-configuration for Apache Geode & Pivotal GemFire.
* Spring Boot auto-configuration for Apache Geode.
*/
package org.springframework.geode.boot.autoconfigure;

4
spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/support/EnableSubscriptionConfiguration.java
View File

@@ -28,8 +28,8 @@ import org.springframework.data.gemfire.config.annotation.ClientCacheConfigurer;
import org.springframework.data.gemfire.config.annotation.PoolConfigurer;
/**
* A Spring {@link Configuration} class used to enable subscription on the Apache Geode & Pivotal GemFire
* {@literal DEFAULT} {@link Pool} as well as the SDG {@literal gemfirePool} {@link Pool}, only.
* A Spring {@link Configuration} class used to enable subscription on the Apache Geode {@literal DEFAULT} {@link Pool}
* as well as the SDG {@literal gemfirePool} {@link Pool}, only.
*
* @author John Blum
* @see org.apache.geode.cache.client.Pool

10
spring-geode-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json
View File

@@ -88,7 +88,7 @@
{
"name": "session",
"type": "org.springframework.geode.boot.autoconfigure.configuration.support.SpringSessionProperties",
"description": "Configuration properties for Spring Session backed by Apache Geode or Pivotal GemFire."
"description": "Configuration properties for Spring Session backed by Apache Geode."
},
{
"name": "ssl",
@@ -100,7 +100,7 @@
{
"name": "spring.data.gemfire.name",
"type": "java.lang.String",
"description": "Name of the Apache Geode / Pivotal GemFire member."
"description": "Name of the Apache Geode member."
},
{
"name": "spring.data.gemfire.locators",
@@ -149,7 +149,7 @@
"name": "spring.data.gemfire.cache.log-level",
"type": "java.lang.String",
"default": "config",
"description": "Configure the log-level of an Apache Geode / Pivotal GemFire cache."
"description": "Configure the log-level of an Apache Geode cache."
},
{
"name": "spring.data.gemfire.cache.name",
@@ -405,7 +405,7 @@
"name": "spring.data.gemfire.logging.level",
"type": "java.lang.String",
"default": "config",
"description": "Configures the log-level of an Apache Geode / Pivotal GemFire cache; Alias for 'spring.data.gemfire.cache.log-level'."
"description": "Configures the log-level of an Apache Geode cache; Alias for 'spring.data.gemfire.cache.log-level'."
},
{
"name": "spring.data.gemfire.logging.log-disk-space-limit",
@@ -840,7 +840,7 @@
"name": "spring.data.gemfire.service.http.dev-rest-api-start",
"type": "java.lang.Boolean",
"default": false,
"description": "Configures whether to start the Developer REST API web service. A full installation of Apache Geode or Pivotal GemFire is required and you must set the $GEODE environment variable."
"description": "Configures whether to start the Developer REST API web service. A full installation of Apache Geode is required and you must set the $GEODE environment variable."
},
{
"name": "spring.data.gemfire.service.memcached.port",

2
spring-geode-autoconfigure/src/test/java/example/geode/query/cq/event/TemperatureReadingsContinuousQueriesHandler.java
View File

@@ -26,7 +26,7 @@ import org.apache.geode.cache.query.CqEvent;
import org.springframework.data.gemfire.listener.annotation.ContinuousQuery;
/**
* The {@link TemperatureReadingsContinuousQueriesHandler} class is a POJO containing Apache Geode/Pivotal GemFire
* The {@link TemperatureReadingsContinuousQueriesHandler} class is a POJO containing Apache Geode
* Continuous Query (CQ) definitions.
*
* @author John Blum

4
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/AutoConfiguredCachingIntegrationTests.java
View File

@@ -43,8 +43,8 @@ import example.app.books.model.Book;
import example.app.books.service.support.CachingBookService;
/**
* Integration tests testing the auto-configuration of Spring's Cache Abstraction with Apache Geode
* or Pivotal GemFire as the caching provider.
* Integration Tests testing the auto-configuration of Spring's Cache Abstraction with Apache Geode
* as the caching provider.
*
* @author John Blum
* @see org.junit.Test

6
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/ManuallyConfiguredCachingIntegrationTests.java
View File

@@ -35,9 +35,9 @@ import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration tests for {@link CachingProviderAutoConfiguration} asserting that neither Apache Geode
* nor Pivotal GemFire is configured as the caching provider in Spring's Cache Abstraction when another
* caching provider (i.e. {@link CacheManager} bean) has been declared and configured.
* Integration Tests for {@link CachingProviderAutoConfiguration} asserting that Apache Geode is not configured as
* the caching provider in Spring's Cache Abstraction when another caching provider (i.e. {@link CacheManager} bean)
* has been declared and configured.
*
* @author John Blum
* @see org.junit.Test

8
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/configuration/GeodePropertiesVsSpringDataGeodePropertiesPrecedenceIntegrationTests.java
View File

@@ -35,11 +35,11 @@ import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests asserting and testing the precedence of GemFire, Spring and Spring Data for Apache Geode
* & Pivotal GemFire (SDG) {@link Properties} precedence.
* Integration Tests asserting and testing the precedence of GemFire, Spring and Spring Data for Apache Geode (SDG)
* {@link Properties} precedence.
*
* Essentially, SDG {@link Properties} should take precedence over (i.e. override) both Spring And Apache Geode
* or Pivotal GemFire {@link Properties}.
* Essentially, SDG {@link Properties} should take precedence over (i.e. override) both Spring and Apache Geode
* {@link Properties}.
*
* @author John Blum
* @see org.junit.Test

2
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/cq/AutoConfiguredContinuousQueryIntegrationTests.java
View File

@@ -54,7 +54,7 @@ import example.geode.query.cq.event.TemperatureReading;
import example.geode.query.cq.event.TemperatureReadingsContinuousQueriesHandler;
/**
* Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire Continuous Query.
* Integration Tests testing the auto-configuration of Apache Geode Continuous Query.
*
* @author John Blum
* @see org.junit.Test

2
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/AutoConfiguredFunctionExecutionsIntegrationTests.java
View File

@@ -42,7 +42,7 @@ import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.Assert;
/**
* Integration Tests testing the auto-configuration of Spring Data for Apache Geode/Pivotal GemFire
* Integration Tests testing the auto-configuration of Spring Data for Apache Geode
* Function implementations and executions support.
*
* @author John Blum

4
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/executions/Calculator.java
View File

@@ -13,20 +13,18 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.function.executions;
import org.springframework.data.gemfire.function.annotation.OnMember;
/**
* The {@link Calculator} interface defines Apache Geode/Pivotal GemFire Functions.
* The {@link Calculator} interface defines Apache Geode Functions.
*
* @author John Blum
* @see org.springframework.data.gemfire.function.annotation.OnRegion
* @since 1.0.0
*/
@OnMember(groups = "test")
@SuppressWarnings("all")
// TODO change Function returns type when SDG properly handles Function method return types/values
public interface Calculator {

4
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/logging/LoggingAutoConfigurationIntegrationTests.java
View File

@@ -33,8 +33,8 @@ import org.springframework.geode.util.GeodeConstants;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests asserting the configuration and behavior of Apache Geode & Pivotal GemFire logging
* when configured with Spring Boot auto-configuration.
* Integration Tests asserting the configuration and behavior of Apache Geode logging when configured with
* Spring Boot auto-configuration.
*
* @author John Blum
* @see java.util.Properties

3
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/AutoConfiguredRepositoriesIntegrationTests.java
View File

@@ -38,8 +38,7 @@ import org.springframework.geode.boot.autoconfigure.repository.service.CustomerS
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests testing the auto-configuration of Spring Data Repositories backed by either Apache Geode
* or Pivotal GemFire.
* Integration Tests testing the auto-configuration of Spring Data Repositories backed by Apache Geode.
*
* @author John Blum
* @see org.junit.Test

3
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/repo/CustomerRepository.java
View File

@@ -13,7 +13,6 @@
* or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package org.springframework.geode.boot.autoconfigure.repository.repo;
import org.springframework.data.repository.CrudRepository;
@@ -21,7 +20,7 @@ import org.springframework.geode.boot.autoconfigure.repository.model.Customer;
/**
* The {@link CustomerRepository} interface defines a Spring Data {@link CrudRepository} for performing basic CRUD
* and simple query data access operations on {@link Customer} objects stored in Apache Geode or Pivotal GemFire.
* and simple query data access operations on {@link Customer} objects stored in Apache Geode.
*
* @author John Blum
* @see org.springframework.data.repository.CrudRepository

4
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/cloud/AutoConfiguredCloudSecurityContextIntegrationTests.java
View File

@@ -34,8 +34,8 @@ import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire Security
* authentication/authorization in a cloud, managed context (e.g. Pivotal CloudFoundry)
* Integration Tests testing the auto-configuration of Apache Geode Security authentication/authorization in a cloud,
* managed context (e.g. CloudFoundry).
*
* @author John Blum
* @see java.security.Principal

3
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/hybrid/AutoConfiguredHybridSecurityContextIntegrationTests.java
View File

@@ -42,8 +42,7 @@ import org.springframework.test.context.junit4.SpringRunner;
* Pivotal Cloud Cache (PCC) service instance.
*
* This Use Case is common when users want to deploy their Spring Boot, {@link ClientCache} apps to
* Pivotal CloudFoundry (PCF) however, want to connect those apps to an external Apache Geode or Pivotal GemFire
* cluster.
* Pivotal CloudFoundry (PCF) however, want to connect those apps to an external Apache Geode cluster.
*
* @author John Blum
* @see java.util.Properties

4
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/local/AutoConfiguredLocalSecurityContextIntegrationTests.java
View File

@@ -31,8 +31,8 @@ import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire Security
* authentication/authorization in a local, non-managed context.
* Integration Tests testing the auto-configuration of Apache Geode Security authentication/authorization in a local,
* non-managed context.
*
* @author John Blum
* @see java.security.Principal

2
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/ssl/AutoConfiguredSslIntegrationTests.java
View File

@@ -53,7 +53,7 @@ import example.echo.config.EchoClientConfiguration;
import example.echo.config.EchoServerConfiguration;
/**
* Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire SSL.
* Integration Tests testing the auto-configuration of Apache Geode SSL.
*
* @author John Blum
* @see org.junit.Test

7
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/AutoConfiguredSessionCachingIntegrationTests.java
View File

@@ -42,11 +42,10 @@ import org.springframework.session.data.gemfire.config.annotation.web.http.GemFi
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests for auto-configuration of Spring Session using either Apache Geode or Pivotal GemFire
* as the {@link Session} state management provider.
* Integration Tests for auto-configuration of Spring Session using either Apache Geode as the {@link Session} state
* management provider.
*
* This test asserts that the Spring Boot auto-configuration properly configures Spring Session
* with either Apache Geode or Pivotal GemFire
* This test asserts that the Spring Boot auto-configuration properly configures Spring Session with Apache Geode.
*
* @author John Blum
* @see org.junit.Test

4
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/CustomConfiguredSessionCachingIntegrationTests.java
View File

@@ -51,8 +51,8 @@ import org.springframework.web.context.ConfigurableWebApplicationContext;
import org.springframework.web.context.support.GenericWebApplicationContext;
/**
* Integration Test for the auto-configuration of Spring Session using either Apache Geode or Pivotal GemFire
* as the {@link Session} state management provider.
* Integration Test for the auto-configuration of Spring Session using Apache Geode as the {@link Session} state
* management provider.
*
* This test asserts that the Spring Boot auto-configuration can be customized using either {@link Properties}
* or a {@link SpringSessionGemFireConfigurer}.

2
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredSessionCachingIntegrationTests.java
View File

@@ -41,7 +41,7 @@ import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests for auto-configuration of Spring Session using a custom Spring Session {@link Session} state
* management provider, asserting that neither Apache Geode nor Pivotal GemFire is configured.
* management provider, asserting that Apache Geode is configured.
*
* @author John Blum
* @see org.junit.Test

5
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredWithPropertiesSessionCachingIntegrationTests.java
View File

@@ -35,10 +35,9 @@ import org.springframework.session.data.gemfire.config.annotation.web.http.GemFi
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration Tests asserting the configuration of Spring Session using Spring Boot's
* Integration Tests asserting the configuration of Spring Session using Spring Boot'
* {@literal spring.session.store-type} configuration property set to {@literal none}
* and assert neither Apache Geode nor Pivotal GemFire was configured as the Session
* state management provider.
* and assert Apache Geode was not configured as the Session state management provider.
*
* @author John Blum
* @see org.apache.geode.cache.GemFireCache

5
spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/NoAutoConfigurationOfSessionCachingIntegrationTests.java
View File

@@ -32,9 +32,8 @@ import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.context.WebApplicationContext;
/**
* Integration tests for {@link SpringSessionAutoConfiguration} asserting that Spring Session
* (for Apache Geode/Pivotal GemFire) is not auto-configured when the Spring {@link ApplicationContext}
* is not a {@link WebApplicationContext}.
* Integration tests for {@link SpringSessionAutoConfiguration} asserting that Spring Session (for Apache Geode)
* is not auto-configured when the Spring {@link ApplicationContext} is not a {@link WebApplicationContext}.
*
* @author John Blum
* @see org.junit.Test

2
spring-geode-autoconfigure/src/test/resources/application-gemfire-config-test.properties
View File

@@ -1,4 +1,4 @@
# Spring Boot application.properties containing Spring Data for Apache Geode / Pivotal GemFire properties.
# Spring Boot application.properties containing Spring Data for Apache Geode properties.
spring.data.gemfire.name=GemFirePropertiesIntegrationTests
spring.data.gemfire.locators=localhost[11235],localhost[12480]

2
spring-geode-autoconfigure/src/test/resources/application-security-cloud.properties
View File

@@ -1,4 +1,4 @@
# Spring Boot application.properties for testing Apache Geode/Pivotal GemFire Security in a cloud context.
# Spring Boot application.properties for testing Apache Geode Security in a cloud context.
vcap.application.application_id=c50bb519-2739-4fa3-8750-02c051e35735
vcap.application.application_name=boot-test

2
spring-geode-autoconfigure/src/test/resources/application-security-hybrid.properties
View File

@@ -1,4 +1,4 @@
# Spring Boot application.properties used in server for testing Apache Geode/Pivotal GemFire Security in a hybrid cloud context.
# Spring Boot application.properties used in server for testing Apache Geode Security in a hybrid cloud context.
test.security.context.username=phantom
test.security.context.password=s3cr3t

2
spring-geode-autoconfigure/src/test/resources/application-security-local-client.properties
View File

@@ -1,4 +1,4 @@
# Spring Boot application.properties used in client for testing Apache Geode/Pivotal GemFire Security in a local context.
# Spring Boot application.properties used in client for testing Apache Geode Security in a local context.
spring.data.gemfire.security.username=ghostrider
spring.data.gemfire.security.password=p@55w0rd

2
spring-geode-autoconfigure/src/test/resources/application-security-local-server.properties
View File

@@ -1,4 +1,4 @@
# Spring Boot application.properties used in server for testing Apache Geode/Pivotal GemFire Security in a local context.
# Spring Boot application.properties used in server for testing Apache Geode Security in a local context.
test.security.context.username=ghostrider
test.security.context.password=p@55w0rd

2
spring-geode-autoconfigure/src/test/resources/application-security-multi.properties
View File

@@ -1,4 +1,4 @@
# Spring Boot application.properties used in server for testing Apache Geode/Pivotal GemFire Security in a multi-cloudcache service instance (PCF) context.
# Spring Boot application.properties used in server for testing Apache Geode Security in a multi-cloudcache service instance (PCF) context.
test.security.context.username=master
test.security.context.password=p@55w0rd

2
spring-geode-autoconfigure/src/test/resources/application-session-config-test.properties
View File

@@ -1,4 +1,4 @@
# Spring Session for Apache Geode/Pivotal GemFire (Test) Properties
# Spring Session for Apache Geode (SSDG) Test Properties
spring.session.data.gemfire.cache.client.pool.name=DEAD
spring.session.data.gemfire.cache.client.region.shortcut=LOCAL

2
spring-geode-autoconfigure/src/test/resources/application-ssl.properties
View File

@@ -1,4 +1,4 @@
# Spring Boot application.properties for testing Apache Geode/Pivotal GemFire SSL
# Spring Boot application.properties for testing Apache Geode SSL
spring.boot.data.gemfire.security.ssl.keystore.name=test-trusted.keystore
spring.data.gemfire.security.ssl.keystore.password=s3cr3t

2
spring-geode-docs/spring-geode-docs.gradle
View File

@@ -7,7 +7,7 @@ import org.apache.tools.ant.filters.ReplaceTokens
apply plugin: 'io.spring.convention.docs'
apply plugin: 'io.spring.convention.spring-test'
description = "Generate Javadoc and Reference Documentation on Spring Boot for Apache Geode & Pivotal GemFire"
description = "Generate Javadoc and Reference Documentation on Spring Boot for Apache Geode & VMware Tanzu GemFire"
dependencies {

122
spring-geode-docs/src/docs/asciidoc/_includes/appendix.adoc
View File

@@ -1,8 +1,10 @@
[[appendix]]
== Appendix
:geode-name: {apache-geode-name}
:gemfire-name: {pivotal-gemfire-name}
:cloud-cache-name: {pivotal-cloudcache-name}
The following appendices provide additional help while developing Spring Boot applications backed by Apache Geode
or Pivotal GemFire.
The following appendices provide additional help while developing Spring Boot applications backed by {geode-name}.
_Table of Contents_
@@ -24,9 +26,9 @@ include::configuration-properties.adoc[leveloffset=+1]
[[geode-auto-configuration-disable]]
=== Disabling Auto-configuration
If you would like to disable the _auto-configuration_ of any feature provided by Spring Boot for Apache Geode
or Pivotal GemFire, then you can specify the _auto-configuration_ class in the `exclude` attribute
of the `@SpringBootApplication` annotation, as follows:
If you would like to disable the _auto-configuration_ of any feature provided by Spring Boot for {geode-name},
then you can specify the _auto-configuration_ class in the `exclude` attribute of the `@SpringBootApplication`
annotation, as follows:
.Disable Auto-configuration of PDX
[source,java]
@@ -58,7 +60,7 @@ public class MySpringBootApplication {
[[geode-auto-configuration-disable-classes]]
==== Complete Set of Auto-configuration Classes
The current set of _auto-configuration_ classes in Spring Boot for Apache Geode & Pivotal GemFire (SBDG) include:
The current set of _auto-configuration_ classes in Spring Boot for {geode-name} (SBDG) include:
* `CacheNameAutoConfiguration`
* `CachingProviderAutoConfiguration`
@@ -77,30 +79,31 @@ The current set of _auto-configuration_ classes in Spring Boot for Apache Geode
* `SslAutoConfiguration`
[[geode-gemfire-switch]]
=== Switch from Apache Geode to Pivotal Cloud Cache (a.k.a. Pivotal GemFire)
=== Switch from {geode-name} to {gemfire-name} for VMs (formerly known as Pivotal Cloud Cache)
First, understand that {pivotal-gemfire-website}[Pivotal GemFire] is being succeeded by {pivotal-cloudcache-website}[Pivotal Cloud Cache] (PCC).
Therefore, all references to Pivotal GemFire implies for Pivotal Cloud Cache (PCC) as well.
First, understand that {pivotal-gemfire-website}[Pivotal GemFire] is being succeeded by
{pivotal-cloudcache-website}[Pivotal Cloud Cache] (PCC) or {cloud-cache-name}. Therefore, all references to
Pivotal GemFire implies for Pivotal Cloud Cache (PCC) or {cloud-cache-name} as well.
When it comes to Spring's support, whether you are developing with Open Source Software (OSS) {apache-geode-website}[Apache Geode]
When it comes to Spring's support, whether you are developing with Open Source Software (OSS) {apache-geode-website}[{geode-name}]
or developing for {pivotal-cloudcache-website}[Pivotal Cloud Cache], Spring has you covered.
At a strategic-level, this means:
1. From _Open Source Software_ (e.g. Apache Geode) to _Commercial_ (e.g. Pivotal Cloud Cache)
1. From _Open Source Software_ (e.g. {geode-name}) to _Commercial_ (e.g. Pivotal Cloud Cache)
2. From _Non-Managed Environments_ (e.g. Standalone, Externally Managed) to _Managed Environments_ (e.g. Pivotal Platform)
3. With _**little**_ to _**no code or configuration**_ changes necessary. It just works!
You may also migrate your Spring Boot applications away from Pivotal Platform using the commercial software offering,
Pivotal Cloud Cache, and switch back to Open Source Apache Geode running in a standalone, externally managed environment.
Pivotal Cloud Cache, and switch back to Open Source {geode-name} running in a standalone, externally managed environment.
SBDG will never lock you in! It is, and always will be, your choice!
Technically, this means to go from Apache Geode to Pivotal Cloud Cache (PCC), you must change 2 things.
Technically, this means to go from {geode-name} to Pivotal Cloud Cache (PCC), you must change 2 things.
First, you must switch the dependency from `spring-geode-starter` to `spring-gemfire-starter`:
.Maven POM with Spring Boot for Apache Geode
.Maven POM with Spring Boot for {geode-name}
[source,xml]
[subs="verbatim,attributes"]
----
@@ -111,7 +114,7 @@ First, you must switch the dependency from `spring-geode-starter` to `spring-gem
</dependency>
----
.Gradle build file with Spring Boot for Apache Geode
.Gradle build file with Spring Boot for {geode-name}
[source,groovy]
[subs="verbatim,attributes"]
----
@@ -122,7 +125,7 @@ dependencies {
To:
.Maven POM with Spring Boot for Pivotal GemFire
.Maven POM with Spring Boot for {gemfire-name}
[source,xml]
[subs="verbatim,attributes"]
----
@@ -133,7 +136,7 @@ To:
</dependency>
----
.Gradle build file with Spring Boot for Pivotal GemFire
.Gradle build file with Spring Boot for {gemfire-name}
[source,groovy]
[subs="verbatim,attributes"]
----
@@ -142,10 +145,10 @@ dependencies {
}
----
Second, to obtain the commercial Pivotal Cloud Cache (PCC) or Pivotal GemFire bits, you must declare the appropriate
repository declaration in your Maven POM or Gradle build file:
Second, to obtain the commercial Pivotal Cloud Cache (PCC) or {gemfire-name} bits, you must declare
the appropriate repository declaration in your Maven POM or Gradle build file:
.Maven Repository definition to acquire PCC or Pivotal GemFire bits
.Maven Repository definition to acquire PCC or {gemfire-name} bits
[source,xml]
----
<repositories>
@@ -157,7 +160,7 @@ repository declaration in your Maven POM or Gradle build file:
</repositories>
----
.Gradle Repository definition to acquire PCC or Pivotal GemFire bits
.Gradle Repository definition to acquire PCC or {gemfire-name} bits
[source,groovy]
----
repositories {
@@ -188,9 +191,9 @@ and password to configure access to the server in your Maven settings (i.e. ~/.m
</settings>
----
TIP: For more details on acquiring the Pivotal Cloud Cache (PCC) or Pivotal GemFire bits, see Pivotal GemFire's
TIP: For more details on acquiring the Pivotal Cloud Cache (PCC) or {gemfire-name} bits, see {gemfire-name}'s
https://gemfire.docs.pivotal.io/{pivotal-gemfire-version}/gemfire/getting_started/installation/obtain_gemfire_maven.html[documentation].
When using the `spring-gemfire-starter`, you do not need to declare the Pivotal GemFire dependencies noted in
When using the `spring-gemfire-starter`, you do not need to declare the {gemfire-name} dependencies noted in
the documentation. The `spring-gemfire-starter` does that for you! You only need to declare the repository
and configure your settings.
@@ -200,7 +203,7 @@ Done!
It should just work without any code or configuration changes and if this is not the case, for whatever reason, then we
will work to correct it, short of any feature differences between Pivotal Cloud Cache (PCC) that cannot be accomplished
with Apache Geode itself, of course.
with {geode-name} itself, of course.
Spring Boot's _auto-configuration_ and _convention over configuration_ approach tries to determine the runtime
environment in order to handle infrastructure logistics so you do not have to. This is true inside or outside
@@ -208,29 +211,29 @@ of a managed environment so that we can provide users with a consistent and reli
and issues that arise by switching environments in the first place. Switching environments is especially common as you
migrate your Spring Boot applications from DEV to TEST, followed by STAGING, and finally, to PRODUCTION.
Of course, it will nearly always be easier to "run" Apache Geode as a "managed" service inside Pivotal Platform (PCF)
using Pivotal Cloud Cache (PCC) than it will be to manage an externally run Apache Geode cluster, especially if your
Of course, it will nearly always be easier to "run" {geode-name} as a "managed" service inside Pivotal Platform (PCF)
using Pivotal Cloud Cache (PCC) than it will be to manage an externally run {geode-name} cluster, especially if your
Use Cases require maximum performance and high availability. We highly recommend this approach when and where possible,
but it is still your choice.
[[geode-cluster-configuration-bootstrapping]]
=== Running an Apache Geode or Pivotal GemFire cluster using Spring Boot from your IDE
=== Running an {geode-name} cluster using Spring Boot from your IDE
As described in <<geode-clientcache-applications>>, it is possible to configure and run a small Apache Geode
or Pivotal GemFire cluster from inside your IDE using Spring Boot. This is extremely helpful during development
since it allows you to manually spin up, test and debug your applications quickly and easily.
As described in <<geode-clientcache-applications>>, it is possible to configure and run a small {geode-name} cluster
from inside your IDE using Spring Boot. This is extremely helpful during development since it allows you to manually
spin up, test and debug your applications quickly and easily.
Spring Boot for Apache Geode/Pivotal GemFire includes such a class:
Spring Boot for {geode-name} includes such a class:
.Spring Boot application class used to configure and bootstrap an Apache Geode/Pivotal GemFire server
.Spring Boot application class used to configure and bootstrap an {geode-name} server
[source,java]
----
include::{docs-src-dir}/org/springframework/geode/docs/example/app/server/SpringBootApacheGeodeCacheServerApplication.java[tags=class]
----
This class is a proper Spring Boot application that can be used to configure and bootstrap multiple Apache Geode
or Pivotal GemFire servers and joining them together to form a small cluster simply by modifying
the runtime configuration of this class ever so slightly.
This class is a proper Spring Boot application that can be used to configure and bootstrap multiple {geode-name} servers
and join them together to form a small cluster simply by modifying the runtime configuration of this class ever so
slightly.
Initially you will want to start a single, primary server with the embedded Locator and Manager service.
@@ -241,7 +244,7 @@ route data requests directly to the server hosting the data (a.k.a. single-hop a
is partitioned/sharded across servers in the cluster. Locator Pools include support for load balancing connections
and handling automatic fail-over in the event of failed connections, among other things.
The Manager service enables you to connect to this server using _Gfsh_ (the Apache Geode and Pivotal GemFire
The Manager service enables you to connect to this server using _Gfsh_ (the {geode-name}
{apache-geode-docs}/tools_modules/gfsh/chapter_overview.html[shell tool]).
To start our primary server, create a run configuration in your IDE for the `SpringBootApacheGeodeCacheServerApplication`
@@ -421,9 +424,8 @@ Client Connections : 0
Now, let's start some additional servers to scale-out our cluster.
To do so, you simply need to vary the name of the members we will add to our cluster as peers. Apache Geode
and Pivotal GemFire require that the members in a cluster be named and the names of each member in the cluster
be unique.
To do so, you simply need to vary the name of the members we will add to our cluster as peers. {geode-name} requires
that the members in a cluster be named and the names of each member in the cluster be unique.
Additionally, since we are running multiple instances of our `SpringBootApacheGeodeCacheServerApplication` class,
which also embeds a `CacheServer` instance enabling cache clients to connect, we need to be careful to vary our
@@ -548,47 +550,45 @@ Running : true
Client Connections : 0
----
Congratulations! You just started a small Apache Geode/Pivotal GemFire cluster, with 3 members, using Spring Boot
from inside your IDE.
Congratulations! You just started a small {geode-name} cluster, with 3 members, using Spring Boot from inside your IDE.
It is pretty simple to build and run a Spring Boot, Apache Geode/Pivotal GemFire, `ClientCache` application
that connects to this cluster. Simply include and use Spring Boot for Apache Geode/Pivotal GemFire, ;-).
It is pretty simple to build and run a Spring Boot, {geode-name}, `ClientCache` application that connects to
this cluster. Simply include and use Spring Boot for {geode-name}, ;-).
[[geode-testing]]
=== Testing
https://github.com/spring-projects/spring-test-data-geode[Spring Test for Apache Geode & Pivotal GemFire] is a new,
soon to be released and upcoming project to help developers write both _Unit_ and _Integration Tests_
when using either Apache Geode or Pivotal GemFire in a Spring context.
https://github.com/spring-projects/spring-test-data-geode[Spring Test for {geode-name}] is a new, soon to be released
and upcoming project to help developers write both _Unit_ and _Integration Tests_ when using {geode-name}
in a Spring context.
In fact, the entire {github-url}/tree/master/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure[test suite]
in Spring Boot for Apache Geode & Pivotal GemFire is based on this project.
in Spring Boot for {geode-name} is based on this project.
All Spring projects integrating with either Apache Geode or Pivotal GemFire will use this new test framework for all
their testing needs, making this new test framework for Apache Geode and Pivotal GemFire a proven and reliable solution
for all your Apache Geode/Pivotal GemFire application testing needs when using Spring as well.
All Spring projects integrating with either {geode-name} will use this new test framework for all their testing needs,
making this new test framework for {geode-name} a proven and reliable solution for all your {geode-name} application
testing needs when using Spring as well.
Later on, this reference guide will include and dedicate an entire chapter on testing.
[[geode-examples]]
=== Examples
The definitive source of truth on how to best use Spring Boot for Apache Geode & Pivotal GemFire (or Pivotal Cloud Cache
(PCC)) is to refer to the <<geode-samples,Samples>>.
The definitive source of truth on how to best use Spring Boot for {geode-name} is to refer to the <<geode-samples,Samples>>.
Refer to the Pivotal Cloud Cache (PCC), https://github.com/pivotal-cf/PCC-Sample-App-PizzaStore[Pizza Store],
Spring Boot application for an example of how to use Spring Boot for Pivotal GemFire (SBDG) in a `ClientCache`
Spring Boot application for an example of how to use Spring Boot for {gemfire-name} (SBDG) in a `ClientCache`
application interfacing with PCC.
Additionally, you may refer to the https://github.com/jxblum/temperature-service[Temperature Service], Spring Boot
application, which implements a Temperature Sensor and Monitoring, Internet of Things (IOT) example. The example uses
SBDG to showcase Apache Geode CQ, Function Implementations/Executions and positions Apache Geode as a _caching provider_
SBDG to showcase {geode-name} CQ, Function Implementations/Executions and positions {geode-name} as a _caching provider_
in Spring's Cache Abstraction. It is a working, sophisticated and complete example, and is highly recommended
as a good starting point for real-world use cases.
You may also refer to the https://github.com/jxblum/contacts-application/tree/master/boot-example[boot-example]
from the _Contact Application_ Reference Implementation (RI) for Spring Data for Apache Geode & Pivotal GemFire
(SDG) as yet another example.
from the _Contact Application_ Reference Implementation (RI) for Spring Data for {geode-name} (SDG)
as yet another example.
[[references]]
=== References
@@ -596,8 +596,8 @@ from the _Contact Application_ Reference Implementation (RI) for Spring Data for
1. Spring Framework {spring-framework-docs}[Reference Guide] | {spring-framework-javadoc}[Javadoc]
2. Spring Boot {spring-boot-docs-html}[Reference Guide] | {spring-boot-javadoc}[Javadoc]
3. Spring Data Commons {spring-data-commons-docs-html}[Reference Guide] | {spring-data-commons-javadoc}[Javadoc]
4. Spring Data for Apache Geode {spring-data-geode-docs-html}[Reference Guide] | {spring-data-geode-javadoc}[Javadoc]
5. Spring Session for Apache Geode {spring-session-data-gemfire-docs}[Reference Guide] | {spring-session-data-gemfire-javadoc}[Javadoc]
6. Spring Test for Apache Geode {spring-test-data-gemfire-website}[README]
7. Apache Geode {apache-geode-docs}[User Guide] | {apache-geode-javadoc}[Javadoc]
8. Pivotal GemFire {pivotal-gemfire-docs}[User Guide] | {pivotal-gemfire-javadoc}[Javadoc]
4. Spring Data for {geode-name} {spring-data-geode-docs-html}[Reference Guide] | {spring-data-geode-javadoc}[Javadoc]
5. Spring Session for {geode-name} {spring-session-data-gemfire-docs}[Reference Guide] | {spring-session-data-gemfire-javadoc}[Javadoc]
6. Spring Test for {geode-name} {spring-test-data-gemfire-website}[README]
7. {geode-name} {apache-geode-docs}[User Guide] | {apache-geode-javadoc}[Javadoc]
8. {gemfire-name} {pivotal-gemfire-docs}[User Guide] | {pivotal-gemfire-javadoc}[Javadoc]

86
spring-geode-docs/src/docs/asciidoc/_includes/clientcache-applications.adoc
View File

@@ -1,17 +1,17 @@
[[geode-clientcache-applications]]
== Building ClientCache Applications
The first, opinionated option provided to you by Spring Boot for Apache Geode & Pivotal GemFire (SBDG) out-of-the-box is
a {apache-geode-javadoc}/org/apache/geode/cache/client/ClientCache.html[ClientCache] instance, simply by declaring
either Spring Boot for Apache Geode or Spring Boot for Pivotal GemFire on your application classpath.
The first, opinionated option provided to you by Spring Boot for Apache Geode (SBDG) out-of-the-box is a
{apache-geode-javadoc}/org/apache/geode/cache/client/ClientCache.html[ClientCache] instance, simply by declaring
Spring Boot for Apache Geode (SBDG) on your application classpath.
It is assumed that most application developers using Spring Boot to build applications backed by either Apache Geode
or Pivotal GemFire will be building cache client applications deployed in an Apache Geode or Pivotal GemFire
It is assumed that most application developers using Spring Boot to build applications backed by Apache Geode will be
building cache client applications deployed in an Apache Geode
{apache-geode-docs}/topologies_and_comm/cs_configuration/chapter_overview.html[Client/Server topology].
A client/server topology is the most common and traditional architecture employed by enterprise applications.
For example, you can begin building a Spring Boot, Apache Geode or Pivotal GemFire, `ClientCache` application
with either the `spring-geode-starter` or `spring-gemfire-starter` on your application's classpath:
For example, you can begin building a Spring Boot, Apache Geode `ClientCache` application with either
the `spring-geode-starter` or `spring-gemfire-starter` on your application's classpath:
.Spring Boot for Apache Geode on the application classpath
[source,xml]
@@ -37,12 +37,12 @@ public class SpringBootApacheGeodeClientCacheApplication {
}
----
Your application now has a `ClientCache` instance, which is able to connect to an Apache Geode or Pivotal GemFire server
running on `localhost`, listening on the default `CacheServer` port, `40404`.
Your application now has a `ClientCache` instance, which is able to connect to an Apache Geode server running on
`localhost`, listening on the default `CacheServer` port, `40404`.
By default, an Apache Geode or Pivotal GemFire server (i.e. `CacheServer`) must be running in order to use
the `ClientCache` instance. However, it is perfectly valid to create a `ClientCache` instance and perform
data access operations using `LOCAL` Regions. This is very useful during development.
By default, an Apache Geode server (i.e. `CacheServer`) must be running in order to use the `ClientCache` instance.
However, it is perfectly valid to create a `ClientCache` instance and perform data access operations using `LOCAL`
Regions. This is very useful during development.
TIP: To develop with `LOCAL` Regions, you only need to define your cache Regions with the
{apache-geode-javadoc}/org/apache/geode/cache/client/ClientRegionShortcut.html#LOCAL[`ClientRegionShortcut.LOCAL`]
@@ -53,7 +53,7 @@ environment, you simply change the data management policy of the client Region f
or even a `CACHING_PROXY`, data management policy which will cause the data to be sent/received to and from 1 or more
servers, respectively.
TIP: Compare and contrast the above configuration with Spring Data for Apache Geode/Pivotal GemFire's
TIP: Compare and contrast the above configuration with Spring Data for Apache Geode's
{spring-data-geode-docs-html}/#bootstrap-annotation-config-geode-applications[approach].
It is uncommon to ever need a direct reference to the `ClientCache` instance provided by SBDG injected into your
@@ -103,12 +103,12 @@ It is the 2nd part, "_get out of the way quickly as requirements start to diverg
that we refer to here.
If your application requirements demand you use Spring Boot to configure and bootstrap an embedded, peer `Cache`
Apache Geode or Pivotal GemFire application, then simply declare your intention with either SDG's
Apache Geode application, then simply declare your intention with either SDG's
{spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/PeerCacheApplication.html[`@PeerCacheApplication`] annotation,
or alternatively, if you need to enable connections from `ClientCache` apps as well, use the SDG
{spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/CacheServerApplication.html[`@CacheServerApplication`] annotation:
.Spring Boot, Apache Geode/Pivotal GemFire CacheServer Application
.Spring Boot, Apache Geode CacheServer Application
[source,java]
----
@SpringBootApplication
@@ -121,8 +121,8 @@ public class SpringBootApacheGeodeCacheServerApplication {
}
----
TIP: An Apache Geode/Pivotal GemFire "server" is not necessarily a "`CacheServer`" capable of serving cache clients.
It is merely a peer member node in a GemFire/Geode cluster (a.k.a. distributed system) that stores and manages data.
TIP: An Apache Geode "server" is not necessarily a "`CacheServer`" capable of serving cache clients. It is merely a
peer member node in a GemFire/Geode cluster (a.k.a. distributed system) that stores and manages data.
By explicitly declaring the `@CacheServerApplication` annotation, you are telling Spring Boot that you do not want
the default, `ClientCache` instance, but rather an embedded, peer `Cache` instance with a `CacheServer` component,
@@ -133,7 +133,7 @@ to "locate" servers in a cluster, as well as an embedded _Manager_, which allows
to be managed and monitored using {apache-geode-docs}/tools_modules/gfsh/chapter_overview.html[_Gfsh_], GemFire/Geode's
shell tool:
.Spring Boot, Apache Geode/Pivotal GemFire CacheServer Application with _Locator_ and _Manager_ services enabled
.Spring Boot, Apache Geode `CacheServer` Application with _Locator_ and _Manager_ services enabled
[source,java]
----
@SpringBootApplication
@@ -197,9 +197,9 @@ Client Connections : 0
----
You can even start additional servers in _Gfsh_, which will connect to your Spring Boot configured and bootstrapped
Apache Geode or Pivotal GemFire `CacheServer` application. These additional servers started in _Gfsh_ know about
the Spring Boot, GemFire/Geode server because of the embedded _Locator_ service, which is running on `localhost`,
listening on the default _Locator_ port, `10334`:
Apache Geode `CacheServer` application. These additional servers started in _Gfsh_ know about the Spring Boot,
Apache Geode server because of the embedded _Locator_ service, which is running on `localhost`, listening on
the default _Locator_ port, `10334`:
[source,text]
----
@@ -268,7 +268,7 @@ GfshServer | 10.0.0.121(GfshServer:30270)<v1>:1025
Then, modify the `SpringBootApacheGeodeCacheServerApplication` class to connect to the existing cluster, like so:
.Spring Boot, Apache Geode/Pivotal GemFire CacheServer Application with _Locator_ and _Manager_ services enabled
.Spring Boot, Apache Geode `CacheServer` Application with _Locator_ and _Manager_ services enabled
[source,java]
----
@SpringBootApplication
@@ -317,8 +317,8 @@ Running : true
Client Connections : 0
----
In both scenarios, the Spring Boot configured and bootstrapped Apache Geode (or Pivotal GemFire) server
and the _Gfsh_ _Locator_ and _Server_ formed a cluster.
In both scenarios, the Spring Boot configured and bootstrapped Apache Geode server and the _Gfsh_ _Locator_ and _Server_
formed a cluster.
While you can use either approach and Spring does not care, it is far more convenient to use Spring Boot and your IDE
to form a small cluster while developing. By leveraging Spring profiles, it is far simpler and much faster to
@@ -342,10 +342,10 @@ TIP: See the Appendix, <<geode-cluster-configuration-bootstrapping>> for more de
In addition to `ClientCache`, `CacheServer` and peer `Cache` applications, SDG, and by extension SBDG, now supports
Locator-based, Spring Boot applications.
An Apache Geode or Pivotal GemFire Locator is a location-based service, or alternatively and more typically,
a standalone process enabling clients to "locate" a cluster of Apache Geode/Pivotal GemFire servers to manage data.
Many cache clients can connect to the same cluster in order to share data. Running multiple clients is common in a
Microservices architecture where you need to scale-up the number of app instances to satisfy the demand.
An Apache Geode Locator is a location-based service, or alternatively and more typically, a standalone process enabling
clients to "locate" a cluster of Apache Geode servers to manage data. Many cache clients can connect to the same cluster
in order to share data. Running multiple clients is common in a Microservices architecture where you need to scale-up
the number of app instances to satisfy the demand.
A Locator is also used by joining members of an existing cluster to scale-out and increase capacity of the logically
pooled system resources (i.e. Memory, CPU and Disk). A Locator maintains metadata that is sent to the clients to
@@ -398,8 +398,8 @@ class SpringBootApacheGeodeLocatorApplication {
Instead of using the `@EnableLocator` annotation, you now use the `@LocatorApplication` annotation.
The `@LocatorApplication` annotation works in the same way as the `@PeerCacheApplication` and `@CacheServerApplication`
annotations, bootstrapping a Apache Geode or Pivotal GemFire process, overriding the default `ClientCache` instance
provided by SBDG out-of-the-box.
annotations, bootstrapping a Apache Geode process, overriding the default `ClientCache` instance provided by SBDG
out-of-the-box.
NOTE: If your `@SpringBootApplication` class is annotated with `@LocatorApplication`, then it can only be a `Locator`
and not a `ClientCache`, `CacheServer` or peer `Cache` application. If you need the application to function as a
@@ -420,14 +420,14 @@ include::{docs-src-dir}/org/springframework/geode/docs/example/app/locator/Sprin
We also need to vary the configuration for each Locator app instance.
Apache Geode and Pivotal GemFire requires each peer member in the cluster to be uniquely named. We can set the name
of the Locator by using the `spring.data.gemfire.locator.name` SDG property set as a JVM System Property in your IDE's
Run Configuration Profile for the application main class like so: `-Dspring.data.gemfire.locator.name=SpringLocatorOne`.
We name the second Locator app instance, "_SpringLocatorTwo_".
Apache Geode requires each peer member in the cluster to be uniquely named. We can set the name of the Locator by using
the `spring.data.gemfire.locator.name` SDG property set as a JVM System Property in your IDE's Run Configuration Profile
for the application main class like so: `-Dspring.data.gemfire.locator.name=SpringLocatorOne`. We name the second
Locator app instance, "_SpringLocatorTwo_".
Additionally, we must vary the port numbers that the Locators use to listen for connections. By default,
an Apache Geode or Pivotal GemFire Locator listens on port `10334`. We can set the Locator port using the
`spring.data.gemfire.locator.port` SDG property.
an Apache Geode Locator listens on port `10334`. We can set the Locator port using
the `spring.data.gemfire.locator.port` SDG property.
For our first Locator app instance (i.e. "_SpringLocatorOne_"), we also enable the "_manager_" Profile so that
we can connect to the Locator using _Gfsh_.
@@ -616,17 +616,17 @@ GfshServer | 10.99.199.24(GfshServer:30295)<v4>:41004
----
You must be careful to vary the ports and name your peer members appropriately. With Spring, and Spring Boot
for Apache Geode and Pivotal GemFire (SBDG) in particular, it really is that easy!
for Apache Geode (SBDG) in particular, it really is that easy!
[[geode-manager-applications]]
=== Building Manager Applications
As discussed in the previous sections above, it is possible to enable a Spring Boot configured and bootstrapped
Apache Geode or Pivotal GemFire peer member node in the cluster to function as a _Manager_.
Apache Geode peer member node in the cluster to function as a _Manager_.
An Apache Geode or Pivotal GemFire _Manager_ is a peer member node in the cluster running the Management Service,
allowing the cluster to be managed and monitored using JMX based tools, like _Gfsh_, _JConsole_ or _JVisualVM_,
for instance. Any tool that uses the JMX API can connect to and manage the GemFire/Geode cluster for whatever purpose.
An Apache Geode _Manager_ is a peer member node in the cluster running the Management Service, allowing the cluster
to be managed and monitored using JMX based tools, like _Gfsh_, _JConsole_ or _JVisualVM_, for instance. Any tool
that uses the JMX API can connect to and manage the GemFire/Geode cluster for whatever purpose.
The cluster may have more than 1 _Manager_ for redundancy. Only server-side, peer member nodes in the cluster
may function as a _Manager_. Therefore, a `ClientCache` application cannot be a _Manager_.
@@ -683,8 +683,8 @@ TIP: See the `@EnableManager` annotation
for additional configuration options.
As of Apache Geode 1.11.0, you must now include additional Geode dependencies on your Spring Boot application classpath
to make your application a proper Apache Geode/Pivotal GemFire _Manager_ in the cluster, particularly if you are also
enabling the embedded HTTP service in the _Manager_.
to make your application a proper Apache Geode _Manager_ in the cluster, particularly if you are also enabling
the embedded HTTP service in the _Manager_.
The required dependencies are:

41
spring-geode-docs/src/docs/asciidoc/_includes/cloudfoundry.adoc
View File

@@ -6,7 +6,7 @@ In most cases, when you "_push_" (i.e. "_deploy_") your Spring Boot applications
you will bind your app to 1 or more instances of the Pivotal Cloud Cache (PCC) service.
In a nutshell, {pivotal-cloudcache-website}[Pivotal Cloud Cache] is a managed version of
{pivotal-gemfire-website}[Pivotal GemFire] running in {pivotal-cloudfoundry-website}[Pivotal CloudFoundry].
{pivotal-gemfire-website}[VMware Tanzu GemFire] running in {pivotal-cloudfoundry-website}[Pivotal CloudFoundry].
When running in or across cloud environments (e.g. AWS, Azure, GCP or PWS), PCC with PCF offers several advantages
over trying to run and manage your own standalone Apache Geode or Pivotal GemFir clusters. It handles many of
the infrastructure-related, operational concerns so you do not have to.
@@ -34,12 +34,12 @@ the `@EnableClusterConfiguration` annotation:
----
@SpringBootApplication
@EnableClusterConfiguration(useHttp = true)
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
With `@EnableClusterConfiguration`, Region and OQL Index configuration metadata defined on the client can be sent to
servers in the PCC cluster. Apache Geode and Pivotal GemFire requires matching Regions by name on both the client
and servers in order for clients to send and receive data to and from the cluster.
servers in the PCC cluster. Apache Geode requires matching Regions by name on both the client and servers in order for
clients to send and receive data to and from the cluster.
For example, when you declare the Region where an application entity will be persisted using the `@Region` mapping
annotation and additionally declare the `@EnableEntityDefinedRegions` annotation on the main `@SpringBootApplication`
@@ -82,7 +82,6 @@ Configuration metadata for the PCC service instance might appear as follows:
"password": "*****",
"roles": [ "developer" ],
"username": "developer_user"
},
}, {
"password": "*****",
"roles": [ "read-only-user" ],
@@ -97,7 +96,6 @@ Configuration metadata for the PCC service instance might appear as follows:
}
}
},
...
"name": "jblum-pcc",
"plan": "small",
"tags": [ "gemfire", "cloudcache", "database", "pivotal" ]
@@ -122,9 +120,9 @@ TIP: The `spring.data.gemfire.security.username` property corresponds directly t
See the {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableSecurity.html#securityUsername--[Javadoc]
for more details.
The `spring.data.gemfire.security.username` property is the same property used by Spring Data for Apache Geode
and Pivotal GemFire (SDG) to configure the runtime user of your Spring Data application when connecting to either
an externally managed Apache Geode or Pivotal GemFire cluster.
The `spring.data.gemfire.security.username` property is the same property used by Spring Data for Apache Geode (SDG)
to configure the runtime user of your Spring Data application when connecting to either an externally managed
Apache Geode cluster.
In this case, SBDG simply uses the configured username to lookup the authentication credentials of the user to set
the username and password used by the Spring Boot, `ClientCache` app when connecting to PCC while running in PCF.
@@ -164,9 +162,9 @@ will not be extracted from the environment.
It is possible to provision multiple instances of the Pivotal Cloud Cache service in your Pivotal CloudFoundry
environment. You can then bind multiple PCC service instances to your Spring Boot app.
However, Spring Boot for Apache Geode & Pivotal GemFire (SBDG) will only auto-configure 1 PCC service instance for your
Spring Boot application. This does not mean it is not possible to use multiple PCC service instances with your
Spring Boot app, just that SBDG only "_auto-configures_" 1 service instance for you.
However, Spring Boot for Apache Geode (SBDG) will only auto-configure 1 PCC service instance for your Spring Boot
application. This does not mean it is not possible to use multiple PCC service instances with your Spring Boot app,
just that SBDG only "_auto-configures_" 1 service instance for you.
You must select which PCC service instance your Spring Boot app will auto-configure for you automatically when you have
multiple instances and want to target a specific PCC service instance to use.
@@ -211,7 +209,7 @@ The configuration would be similar to the following:
@EnablePool(name = "PccN")
})
class PccConfiguration {
...
// ...
}
----
@@ -267,11 +265,10 @@ as discussed <<cloudfoundry-cloudcache-multiinstance-using,above>>.
=== Hybrid Pivotal CloudFoundry & Apache Geode Spring Boot Applications
Sometimes, it is desirable to deploy (i.e. "_push_") and run your Spring Boot applications in Pivotal CloudFoundry,
but still connect your Spring Boot applications to an externally managed, standalone Apache Geode or Pivotal GemFire
cluster.
but still connect your Spring Boot applications to an externally managed, standalone Apache Geode cluster.
Spring Boot for Apache Geode & Pivotal GemFire (SBDG) makes this a non-event and honors its "_little to no code
or configuration changes necessary_" goal, regardless of your runtime choice, "_it should just work!_"
Spring Boot for Apache Geode (SBDG) makes this a non-event and honors its "_little to no code or configuration changes
necessary_" goal, regardless of your runtime choice, "_it should just work!_"
To help guide you through this process, we will cover the following topics:
@@ -294,7 +291,7 @@ can be bound and used by your Spring Boot application to accomplish its tasks.
However, PCF Dev lacks the Pivotal Cloud Cache (PCC) service that is available in PCF. This is actually ideal for
this little exercise since we are trying to build and run Spring Boot applications in a PCF environment
but connect to an externally managed, standalone Apache Geode or Pivotal GemFire cluster.
but connect to an externally managed, standalone Apache Geode cluster.
As a prerequisite, you will need to follow the steps outlined in the
https://pivotal.io/platform/pcf-tutorials/getting-started-with-pivotal-cloud-foundry-dev/introduction[tutorial]
@@ -486,8 +483,8 @@ Now that we have PCF Dev and a small Apache Geode cluster up and running, it is
to the external, standalone Apache Geode cluster that we started in <<cloudfoundry-geode-cluster,step 2>>.
As mentioned, PCF Dev offers the MySQL, Redis and RabbitMQ services out-of-the-box. However, to use Apache Geode
(or Pivotal GemFire) in the same capacity as you would Pivotal Cloud Cache when running in a production-grade,
PCF environment, you need to create a User-Provided Service for the standalone Apache Geode cluster.
in the same capacity as you would Pivotal Cloud Cache when running in a production-grade, PCF environment, you need
to create a User-Provided Service for the standalone Apache Geode cluster.
To do so, execute the following `cf` CLI command:
@@ -757,8 +754,8 @@ Rows : 1
There you have it!
The ability to deploy Spring Boot, Apache Geode or Pivotal GemFire `ClientCache` applications to Pivotal CloudFoundry,
yet connect your app to a externally managed, standalone Apache Geode or Pivotal GemFire cluster.
The ability to deploy Spring Boot, Apache Geode `ClientCache` applications to Pivotal CloudFoundry, yet connect your app
to a externally managed, standalone Apache Geode cluster.
Indeed, this is will be a useful arrangement and stepping stone for many users as they begin their journey towards
a Cloud-Native platform like Pivotal CloudFoundry (PCF) and using services like Pivotal Cloud Cache (PCC).

31
spring-geode-docs/src/docs/asciidoc/_includes/configuration-annotations.adoc
View File

@@ -1,31 +1,30 @@
[[geode-auto-configuration-annotations]]
== Auto-configuration vs. Annotation-based configuration
The question most often asked is, "_What Spring Data for Apache Geode/Pivotal GemFire annotations can I use,
or must I use, when developing Apache Geode or Pivotal GemFire applications with Spring Boot?_"
The question most often asked is, "_What Spring Data for Apache Geode annotations can I use, or must I use,
when developing Apache Geode applications with Spring Boot?_"
This section will answer this question and more.
Readers should refer to the complimentary sample, link:guides/boot-configuration.html[Spring Boot Auto-configuration for Apache Geode & Pivotal GemFire],
which showcases the _auto-configuration_ provided by Spring Boot for Apache Geode/Pivotal GemFire in action.
Readers should refer to the complimentary sample, link:guides/boot-configuration.html[Spring Boot Auto-configuration for Apache Geode],
which showcases the _auto-configuration_ provided by Spring Boot for Apache Geode in action.
[[geode-autoconfiguration-annotations-background]]
=== Background
To help answer this question, we must start by reviewing the complete collection of available
Spring Data for Apache Geode/Pivotal GemFire (SDG) annotations. These annotations are provided in the
Spring Data for Apache Geode (SDG) annotations. These annotations are provided in the
{spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/package-summary.html[org.springframework.data.gemfire.config.annotation]
package. Most of the pertinent annotations begin with `@Enable...`, except for the base annotations:
`@ClientCacheApplication`, `@PeerCacheApplication` and `@CacheServerApplication`.
By extension, Spring Boot for Apache Geode/Pivotal GemFire (SBDG) builds on SDG's Annotation-based configuration model
to implement _auto-configuration_ and apply Spring Boot's core concepts, like "_convention over configuration_",
enabling GemFire/Geode applications to be built with Spring Boot reliably, quickly and easily.
By extension, Spring Boot for Apache Geode (SBDG) builds on SDG's Annotation-based configuration model to implement
_auto-configuration_ and apply Spring Boot's core concepts, like "_convention over configuration_", enabling Apache
Geode applications to be built with Spring Boot reliably, quickly and easily.
SDG provides this Annotation-based configuration model to, first and foremost, give application developers "_choice_"
when building Spring applications using either Apache Geode or Pivotal GemFire. SDG makes no assumptions about what
application developers are trying to do and fails fast anytime the configuration is ambiguous, giving users immediate
feedback.
when building Spring applications using Apache Geode. SDG makes no assumptions about what application developers are
trying to do and fails fast anytime the configuration is ambiguous, giving users immediate feedback.
Second, SDG's Annotations were meant to get application developers up and running quickly and reliably with ease. SDG
accomplishes this by applying sensible defaults so application developers do not need to know, or even have to learn,
@@ -84,8 +83,8 @@ By default, SBDG provides you with a `ClientCache` instance. Technically, SBDG
an auto-configuration class with `@ClientCacheApplication`, internally.
It is by convention that we assume most application developers' will be developing Spring Boot applications
using Apache Geode or Pivotal GemFire as "client" applications in GemFire/Geode's client/server topology. This is
especially true as users migrate their applications to a managed environment, such as Pivotal CloudFoundry (PCF)
using Apache Geode as "client" applications in GemFire/Geode's client/server topology. This is especially true
as users migrate their applications to a managed environment, such as Pivotal CloudFoundry (PCF)
using Pivotal Cloud Cache (PCC).
Still, users are free to "override" the default settings and declare their Spring applications to be actual peer `Cache`
@@ -97,7 +96,7 @@ For example:
----
@SpringBootApplication
@CacheServerApplication
class MySpringBootPeerCacheServerApplication { ... }
class MySpringBootPeerCacheServerApplication { }
----
By declaring the `@CacheServerApplication` annotation, you effectively override the SBDG default. Therefore, SBDG
@@ -220,7 +219,7 @@ You can do that by defining each Region explicitly, or more conveniently, you ca
----
@SpringBootApplication
@EnableCachingDefinedRegions
class Application { ... }
class Application { }
----
`@EnableCachingDefinedRegions` is optional, provided for convenience, and complimentary to caching when used
@@ -275,7 +274,7 @@ class GemFireFunctions {
@GemfireFunction
Object exampleFunction(Object arg) {
...
// ...
}
}
----

88
spring-geode-docs/src/docs/asciidoc/_includes/configuration-declarative.adoc
View File

@@ -36,11 +36,11 @@ Now, that we explained the motivation behind this chapter, let's outline what we
* Refer you to the SDG _Annotations_ covered by SBDG's _Auto-configuration_
* List all SDG _Annotations_ not covered by SBDG's _Auto-configuration_
* Cover the SBDG, SSDG and SDG _Annotations_ that must be declared explicitly and that provide the most value and productivity
when getting started using either Apache Geode or Pivotal GemFire in Spring [Boot] applications.
when getting started using Apache Geode in Spring [Boot] applications.
NOTE: SDG refers to {spring-data-geode-website}[Spring Data for Apache Geode & Pivotal GemFire]. SSDG refers to
{spring-session-data-gemfire-website}[Spring Session for Apache Geode & Pivotal GemFire] and SBDG refers to
_Spring Boot for Apache Geode & Pivotal GemFire_, this project.
NOTE: SDG refers to {spring-data-geode-website}[Spring Data for Apache Geode]. SSDG refers to
{spring-session-data-gemfire-website}[Spring Session for Apache Geode] and SBDG refers to
_Spring Boot for Apache Geode_, this project.
TIP: The list of SDG _Annotations_ covered by SBDG's _Auto-configuration_ is discussed in detail in the <<appendix, Appendix>>,
in the section, <<geode-auto-configuration-annotations,Auto-configuration vs. Annotation-based configuration>>.
@@ -134,7 +134,7 @@ Still, all of these _Annotations_ are available for the application developer to
=== Productivity Annotations
This section calls out the _Annotations_ we believe to be most beneficial for your application development purposes
when using either Apache Geode or Pivotal GemFire in Spring Boot applications.
when using Apache Geode in Spring Boot applications.
[[geode-configuration-declarative-annotations-productivity-enableclusteraware]]
==== `@EnableClusterAware` (SBDG)
@@ -148,14 +148,14 @@ When you annotate your main `@SpringBootApplication` class with `@EnableClusterA
----
@SpringBootApplication
@EnableClusterAware
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
Your Spring Boot, Apache Geode `ClientCache` application is able to seamlessly switch between client/server
and local-only topologies with no code or configuration changes.
When a cluster of Apache Geode or Pivotal GemFire servers is detected, the client application will send and receive data
to and from the cluster. If a cluster is not available, then the client automatically switches to storing data locally
When a cluster of Apache Geode servers is detected, the client application will send and receive data to and from
the cluster. If a cluster is not available, then the client automatically switches to storing data locally
on the client using `LOCAL` Regions.
Additionally, the `@EnableClusterAware` annotation is meta-annotated with SDG's
@@ -228,9 +228,9 @@ For example, given:
@Service
class CustomerService {
@Cacheable("CustomersByAccountNumber" key="#account.number")
@Cacheable(cacheName = "CustomersByAccountNumber", key="#account.number")
Customer findBy(Account account) {
...
// ...
}
}
----
@@ -242,7 +242,7 @@ When your main `@SpringBootApplication` class is annotated with `@EnableCachingD
----
@SpringBootApplication
@EnableCachingDefineRegions
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
Then, SBDG would create a client `PROXY` Region (or `PARTITION_REGION` if your application were a peer member of the
@@ -276,7 +276,6 @@ class Customer {
@Indexed
private String name;
...
}
----
@@ -290,7 +289,7 @@ the main `@SpringBootApplication` class is annotated with `@EnableEntityDefinedR
@SpringBootApplication
@EnableEntityDefinedRegions(basePackageClasses = Customer.class,
clientRegionShortcut = ClientRegionShortcut.CACHING_PROXY)
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
Like the `@EnableCachingDefinedRegions` annotation, you can set the client and server Region data management policy
@@ -339,7 +338,7 @@ Then, you could configure the `@EnableEntityDefinedRegions` as follows:
----
@SpringBootApplication
@EnableEntityDefinedRegions(basePackageClasses = { NonEntity.class, Account.class } )
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
If `Customer`, `Address`, `PhoneNumber` and `Account` were all entity classes properly annotated with `@Region`, then
@@ -365,7 +364,7 @@ This is as simple as annotating your main `@SpringBootApplication` class with `@
----
@SpringBootApplication
@EnableClusterDefinedRegions
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
Every Region that exists on the cluster of servers will have a corresponding `PROXY` Region defined and created on the
@@ -389,8 +388,9 @@ class SomeApplicationComponent {
this.serverRegion.put(1, entity);
...
// ...
}
}
----
Of course, SBDG _auto-configures_ a `GemfireTemplate` for the "_ServerRegion_" Region (as described <<geode-configuration-declarative-auto-configuration-regiontemplates,here>>),
@@ -413,8 +413,9 @@ class SomeApplicationComponent {
this.serverRegionTemplate.put(1, entity);
...
// ...
}
}
----
TIP: Refer to the SDG Reference Guide on {spring-data-geode-docs-html}/#bootstrap-annotation-config-region-cluster-defined[Configuring Cluster-defined Regions]
@@ -449,7 +450,6 @@ class Customer {
@Indexed
private String name;
...
}
----
@@ -461,14 +461,14 @@ As a result, when our main `@SpringBootApplication` class is annotated with `@En
@SpringBootApplication
@EnableEntityDefinedRegions(basePackageClasses = Customer.class)
@EnableIndexing
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
An Apache Geode OQL Index for the `Customer.name` field will be created thereby making OQL Queries on Customers by name
use this Index.
NOTE: Keep in mind that OQL Indexes are not persistent between restarts (i.e. Apache Geode & Pivotal GemFire
maintains Indexes in-memory only). An OQL Index is always rebuilt when the node is restarted.
NOTE: Keep in mind that OQL Indexes are not persistent between restarts (i.e. Apache Geode maintains Indexes
in-memory only). An OQL Index is always rebuilt when the node is restarted.
When you combine `@EnableIndexing` with either `@EnableClusterConfiguration` or `@EnableClusterAware`, then the Index
definitions will be pushed to the server-side Regions where OQL Queries are generally executed.
@@ -479,10 +479,10 @@ for more details.
[[geode-configuration-declarative-annotations-productivity-enableexpiration]]
==== `@EnableExpiration` (SDG)
It is often useful to define both _Eviction_ and _Expiration_ policies, particularly with a system like Apache Geode
or Pivotal GemFire, especially given it primarily keeps data in-memory, on the JVM Heap. As you can imagine your data
volume size may far exceed the amount of available JVM Heap memory and/or keeping too much data on the JVM Heap
can cause Garbage Collection (GC) issues.
It is often useful to define both _Eviction_ and _Expiration_ policies, particularly with a system like Apache Geode,
especially given it primarily keeps data in-memory, on the JVM Heap. As you can imagine your data volume size may far
exceed the amount of available JVM Heap memory and/or keeping too much data on the JVM Heap can cause Garbage Collection
(GC) issues.
TIP: You can enable off-heap (or main memory usage) capabilities by declaring SDG's `@EnableOffHeap` annotation.
Refer to the SDG Reference Guide on {spring-data-geode-docs-html}/#bootstrap-annotation-config-region-off-heap[Configuring Off-Heap Memory]
@@ -521,7 +521,6 @@ class Customer {
@Indexed
private String name;
...
}
----
@@ -535,7 +534,7 @@ with `@EnableExpiration`:
----
@SpringBootApplication
@EnableExpiration
class SpringBootApacheGeodeApplication { ... }
class SpringBootApacheGeodeApplication { }
----
NOTE: Technically, this entity class specific Annotation-based Expiration policy is implemented using Apache Geode's
@@ -551,23 +550,22 @@ TIP: Refer to the SDG Reference Guide for more details on
_Software Testing_ in general, and _Unit Testing_ in particular, are a very important development tasks to ensure
the quality of your Spring Boot applications.
Apache Geode and Pivotal GemFire can make testing difficult in some cases, especially when tests have to be written as
_Integration Tests_ in order to assert the correct behavior. This can be very costly and lengthens the feedback cycle.
Fortunately, it is possible to write _Unit Tests_ as well!
Apache Geode can make testing difficult in some cases, especially when tests have to be written as _Integration Tests_
in order to assert the correct behavior. This can be very costly and lengthens the feedback cycle. Fortunately, it is
possible to write _Unit Tests_ as well!
Spring has your back and once again provides a framework for testing Spring Boot applications using either Apache Geode
or Pivotal GemFire. This is where the {spring-test-data-gemfire-website}[Spring Test for Apache Geode & Pivotal GemFire (STDG)] project
can help, particularly with _Unit Testing_.
Spring has your back and once again provides a framework for testing Spring Boot applications using either Apache Geode.
This is where the {spring-test-data-gemfire-website}[Spring Test for Apache Geode(STDG)] project can help, particularly
with _Unit Testing_.
For example, if you do not care what Apache Geode or Pivotal GemFire would actually do in certain cases and only care
about the "contract", which is what mocking a collaborator is all about, then you could effectively mock Apache Geode
or Pivotal GemFire's objects in order to isolate the "_Subject Under Test_" (SUT) and focus on the interaction(s)
or outcomes you expect to happen.
For example, if you do not care what Apache Geode would actually do in certain cases and only care about the "contract",
which is what mocking a collaborator is all about, then you could effectively mock Apache Geode's objects in order to
isolate the "_Subject Under Test_" (SUT) and focus on the interaction(s) or outcomes you expect to happen.
With STDG, you don't have to change a bit of configuration to enable mocks in the _Unit Tests_ for your Spring Boot
applications. You simply only need to annotate the test class with `@EnableGemFireMockObjects`, like so:
.Using Mock Apache Geode or Pivotal GemFire objects
.Using Mock Apache Geode objects
[source,java]
----
@RunWith(SpringRunner.class)
@@ -576,7 +574,7 @@ class MyApplicationTestClass {
@Test
public void someTestCase() {
...
// ...
}
@Configuration
@@ -588,8 +586,8 @@ class MyApplicationTestClass {
Your Spring Boot configuration of Apache Geode will return mock objects for all Apache Geode objects, such as Regions.
Mocking Apache Geode or Pivotal GemFire objects even works for GemFire/Geode objects created from the productivity
annotations discussed in the previous sections above.
Mocking Apache Geode objects even works for GemFire/Geode objects created from the productivity annotations discussed in
the previous sections above.
For example, given the following Spring Boot, Apache Geode `ClientCache` application class:
@@ -598,14 +596,14 @@ For example, given the following Spring Boot, Apache Geode `ClientCache` applica
----
@SpringBootApplication
@EnableEntityDefinedRegions(basePackageClasses = Customer.class)
class SpringBootApacheGeodeClientCacheApplication { ... }
class SpringBootApacheGeodeClientCacheApplication { }
----
The "_Customers_" Region defined by the `Customer` entity class and created by the `@EnableEntityDefinedRegions`
annotation would be a "mock" Region and not an actual Region. You can still inject the Region in your test as before
and assert interactions on the Region based on your application workflows:
.Using Mock Apache Geode or Pivotal GemFire objects
.Using Mock Apache Geode objects
[source,java]
----
@RunWith(SpringRunner.class)
@@ -624,10 +622,10 @@ class MyApplicationTestClass {
assertThat(this.customers).containsValue(jonDoe);
...
// ...
}
...
// ...
}
----

23
spring-geode-docs/src/docs/asciidoc/_includes/configuration-externalized.adoc
View File

@@ -2,7 +2,7 @@
== Externalized Configuration
Like Spring Boot itself (see {spring-boot-docs-html}/boot-features-external-config.html[here]),
Spring Boot for Apache Geode and Pivotal GemFire (SBDG) supports externalized configuration.
Spring Boot for Apache Geode (SBDG) supports externalized configuration.
By externalized configuration, we mean configuration metadata stored in a Spring Boot
{spring-boot-docs-html}/boot-features-external-config.html#boot-features-external-config-application-property-files[`application.properties` file],
@@ -15,14 +15,13 @@ in properties, {spring-boot-docs-html}/boot-features-external-config.html#boot-f
properties, and so on. What we are particularly interested in, in this section, is
{spring-boot-docs-html}/boot-features-external-config.html#boot-features-external-config-typesafe-configuration-properties[type-safety].
Like Spring Boot, Spring Boot for Apache Geode & Pivotal GemFire provides a hierarchy of classes used to capture
configuration for several Apache Geode or Pivotal GemFire features in an associated `@ConfigurationProperties`
annotated class. Again, the configuration metadata is specified as well-known, documented properties in 1 or more
Spring Boot `application.properties` files.
Like Spring Boot, Spring Boot for Apache Geode provides a hierarchy of classes used to capture configuration for several
Apache Geode features in an associated `@ConfigurationProperties` annotated class. Again, the configuration metadata is
specified as well-known, documented properties in 1 or more Spring Boot `application.properties` files.
For instance, I may have configured my Spring Boot, `ClientCache` application as follows:
.Spring Boot `application.properties` containing Spring Data properties for Apache Geode / Pivotal GemFire
.Spring Boot `application.properties` containing Spring Data properties for Apache Geode
[source,properties]
----
# Spring Boot application.properties used to configure Apache Geode
@@ -84,14 +83,12 @@ class MyApplicationComponent {
// do something with `copyOnRead`
}
...
}
----
Given a handle to {spring-boot-data-geode-javadoc}/org/springframework/geode/boot/autoconfigure/configuration/GemFireProperties.html[`GemFireProperties`],
you can access any of the configuration properties used to configure either Apache Geode or Pivotal GemFire in
a Spring context. You simply only need to autowire an instance of `GemFireProperties` into your application component.
you can access any of the configuration properties used to configure Apache Geode in a Spring context. You simply only
need to autowire an instance of `GemFireProperties` into your application component.
A complete reference to the SBDG provided `@ConfigurationProperties` classes and supporting classes is available
{spring-boot-data-geode-javadoc}/org/springframework/geode/boot/autoconfigure/configuration/package-frame.html[here].
@@ -99,8 +96,8 @@ A complete reference to the SBDG provided `@ConfigurationProperties` classes and
[[geode-configuration-externalized-session]]
=== Externalized Configuration of Spring Session
The same capability applies to accessing the externalized configuration of Spring Session when using either
Apache Geode or Pivotal GemFire as your (HTTP) Session state caching provider.
The same capability applies to accessing the externalized configuration of Spring Session when using Apache Geode
as your (HTTP) Session state caching provider.
In this case, you simply only need to acquire a reference to an instance of the
{spring-boot-data-geode-javadoc}/org/springframework/geode/boot/autoconfigure/configuration/SpringSessionProperties.html[`SpringSessionProperties`]
@@ -135,7 +132,5 @@ class MyApplicationComponent {
// do something with `sessionRegionName`
}
...
}
----

19
spring-geode-docs/src/docs/asciidoc/_includes/configuration-properties.adoc
View File

@@ -2,11 +2,11 @@
== Configuration Metadata Reference
The following 2 reference sections cover documented and well-known properties recognized and processed by
_Spring Data for Apache Geode/Pivotal GemFire_ (SDG) as well as _Spring Session for Apache Geode/Pivotal GemFire_ (SSDG).
_Spring Data for Apache Geode/_ (SDG) as well as _Spring Session for Apache Geode_ (SSDG).
These properties may be used in Spring Boot `application.properties` files, or as JVM System properties, to configure
different aspects of or enable individual features of Apache Geode or Pivotal GemFire in a Spring application.
When combined with the power of Spring Boot, magical things begin to happen.
different aspects of or enable individual features of Apache Geode in a Spring application. When combined with
the power of Spring Boot, magical things begin to happen.
[[geode-configuration-metadata-springdata]]
=== Spring Data Based Properties
@@ -20,7 +20,7 @@ property, use `spring.data.gemfire.cache.copy-on-read` in Spring Boot `applicati
|=====================================================================================================================
| Name | Description | Default | From
| name | Name of the Apache Geode / Pivotal GemFire member. | SpringBasedCacheClientApplication | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#name--[ClientCacheApplication.name]
| name | Name of the Apache Geode member. | SpringBasedCacheClientApplication | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#name--[ClientCacheApplication.name]
| locators | Comma-delimited list of Locator endpoints formatted as: locator1[port1],...,locatorN[portN]. | [] | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/PeerCacheApplication.html#locators--[PeerCacheApplication.locators]
| use-bean-factory-locator | Enable the SDG BeanFactoryLocator when mixing Spring config with GemFire/Geode native config (e.g. cache.xml) and you wish to configure GemFire objects declared in cache.xml with Spring. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#useBeanFactoryLocator--[ClientCacheApplication.useBeanFactoryLocator]
@@ -38,7 +38,7 @@ property, use `spring.data.gemfire.cache.copy-on-read` in Spring Boot `applicati
| cache.enable-auto-region-lookup | Configure whether to lookup Regions configured in GemFire/Geode native config and declare them as Spring beans. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableAutoRegionLookup.html#enabled--[EnableAutoRegionLookup.enable]
| cache.eviction-heap-percentage | Percentage of heap at or above which the eviction should begin on Regions configured for HeapLRU eviction. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#evictionHeapPercentage--[ClientCacheApplication.evictionHeapPercentage]
| cache.eviction-off-heap-percentage | Percentage of off-heap at or above which the eviction should begin on Regions configured for HeapLRU eviction. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#evictionOffHeapPercentage--[ClientCacheApplication.evictionOffHeapPercentage]
| cache.log-level | Configure the log-level of an Apache Geode / Pivotal GemFire cache. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#logLevel--[ClientCacheApplication.logLevel]
| cache.log-level | Configure the log-level of an Apache Geode cache. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#logLevel--[ClientCacheApplication.logLevel]
| cache.name | Alias for 'spring.data.gemfire.name'. | SpringBasedCacheClientApplication | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#name--[ClientCacheApplication.name]
| cache.compression.bean-name | Name of a Spring bean implementing org.apache.geode.compression.Compressor. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableCompression.html#compressorBeanName--[EnableCompression.compressorBeanName]
| cache.compression.region-names | Comma-delimited list of Region names for which compression will be configured. | [] | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableCompression.html#regionNames--[EnableCompression.regionNames]
@@ -188,7 +188,7 @@ specified location and limited to the defined size.
|=====================================================================================================================
| Name | Description | Default | From
| logging.level | Configures the log-level of an Apache Geode / Pivotal GemFire cache; Alias for 'spring.data.gemfire.cache.log-level'. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logLevel--[EnableLogging.logLevel]
| logging.level | Configures the log-level of an Apache Geode cache; Alias for 'spring.data.gemfire.cache.log-level'. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logLevel--[EnableLogging.logLevel]
| logging.log-disk-space-limit | Configures the amount of disk space allowed to store log files. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logDiskSpaceLimit--[EnableLogging.logDiskSpaceLimit]
| logging.log-file | Configures the pathname of the log file used to log messages. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logFile--[EnableLogging.logFile]
| logging.log-file-size | Configures the maximum size of a log file before the log file is rolled. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logFileSizeLimit--[EnableLogging.logFileSize]
@@ -328,7 +328,7 @@ specified location and limited to the defined size.
| service.http.bind-address | Configures the IP address or hostname of the system NIC used by the embedded HTTP server to bind and listen for HTTP(S) connections. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#bindAddress--[EnableHttpService.bindAddress]
| service.http.port | Configures the port used by the embedded HTTP server to listen for HTTP(S) connections. | 7070 | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#port--[EnableHttpService.port]
| service.http.ssl-require-authentication | Configures whether 2-way HTTP authentication is required. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#sslRequireAuthentication--[EnableHttpService.sslRequireAuthentication]
| service.http.dev-rest-api-start | Configures whether to start the Developer REST API web service. A full installation of Apache Geode or Pivotal GemFire is required and you must set the $GEODE environment variable. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#startDeveloperRestApi--[EnableHttpService.startDeveloperRestApi]
| service.http.dev-rest-api-start | Configures whether to start the Developer REST API web service. A full installation of Apache Geode is required and you must set the $GEODE environment variable. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#startDeveloperRestApi--[EnableHttpService.startDeveloperRestApi]
| service.memcached.port | Configures the port of the embedded Memcached server (service). | 11211| {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableMemcachedServer.html#port--[EnableMemcachedServer.port]
| service.memcached.protocol | Configures the protocol used by the embedded Memcached server (service). | ASCII | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableMemcachedServer.html#protocol--[EnableMemcachedServer.protocol]
| service.redis.bind-address | Configures the IP address or hostname of the system NIC used by the embedded Redis server to bind an listen for connections. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableRedisServer.html#bindAddress--[EnableRedis.bindAddress]
@@ -366,6 +366,5 @@ While it is not recommended to use Apache Geode properties directly in your Spri
you from doing so. A complete reference to the Apache Geode specific properties can be found
{apache-geode-docs}/reference/topics/gemfire_properties.html[here].
WARNING: Apache Geode (and Pivotal GemFire) are very strict about the properties that maybe specified in
a `gemfire.properties` file. You cannot mix Spring properties with `gemfire.*` properties in an Apache Geode
or Pivotal GemFire, `gemfire.properties` file.
WARNING: Apache Geode is very strict about the properties that maybe specified in a `gemfire.properties` file. You
cannot mix Spring properties with `gemfire.*` properties in an Apache Geode `gemfire.properties` file.

26
spring-geode-docs/src/docs/asciidoc/_includes/continuous-query.adoc
View File

@@ -5,21 +5,20 @@ Arguably, the most invaluable of applications are those that can process a strea
and intelligently react in near real-time to the countless changes in the data over time. The most useful
of frameworks are those that can make processing a stream of events as they happen, as easy as possible.
Spring Boot for Apache Geode & Pivotal GemFire does just that, without users having to perform any complex setup
or configure any necessary infrastructure components to enable such functionality. Developers can simply define
the criteria for the data they are interested in and implement a handler to process the stream of events
as they occur.
Spring Boot for Apache Geode does just that, without users having to perform any complex setup or configure any
necessary infrastructure components to enable such functionality. Developers can simply define the criteria for
the data they are interested in and implement a handler to process the stream of events as they occur.
Apache Geode & Pivotal GemFire make defining criteria for data of interests easy when using
Apache Geode make defining criteria for data of interests easy when using
{apache-geode-docs}/developing/continuous_querying/chapter_overview.html[Continuous Query (CQ)]. With CQ, you can
express the criteria matching the data of interests using a query predicate. Apache Geode & Pivotal GemFire implements
express the criteria matching the data of interests using a query predicate. Apache Geode implements
the {apache-geode-docs}/developing/querying_basics/query_basics.html[Object Query Language (OQL)] for defining
and executing queries. OQL is not unlike SQL, and supports projections, query predicates, ordering and aggregates.
And, when used in CQs, they execute continuously, firing events when the data changes in such ways as to match
the criteria expressed in the query predicate.
Spring Boot for Apache Geode/Pivotal GemFire combines the ease of expressing interests in data using an OQL
query statement with implementing the listener handler callback, in 1 easy step.
Spring Boot for Apache Geode combines the ease of expressing interests in data using an OQL query statement with
implementing the listener handler callback, in 1 easy step.
For example, suppose we want to perform some follow up action anytime a customer's financial loan application
is either approved or denied.
@@ -38,7 +37,7 @@ class EligibilityDecision {
private final Timespan timespan;
...
// ...
enum Status {
@@ -64,7 +63,7 @@ class EligibilityDecisionPostProcessor {
FROM /EligibilityDecisions decisions
WHERE decisions.getStatus().name().equalsIgnoreCase('APPROVED')")
public void processApprovedDecisions(CqEvent event) {
...
// ...
}
@ContinuousQuery(name = "DeniedDecisionsHandler",
@@ -72,7 +71,7 @@ class EligibilityDecisionPostProcessor {
FROM /EligibilityDecisions decisions
WHERE decisions.getStatus().name().equalsIgnoreCase('DENIED')")
public void processDeniedDecisions(CqEvent event) {
...
// ...
}
}
----
@@ -83,6 +82,5 @@ anyway you like. And, because our Continuous Query handler class is a component
`ApplicationContext`, you can auto-wire any other beans necessary to carry out the application's intended function.
This is not unlike Spring's {spring-framework-docs}/integration.html#jms-annotated[Annotation-driven listener endpoints]
used in (JMS) message listeners/handlers, except in Spring Boot for Apache Geode/Pivotal GemFire, you do not need to do
anything special to enable this functionality. Just declare the `@ContinuousQuery` annotation on any POJO method
and off you go.
used in (JMS) message listeners/handlers, except in Spring Boot for Apache Geode, you do not need to do anything special
to enable this functionality. Just declare the `@ContinuousQuery` annotation on any POJO method and off you go.

29
spring-geode-docs/src/docs/asciidoc/_includes/data-serialization.adoc
View File

@@ -2,26 +2,26 @@
== Data Serialization with PDX
Anytime data is overflowed or persisted to disk, transferred between clients and servers, peers in a cluster or between
different clusters in a multi-site topology, then all data stored in Apache Geode/Pivotal GemFire must be serializable.
different clusters in a multi-site topology, then all data stored in Apache Geode must be serializable.
To serialize objects in Java, object types must implement the `java.io.Serializable` interface. However, if you have
a large number of application domain object types that currently do not implement `java.io.Serializable`, then
refactoring hundreds or even thousands of class types to implement `Serializable` would be a tedious task just to
store and manage those objects in Apache Geode or Pivotal GemFire.
store and manage those objects in Apache Geode.
Additionally, it is not just your application domain object types you necessarily need to worry about either. If you
used 3rd party libraries in your application domain model, any types referred to by your application domain object types
stored in Apache Geode or Pivotal GemFire must be serializable too. This type explosion may bleed into class types
for which you may have no control over.
stored in Apache Geode must be serializable too. This type explosion may bleed into class types for which you may have
no control over.
Furthermore, Java serialization is not the most efficient format given that meta-data about your types is stored with
the data itself. Therefore, even though Java serialized bytes are more descriptive, it adds a great deal of overhead.
Then, along came serialization using Apache Geode or Pivotal GemFire's {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX]
Then, along came serialization using Apache Geode {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX]
format. PDX stands for _Portable Data Exchange_, and achieves 4 goals:
1. Separates type meta-data from the data itself making the bytes more efficient during transfer. Apache Geode
and Pivotal GemFire maintain a type registry storing type meta-data about the objects serialized using PDX.
1. Separates type meta-data from the data itself making the bytes more efficient during transfer. Apache Geode maintains
a type registry storing type meta-data about the objects serialized using PDX.
2. Supports versioning as your application domain types evolve. It is not uncommon to have old and new applications
deployed to production, running simultaneously, sharing data, and possibly using different versions of the same domain
@@ -50,7 +50,7 @@ de-serializing the object bytes since it involves a method invocation, which def
preserving format to avoid the cost of de/serialization.
However, we think the benefits of using PDX greatly outweigh the limitations and therefore have enabled PDX by default
when using Spring Boot for Apache Geode/Pivotal GemFire.
when using Spring Boot for Apache Geode.
There is nothing special you need to do. Simply code your types and rest assured that objects of those types will be
properly serialized when overflowed/persisted to disk, transferred between clients and servers, or peers in a cluster
@@ -61,17 +61,17 @@ and even when data is transferred over the WAN when using GemFire/Geode's multi-
----
@Region("EligibilityDecisions")
class EligibilityDecision {
...
// ...
}
----
TIP: Apache Geode/Pivotal GemFire does {apache-geode-docs}/developing/data_serialization/java_serialization.html[support]
the standard Java Serialization format.
TIP: Apache Geode does {apache-geode-docs}/developing/data_serialization/java_serialization.html[support] the standard
Java Serialization format.
=== SDG `MappingPdxSerializer` vs. GemFire/Geode's `ReflectionBasedAutoSerializer`
Under-the-hood, Spring Boot for Apache Geode/Pivotal GemFire {spring-data-geode-docs-html}/#bootstrap-annotation-config-pdx[enables]
and uses Spring Data for Apache Geode/Pivotal GemFire's {spring-data-geode-javadoc}/org/springframework/data/gemfire/mapping/MappingPdxSerializer.html[MappingPdxSerializer]
Under-the-hood, Spring Boot for Apache Geode {spring-data-geode-docs-html}/#bootstrap-annotation-config-pdx[enables]
and uses Spring Data for Apache Geode's {spring-data-geode-javadoc}/org/springframework/data/gemfire/mapping/MappingPdxSerializer.html[MappingPdxSerializer]
to serialize your application domain objects using PDX.
TIP: Refer to the SDG {spring-data-geode-docs-html}/#mapping.pdx-serializer[Reference Guide] for more details
@@ -104,7 +104,7 @@ with Spring Data's {spring-data-commons-javadoc}/org/springframework/data/annota
of nested entity field/property types.
Number two above deserves special attention since the `MappingPdxSerializer` "excludes" all Java, Spring
and Apache Geode/Pivotal GemFire types, by default. But, what happens when you need to serialize 1 of those types?
and Apache Geode types, by default. But, what happens when you need to serialize 1 of those types?
For example, suppose you need to be able to serialize objects of type `java.security.Principal`. Well, then you can
override the excludes by registering an "include" type filter, like so:
@@ -114,7 +114,6 @@ override the excludes by registering an "include" type filter, like so:
package example.app;
import java.security.Principal;
import ...;
@SpringBootApplication
@EnablePdx(serializerBeanName = "myCustomMappingPdxSerializer")

19
spring-geode-docs/src/docs/asciidoc/_includes/functions.adoc
View File

@@ -15,21 +15,20 @@ Additionally, when the computations are handled in parallel, across the cluster
can be performed much faster. This typically involves intelligently organizing the data using various partitioning
(a.k.a. sharding) strategies to uniformly balance the data set across the cluster.
Well, both Apache Geode and Pivotal GemFire address this very important application concern in its
Well, Apache Geode address this very important application concern in its
{apache-geode-docs}/developing/function_exec/chapter_overview.html[Function Execution] framework.
Spring Data for Apache Geode/Pivotal GemFire {spring-data-geode-docs-html}/#function-annotations[builds] on
this Function Execution framework by enabling developers to {spring-data-geode-docs-html}/#function-implementation[implement]
Spring Data for Apache Geode {spring-data-geode-docs-html}/#function-annotations[builds] on this Function Execution
framework by enabling developers to {spring-data-geode-docs-html}/#function-implementation[implement]
and {spring-data-geode-docs-html}/#function-execution[execute] GemFire/Geode Functions using a very simple POJO-based,
annotation configuration model.
TIP: See {spring-data-geode-docs-html}/#_implementation_vs_execution[here] for the difference between
Function implementation & executions.
Taking this 1 step further, Spring Boot for Apache Geode/Pivotal GemFire _auto-configures_ and enables both Function
implementation and execution out-of-the-box. Therefore, you can immediately begin writing Functions and invoking them
without having to worry about all the necessary plumbing to begin with. You can rest assured that it will just work
as expected.
Taking this 1 step further, Spring Boot for Apache Geode _auto-configures_ and enables both Function implementation
and execution out-of-the-box. Therefore, you can immediately begin writing Functions and invoking them without having
to worry about all the necessary plumbing to begin with. You can rest assured that it will just work as expected.
=== Applying Functions
@@ -58,7 +57,7 @@ class EligibilityDeterminationFunction {
@GemfireFunction(HA = true, hasResult = true, optimizeForWrite=true)
public EligibilityDecision determineEligibility(FunctionContext functionContext, Person person, Timespan timespan) {
...
// ...
}
}
----
@@ -97,7 +96,7 @@ class FinancialLoanApplicationService {
this.execution = execution;
}
@Cacheable("EligibilityDecisions", ...)
@Cacheable("EligibilityDecisions")
EligibilityDecision processEligility(Person person, Timespan timespan) {
return this.execution.determineEligibility(person, timespan);
}
@@ -105,6 +104,6 @@ class FinancialLoanApplicationService {
----
Just like caching, no addition configuration is required to enable and find your application Function implementations
and executions. Simply build and run. Spring Boot for Apache Geode/Pivotal GemFire handles the rest.
and executions. Simply build and run. Spring Boot for Apache Geode handles the rest.
TIP: It is common to implement and register your application Functions on the server and execute them from the client.

2
spring-geode-docs/src/docs/asciidoc/_includes/gemfire-properties.adoc
View File

@@ -1,6 +1,6 @@
[[geode-configuration-gemfire-properties]]
== Using Geode Properties
:gemfire-name: Pivotal GemFire
:gemfire-name: VMWare Tanzu GemFire
:geode-name: Apache Geode
As of Spring Boot for {geode-name} & {gemfire-name} (SBDG) 1.3, it is now possible to declare {geode-name}

2
spring-geode-docs/src/docs/asciidoc/_includes/geode-api-ext.adoc
View File

@@ -1,6 +1,6 @@
[[geode-api-extensions]]
== Apache Geode API Extensions
:gemfire-name: Pivotal GemFire
:gemfire-name: VMware Tanzu GemFire
:geode-name: Apache Geode
:images-dir: ./images

26
spring-geode-docs/src/docs/asciidoc/_includes/logging.adoc
View File

@@ -16,15 +16,15 @@ e.g. `log-level` no longer have any effect, regardless of whether the property (
TIP: Refer to Apache Geode's {apache-geode-docs}/reference/topics/gemfire_properties.html[Documentation]
for a complete list of valid `Properties`, including the `Properties` used to configure logging.
Unfortunately, this also means the _Spring Data for Apache Geode & Pivotal GemFire_ (SDG)
Unfortunately, this also means the _Spring Data for Apache Geode_ (SDG)
{spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html[`@EnableLogging`]
annotation no longer has any effect on Apache Geode or Pivotal GemFire logging either and is the reason it has been
annotation no longer has any effect on Apache Geode logging either and is the reason it has been
https://jira.spring.io/browse/DATAGEODE-299[deprecated]. The reason `@EnableLogging` no longer has any effect on
logging is because this annotation's attributes and associated SDG properties indirectly sets the corresponding
Apache Geode or Pivotal GemFire properties, which again, are useless from Apache Geode `1.9.2` onward.
Apache Geode properties, which again, are useless from Apache Geode `1.9.2` onward.
By way of example, and to make this concrete, **none** of the following approaches have any effect on Apache Geode
or Pivotal GemFire logging:
By way of example, and to make this concrete, **none** of the following approaches have any effect
on Apache Geode logging:
.Command-line configuration
[source,txt]
@@ -36,7 +36,7 @@ $ java -classpath ...:/path/to/MySpringBootApacheGeodeClientCacheApplication.jar
.Externalized configuration using Apache Geode `gemfire.properties`
[source,properties]
----
# Apache Geode/Pivotal GemFire only/specific properties
# Apache Geode only/specific properties
log-level=INFO
----
@@ -66,11 +66,11 @@ class MySpringBootApacheGeodeClientApplication {
That is to say, none of the approaches above have any effect without the **new** SBDG logging starter.
[[geode-logging-configuration]]
=== Configure Apache Geode & Pivotal GemFire Logging
=== Configure Apache Geode Logging
So, how do you configure logging for Apache Geode and Pivotal GemFire?
So, how do you configure logging for Apache Geode?
Effectively, 3 things are required to get Apache Geode or Pivotal GemFire to log output:
Effectively, 3 things are required to get Apache Geode to log output:
1) First, you must declare a logging provider on your Spring Boot application classpath (e.g. _Logback_).
@@ -103,7 +103,7 @@ or bridges `java.util.logging` (JUL) and Apache Log4j to SLF4J. However, you st
configuration, such as a `logback.xml` file for _Logback_, to configure logging not only for your Spring Boot
application, but also for Apache Geode as well.
SBDG has simplified the setup of Apache Geode and Pivotal GemFire logging. Simply declare the
SBDG has simplified the setup of Apache Geode logging. Simply declare the
`org.springframework.geode:spring-geode-starter-logging` dependency on your Spring Boot application classpath!
Unlike Apache Geode's default Log4j XML configuration file (i.e. `log4j2.xml`), SBDG's provided `logback.xml`
@@ -129,8 +129,8 @@ SBDG's _Logback_ configuration defines 3 Loggers to control the log output from
<logger name="org.jgroups" level="${spring.boot.data.gemfire.jgroups.log.level:-ERROR}"/>
----
The `com.gemstone.gemfire` Logger is a legacy Logger covering old Pivotal GemFire bits still present in Apache Geode
for backwards compatibility reasons. This Logger's use should be largely unnecessary.
The `com.gemstone.gemfire` Logger is a legacy Logger covering old VMware Tanzu GemFire bits still present
in Apache Geode for backwards compatibility reasons. This Logger's use should be largely unnecessary.
The `org.apache.geode` Logger is the primary Logger used to control log output from all Apache Geode components
during the runtime operation of Apache Geode. Both this Logger and the legacy `com.gemstone.gemfire` Logger default
@@ -238,7 +238,7 @@ For example, you could compose both the _Logback_ `ConsoleAppender` and `FileApp
.Composing multiple `Appenders`
[source,java]
----
ConsoleAppender<ILoggingEvent> consoleAppender = ...;
ConsoleAppender<ILoggingEvent> consoleAppender = ... ;
FileAppender<ILoggingEvent> fileAppender = ...;

13
spring-geode-docs/src/docs/asciidoc/_includes/repositories.adoc
View File

@@ -1,17 +1,16 @@
[[geode-repositories]]
== Spring Data Repositories
Using Spring Data Repositories with Apache Geode or Pivotal GemFire makes short work of data access operations when
using either Apache Geode or Pivotal GemFire as your System of Record (SOR) to persist your application's state.
Using Spring Data Repositories with Apache Geode makes short work of data access operations when using Apache Geode
as your System of Record (SOR) to persist your application's state.
{spring-data-commons-docs-html}/#repositories[Spring Data Repositories] provides a convenient and highly powerful way
to define basic CRUD and simple query data access operations easily just by specifying the contract of those data access
operations in a Java interface.
Spring Boot for Apache Geode & Pivotal GemFire _auto-configures_ the Spring Data for Apache Geode/Pivotal GemFire
{spring-data-geode-docs-html}/#gemfire-repositories[Repository extension] when either is declared on your application's
classpath. You do not need to do anything special to enable it. Simply start coding your application-specific
Repository interfaces and the way you go.
Spring Boot for Apache Geode _auto-configures_ the Spring Data for Apache Geode {spring-data-geode-docs-html}/#gemfire-repositories[Repository extension]
when declared on your application's classpath. You do not need to do anything special to enable it. Simply start
coding your application-specific Repository interfaces and the way you go.
For example:
@@ -83,5 +82,5 @@ class SpringBootApacheGeodeClientCacheApplication {
----
Again, see Spring Data Commons' {spring-data-commons-docs-html}/#repositories[Repositories abstraction] in general,
and Spring Data for Apache Geode/Pivotal GemFire {spring-data-geode-docs-html}/#gemfire-repositories[Repositories extension]
and Spring Data for Apache Geode {spring-data-geode-docs-html}/#gemfire-repositories[Repositories extension]
in particular, for more details.

11
spring-geode-docs/src/docs/asciidoc/_includes/samples.adoc
View File

@@ -1,12 +1,11 @@
[[geode-samples]]
== Samples
This section contains working examples demonstrating how to use Spring Boot for Apache Geode and Pivotal GemFire (SBDG)
effectively.
This section contains working examples demonstrating how to use Spring Boot for Apache Geode (SBDG) effectively.
Some examples focus on specific Use Cases (e.g. [(HTTP) Session state] caching) while other examples demonstrate how
SBDG works under-the-hood to give users a better understanding of what is actually happening and how to debug problems
with their Apache Geode / Pivotal GemFire, Spring Boot applications.
with their Apache Geode, Spring Boot applications.
.Example Spring Boot applications using Apache Geode
|===
@@ -17,15 +16,15 @@ with their Apache Geode / Pivotal GemFire, Spring Boot applications.
applications with Spring Boot.
| {github-samples-url}/intro/getting-started[Getting Started]
| link:guides/boot-configuration.html[Spring Boot Auto-Configuration for Apache Geode/Pivotal GemFire]
| link:guides/boot-configuration.html[Spring Boot Auto-Configuration for Apache Geode]
| Explains what auto-configuration is provided by SBDG out-of-the-box and what the auto-configuration is doing.
| {github-samples-url}/boot/configuration[Boot Auto-Configuration]
| link:guides/boot-actuator.html[Spring Boot Actuator for Apache Geode/Pivotal GemFire]
| link:guides/boot-actuator.html[Spring Boot Actuator for Apache Geode]
| Explains how to use Spring Boot Actuator for Apache Geode and how it works.
| {github-samples-url}/boot/actuator[Boot Actuator]
| link:guides/boot-security.html[Spring Boot Security for Apache Geode/Pivotal GemFire]
| link:guides/boot-security.html[Spring Boot Security for Apache Geode]
| Explains how to configure Auth and TLS with SSL when using Apache Geode and Pivotal Cloud Cache
in Spring Boot applications.
| {github-samples-url}/boot/security[Boot Security]

33
spring-geode-docs/src/docs/asciidoc/_includes/templates.adoc
View File

@@ -20,11 +20,11 @@ the core Spring Framework.
Other Spring Data modules, such as Spring Data Redis, offer the
https://docs.spring.io/spring-data/redis/docs/current/api/org/springframework/data/redis/core/RedisTemplate.html[RedisTemplate],
and Spring Data for Apache Geode/Pivotal GemFire (SDG) offers the
and Spring Data for Apache Geode (SDG) offers the
{spring-data-gemfire-javadoc}/org/springframework/data/gemfire/GemfireTemplate.html[GemfireTemplate].
The `GemfireTemplate` provides a highly consistent and familiar API to perform data access operations on Apache Geode
or Pivotal GemFire cache `Regions`.
cache `Regions`.
`GemfireTemplate` offers:
@@ -33,8 +33,8 @@ or Pivotal GemFire cache `Regions`.
3. Automatic enlistment in the presence of local, cache transactions.
4. Protection from {apache-geode-javadoc}/org/apache/geode/cache/Region.html[Region API] breaking changes.
Given these conveniences, Spring Boot for Apache Geode & Pivotal GemFire (SBDG) will auto-configure `GemfireTemplate`
beans for each Region present in the GemFire/Geode cache.
Given these conveniences, Spring Boot for Apache Geode (SBDG) will auto-configure `GemfireTemplate` beans for each
Region present in the cache.
Additionally, SBDG is careful not to create a `GemfireTemplate` if the user has already declared a `GemfireTemplate`
bean in the Spring `ApplicationContext` for a given Region.
@@ -51,7 +51,7 @@ class GemFireConfiguration {
@Bean("Example")
ClientRegionFactoryBean<?, ?> exampleRegion (GemFireCache gemfireCache) {
...
// ...
}
}
----
@@ -88,7 +88,7 @@ Given the following entity class:
----
@Region("Customers")
class Customer {
...
// ...
}
----
@@ -97,9 +97,9 @@ And configuration:
[source,java]
----
@Configuration
@EnableEntityDefinedRegions(basePackageClasses = Customer.class}
@EnableEntityDefinedRegions(basePackageClasses = Customer.class)
class GemFireConfiguration {
...
// ...
}
----
@@ -127,9 +127,8 @@ explicitly or implicitly, such as when using the `@EnableEntityDefineRegions` an
SBDG auto-configures `GemfireTemplate` beans for Caching-defined Regions.
When you are using Spring Framework's {spring-framework-docs}/integration.html#cache[Cache Abstraction] backed by
either Apache Geode or Pivotal GemFire, 1 of the requirements is to configure Regions for each of the caches specified
in the {spring-framework-docs}integration.html#cache-annotations[Caching Annotations] of your application service
components.
Apache Geode, 1 of the requirements is to configure Regions for each of the caches specified in the
{spring-framework-docs}integration.html#cache-annotations[Caching Annotations] of your application service components.
Fortunately, SBDG makes enabling and configuring caching easy and <<geode-caching-provider,automatic>> out-of-the-box.
@@ -183,8 +182,8 @@ when autowiring does not.
[[geode-data-access-region-templates-native-defined]]
=== Native-defined Regions
SBDG will even auto-configure `GemfireTemplate` beans for Regions defined using Apache Geode and Pivotal GemFire native
configuration meta-data, such as `cache.xml`.
SBDG will even auto-configure `GemfireTemplate` beans for Regions defined using Apache Geode native configuration
metadata, such as `cache.xml`.
Given the following GemFire/Geode native `cache.xml`:
@@ -208,7 +207,7 @@ And Spring configuration:
@Configuration
@EnableGemFireProperties(cacheXmlFile = "cache.xml")
class GemFireConfiguration {
...
// ...
}
----
@@ -243,7 +242,7 @@ class GemFireConfiguration {
@Bean
public GemfireTemplate customersTemplate(GemFireCache cache) {
return new GemfireTemplate(cache.getRegion("/Customers");
return new GemfireTemplate(cache.getRegion("/Customers"));
}
}
----
@@ -254,7 +253,7 @@ Using our same Customers class, as above:
----
@Region("Customers")
class Customer {
...
// ...
}
----
@@ -278,7 +277,7 @@ class GemFireConfiguration {
@Bean
public GemfireTemplate vipCustomersTemplate(GemFireCache cache) {
return new GemfireTemplate(cache.getRegion("/Customers");
return new GemfireTemplate(cache.getRegion("/Customers"));
}
}
----

15
spring-geode-docs/src/docs/asciidoc/guides/caching-inline.adoc
View File

@@ -160,10 +160,9 @@ expired or been evicted. We neither configure eviction nor expiration for this
Both the `factorial(..)` and `sqrt(..)` methods have been annotated with Spring's `@Cacheable` annotation to demarcate
these methods with caching behavior. Of course, as explained in SBDG's <<../_includes/configuration-annotations.adoc#geode-caching-provider,documentation>>,
caching with Spring's Cache Abstraction using Apache Geode (or Pivotal GemFire, even Pivotal Cloud Cache (PCC)
when running in Pivotal CloudFoundry (PCF)) as the caching provider is enabled by default. Therefore, there is nothing
more you need do to start leverage caching in your Spring Boot applications than to annotate the service methods
with the appropriate Spring or JSR-107, JCache API annotations. Simple!
caching with Spring's Cache Abstraction using Apache Geode as the caching provider is enabled by default. Therefore,
there is nothing more you need do to start leverage caching in your Spring Boot applications than to annotate
the service methods with the appropriate Spring or JSR-107, JCache API annotations. Simple!
It is worth noting that we are starting with the same applied pattern of caching as you would when using the
_Look-Aside Caching_ pattern. This is key to minimizing the invasive nature of _Inline Caching_. There is a subtle
@@ -187,7 +186,7 @@ The pertinent part of the configuration that enables _Inline Caching_ for our Ca
the `inlineCachingForCalculatorApplicationRegionsConfigurer` bean definition.
SBDG provides the `InlineCachingRegionConfigurer` class used in the bean definition to configure and enable the caches
(a.k.a. as Regions in Apache Geode & Pivotal GemFire terminology) with _Inline Caching_ behavior.
(a.k.a. as Regions in Apache Geode terminology) with _Inline Caching_ behavior.
The Configurer's job is to configure the appropriate Spring Data (SD) _Repository_ used as a Region's `CacheLoader`
for "_read-through_" behavior as well as configure the same SD _Repository_ for a Region's `CacheWriter` for
@@ -260,9 +259,9 @@ these Regions for you.
TIP: If you have not done so already, you should definitely read about SBDG's support for _Inline Caching_
in the link:../index.html#geode-caching-provider-inline-caching[Inline Caching] section.
TIP: To learn more about how Apache Geode's (or Pivotal GemFire's) data loading functionality works, or specifically,
how to {apache-geode-docs}/developing/outside_data_sources/sync_outside_data.html["Keep the Cache in Sync with Outside
Data Sources"] follow the link. You may also learn more by reading the _Javadoc_ for
TIP: To learn more about how Apache Geode's data loading functionality works, or specifically, how to
{apache-geode-docs}/developing/outside_data_sources/sync_outside_data.html["Keep the Cache in Sync with Outside Data Sources"]
follow the link. You may also learn more by reading the _Javadoc_ for
{apache-geode-javadoc}//org/apache/geode/cache/CacheLoader.html[`CacheLoader`]
and {apache-geode-javadoc}/org/apache/geode/cache/CacheWriter.html[`CacheWriter`].

22
spring-geode-docs/src/docs/asciidoc/guides/caching-look-aside.adoc
View File

@@ -173,9 +173,8 @@ With the `org.springframework.geode:spring-geode-starter` dependency on your app
And the `BootGeodeLookAsideCachingApplication` class annotated with `@SpringBootApplication`, you have everything you
need to begin using Spring's _Cache Abstraction_ in your application with Apache Geode as the caching provider.
TIP: You can switch from open source Apache Geode to Pivotal GemFire (PCC) very easily simply by changing
the artifactId from `spring-geode-starter` to `spring-gemfire-starter`. No configuration or code changes
are necessary.
TIP: You can switch from open source Apache Geode to VMware Tanzu GemFire very easily simply by changing the artifactId
from `spring-geode-starter` to `spring-gemfire-starter`. No configuration or code changes are necessary.
As an application developer, all you need do is focus on where in your application caching would be most beneficial.
@@ -246,9 +245,8 @@ After running the `BootGeodeLookAsideCachingApplication` class, if you open a We
[[geode-samples-caching-lookaside-example-counterservice-configuration]]
=== Counter Service Configuration
While Spring Boot for Apache Geode/Pivotal GemFire (PCC), SBDG, takes care of enabling Spring's caching infrastructure
for you, configuring Apache Geode/Pivotal GemFire (PCC) as a caching provider, you still must define and declare
your individual caches.
While Spring Boot for Apache Geode (SBDG) takes care of enabling Spring's caching infrastructure for you, configuring
Apache Geode as a caching provider, you still must define and declare your individual caches.
No Spring caching provider is fully configured by Spring or Spring Boot for that matter. Part of the reason for this
is that there are many different ways to configure the caches.
@@ -268,9 +266,9 @@ include::{samples-dir}/caching/look-aside/src/main/java/example/app/caching/look
----
The only thing of real significance here is the `@EnableCachingDefinedRegions` annotation. This Spring Data
for Apache Geode/Pivotal GemFire (SDG) annotation is responsible for introspecting our Spring Boot application
on Spring container startup, identifying all the caching annotations (both Spring Cache annotations as wells JSR-107,
JCache annotations) used in our application components, and creating the appropriate caches.
for Apache Geode (SDG) annotation is responsible for introspecting our Spring Boot application on Spring container
startup, identifying all the caching annotations (both Spring Cache annotations as wells JSR-107, JCache annotations)
used in our application components, and creating the appropriate caches.
If you were not using SDG's `@EnablingCachingDefinedRegions` annotation, then you would need to define the Region
using the equivalent _JavaConfig_:
@@ -547,9 +545,9 @@ B | 2
As you have learned, Spring makes enabling and using caching in your application really easy.
With SBDG, using either Apache Geode or Pivotal GemFire as your caching provider in Spring's _Cache Abstraction_
is as easy as making sure `org.springframework.geode:spring-geode-starter` is on your application's classpath. You just
need to focus on areas of your application that would benefit from caching.
With SBDG, using Apache Geode as your caching provider in Spring's _Cache Abstraction_ is as easy as making sure
`org.springframework.geode:spring-geode-starter` is on your application's classpath. You just need to focus on areas
of your application that would benefit from caching.
You have now successfully used the _**Look-Aside Caching**_ pattern in your Spring Boot application.

2
spring-geode-docs/src/docs/asciidoc/guides/caching-near.adoc
View File

@@ -168,7 +168,7 @@ include::{samples-dir}/caching/near/src/main/java/example/app/caching/near/serve
----
TIP: For more information on configurating and bootstrapping a small cluster of {apache-geode-name} servers using Spring Boot,
see link:../index.html#geode-cluster-configuration-bootstrapping[Running an {apache-geode-name} or Pivotal GemFire Cluster using Spring Boot].
see link:../index.html#geode-cluster-configuration-bootstrapping[Running an {apache-geode-name} Cluster using Spring Boot].
[[geode-samples-caching-near-example-client-side]]
=== Client-side Configuration

140
spring-geode-docs/src/docs/asciidoc/guides/getting-started.adoc
View File

@@ -29,33 +29,33 @@ John Blum
:docinfodir: guides
This guide walks you through building and running a simple Spring Boot, Apache Geode `ClientCache` application
using the Spring Boot for Apache Geode (SBDG) framework. Later in this guide, we switch the application from
{apache-geode-website}[Apache Geode] to {pivotal-cloudcache-website}[Pivotal Cloud Cache] and deploy (i.e `_push_`)
This guide walks you through building and running a simple Spring Boot, {geode-name} `ClientCache` application
using the Spring Boot for {geode-name} (SBDG) framework. Later in this guide, we switch the application from
{apache-geode-website}[{geode-name}] to {pivotal-cloudcache-website}[{cloudcache-name}] and deploy (i.e `_push_`)
the application up to {pivotal-cloudfoundry-website}[_Pivotal Platform_].
Specifically, you will:
1. Create a new "_Spring for Apache Geode_" project using _Spring Initializer_ at https://start.spring.io[start.spring.io].
1. Create a new "_Spring for {geode-name}_" project using _Spring Initializer_ at https://start.spring.io[start.spring.io].
Goto the <<geode-samples-getting-started-spring-initializer,Spring Initializer>> topic.
2. Then, we build a simple Spring Boot, Apache Geode `ClientCache` application that can persist data locally
in Apache Geode. Goto the <<spring-geode-samples-getting-started-build-app,Build App>> topic.
2. Then, we build a simple Spring Boot, {geode-name} `ClientCache` application that can persist data locally
in {geode-name}. Goto the <<spring-geode-samples-getting-started-build-app,Build App>> topic.
3. Next, we switch the application from running locally to using a client/server topology.
Goto the <<spring-geode-samples-getting-started-run-app-clientserver,Client/Server>> topic.
4. And finally, we deploy the application to _Pivotal Platform_ and bind our application to a provisioned
_Pivotal Cloud Cache_ (PCC) service instance.
_{cloudcache-name}_ (PCC) service instance.
Goto the <<spring-geode-samples-getting-started-run-app-cloudplatform,Cloud Platform>> topic.
Our goal is to accomplish each step with _little to no code or configuration_ changes. It should just work!
NOTE: It is also possible to migrate from a Commercial, Managed environment (running in _Pivotal Platform_
using _Pivotal Cloud Cache_ (PCC)) back to an Open Source, Non-Managed environment (i.e. running with an externally
managed Apache Geode cluster).
using _{cloudcache-name}_ (PCC)) back to an Open Source, Non-Managed environment (i.e. running with an externally
managed {geode-name} cluster).
By the end of this guide, you should feel comfortable and ready to begin building Spring Boot applications using either
Apache Geode standalone or by deploying and running in _Pivotal Platform_ using _Pivotal Cloud Cache_ (PCC).
{geode-name} standalone or by deploying and running in _Pivotal Platform_ using _{cloudcache-name}_ (PCC).
NOTE: {pivotal-cloudcache-website}[_Pivotal Cloud Cache_] (PCC) has replaced {pivotal-gemfire-website}[_Pivotal GemFire_]
NOTE: {pivotal-cloudcache-website}[_{cloudcache-name}_] (PCC) has replaced {pivotal-gemfire-website}[_{gemfire-name}_]
as the new brand name.
Let's begin!
@@ -80,7 +80,7 @@ When creating the example app for this guide, we selected:
** _Artifact_: **crm**
** _Options_:
*** _Package Name_: **example.app.crm**
* _Dependencies_: Add "**Spring for Apache Geode**" by typing "_Geode_" into the "_Search dependencies to add_"
* _Dependencies_: Add "**Spring for {geode-name}**" by typing "_Geode_" into the "_Search dependencies to add_"
text field.
* (Optional) _Dependencies_: Add "_Spring Web_" to pull in `org.springframework.boot:spring-boot-starter-web`
if you want this Spring Boot application to be a Web application.
@@ -98,7 +98,7 @@ Your selections should look similar to:
image::{images-dir}/spring-initializer-screenshot.png[]
Be sure to click the "*+*" button next to the "_Spring for Apache Geode_" dependency to select and add it to
Be sure to click the "*+*" button next to the "_Spring for {geode-name}_" dependency to select and add it to
the generated project Maven POM file.
You can explore the contents of the generated project by pressing the `CTRL+SPACE` keys:
@@ -112,7 +112,7 @@ Download the ZIP file and unpack it to your desired working directory.
You can then use your favorite IDE (e.g. https://www.jetbrains.com/idea/[IntelliJ IDEA]
or https://spring.io/tools[Spring Tool Suite] (STS)) to open the generated project.
You are ready to begin developing your Spring Boot, Apache Geode `ClientCache` application.
You are ready to begin developing your Spring Boot, {geode-name} `ClientCache` application.
[[about-versions]]
.Versions
@@ -151,10 +151,10 @@ public class CrmApplication {
}
----
Additionally, in the project Maven POM file, we see the "_Spring Boot for Apache Geode_" (SBDG) dependency
Additionally, in the project Maven POM file, we see the "_Spring Boot for {geode-name}_" (SBDG) dependency
(`org.springframework.geode:spring-geode-starter)`:
.Spring Boot for Apache Geode dependency
.Spring Boot for {geode-name} dependency
[source,xml]
[subs="verbatim,attributes"]
----
@@ -164,9 +164,9 @@ Additionally, in the project Maven POM file, we see the "_Spring Boot for Apache
</dependency>
----
With the _Spring Boot for Apache Geode_ dependency (i.e. `org.springframework.geode:spring-geode-starter`)
With the _Spring Boot for {geode-name}_ dependency (i.e. `org.springframework.geode:spring-geode-starter`)
on the application classpath along with the main Java class being a proper Spring Boot application, this application
will startup and run as an Apache Geode `ClientCache` application:
will startup and run as an {geode-name} `ClientCache` application:
.Application log output
[source,txt]
@@ -634,17 +634,17 @@ Process finished with exit code 0
----
First, you see the JVM bootstrap Spring Boot, which in turn runs our `CrmApplication` and also auto-configures
and bootstraps an Apache Geode `ClientCache` instance. Most of the output comes from Apache Geode.
and bootstraps an {geode-name} `ClientCache` instance. Most of the output comes from {geode-name}.
The application falls straight through because it is not doing anything interesting, and technically, because there are
no non-daemon Threads (e.g. Socket Thread listening on HTTP port 8080 in the case of Web applications running
an embedded Servlet Container like Apache Tomcat) that prevents the "main" Java Thread from exiting immediately.
[[spring-geode-samples-getting-started-build-app]]
== Build a Spring Boot, Apache Geode `ClientCache` application
== Build a Spring Boot, {geode-name} `ClientCache` application
Our Spring Boot application is a simple _Customer Relationship Management_ (CRM) application that allows users
to persist `Customer` data in Apache Geode and lookup `Customers` by name.
to persist `Customer` data in {geode-name} and lookup `Customers` by name.
[[spring-geode-samples-getting-started-build-app-model]]
=== `Customer` class
@@ -660,15 +660,15 @@ include::{samples-dir}/intro/getting-started/src/main/java/example/app/crm/model
The CRM application defines a `Customer` in terms of an identifier (i.e. `Long id`) and a name (i.e. `String name`).
Both fields are required.
Additionally, we map `Customer` objects to the "_/Customers_" Region using Spring Data for Apache Geode's (SDG)
Additionally, we map `Customer` objects to the "_/Customers_" Region using Spring Data for {geode-name}'s (SDG)
{spring-data-geode-javadoc}/org/springframework/data/gemfire/mapping/annotation/Region.html[`@Region`] annotation.
The `@Region` annotation tells Spring Data where to persist and access `Customer` objects in Apache Geode. It is
The `@Region` annotation tells Spring Data where to persist and access `Customer` objects in {geode-name}. It is
basically equivalent to JPA's `@javax.persistence.Table` annotation.
Additionally, we annotate the `Long id` field with Spring Data's `@org.springframework.data.annotation.Id` annotation.
This designates the `id` field as the identifier, or in Apache Geode's case, the "key" since a Region is a key/value
store. In fact, Apache Geode's {apache-geode-javadoc}/org/apache/geode/cache/Region.html[`Region`] interface
This designates the `id` field as the identifier, or in {geode-name}'s case, the "key" since a Region is a key/value
store. In fact, {geode-name}'s {apache-geode-javadoc}/org/apache/geode/cache/Region.html[`Region`] interface
implements the `java.uti.Map` interface making it a `Map` data structure.
We use https://projectlombok.org/[Project Lombok] to simply the implementation of the `Customer` class.
@@ -683,7 +683,7 @@ subjective topic on whether to use Lombok in production code. We have no opinio
=== `CustomerRepository` interface
Now that we have defined a basic model for managing customer data, we can create a Spring Data `CrudRepository` used by
our application to persist `Customer` objects to Apache Geode. This same _Repository_ can be used to lookup, or query
our application to persist `Customer` objects to {geode-name}. This same _Repository_ can be used to lookup, or query
`Customers` by name.
.`CustomerRepository` interface
@@ -697,7 +697,7 @@ that enables an application to perform basic CRUD (i.e. CREATE, READ, UPDATE, DE
data access operations on a persistent entity (e.g. `Customer`).
TIP: Review the Spring Data Commons Reference Guide for more details on {spring-data-commons-docs}/#repositories[Working with Spring Data Repositories]
and Spring Data for Apache Geode's (SDG) {spring-data-geode-docs}/#gemfire-repositories[extension and implementation]
and Spring Data for {geode-name}'s (SDG) {spring-data-geode-docs}/#gemfire-repositories[extension and implementation]
of Spring Data Commons Repository Abstraction.
[[spring-geode-samples-getting-started-build-app-controller]]
@@ -731,7 +731,7 @@ for accessing the CRM application via a Web client (e.g. Web browser).
|===
NOTE: If you did not enable the Web components by adding the Spring Web dependency to your application classpath, then
no worries, we will still be inspecting the application's effects on Apache Geode using _Gfsh_ (Apache Geode & Pivotal
no worries, we will still be inspecting the application's effects on {geode-name} using _Gfsh_ ({geode-name} & Pivotal
GemFire's shell tool). Of course, you can just add the `org.springframework.boot:spring-boot-starter-web` dependency
to your Maven POM file as well.
@@ -755,7 +755,7 @@ responsibility as the application developer. One example is Region configuratio
There are many ways to configure a Region and it varies significantly from application Use Case to application Use Case.
First, there are different data management policies (e.g. `PARTITION` or `REPLICATE`) that might be applicable depending
on the type of data you store in Apache Geode (e.g. Transactional vs. Reference data). You might need different
on the type of data you store in {geode-name} (e.g. Transactional vs. Reference data). You might need different
Eviction and Expiration policies depending on your user base or workloads. Some data is suited for Off-Heap memory.
Depending on the data management policy of the Region (e.g. `PARTITION`) you can configure additional per node and total
Region memory usage restrictions, collocate the Region with another Region for use in JOIN Queries, etc.
@@ -765,7 +765,7 @@ especially during development. So, while SBDG may not provide implicit _auto-co
this does not mean you are left to figure it all out by yourself (e.g. Region configuration).
During development, if you don't care specifically "_how_" your data is stored and you just want to simply and rapidly
iterate, putting and getting data into and out of Apache Geode, then SBDG can help.
iterate, putting and getting data into and out of {geode-name}, then SBDG can help.
The first thing we will do is annotate our application configuration with SDG's `@EnableEntityDefinedRegions` annotation
and set the `basePackageClasses` attribute to our `Customer` class:
@@ -822,12 +822,12 @@ You can also use Spring XML:
==== Configure the Application to be Cluster-Aware
The final bit of configuration helps determine whether the client application is by itself or whether a cluster of
Apache Geode servers are available to manage the application's data.
{geode-name} servers are available to manage the application's data.
During development, you might be iteratively and rapidly developing inside your IDE, debugging and testing new functions
locally and then switch to a client/server environment for further integration testing.
Apache Geode requires 1) all client Regions that send data to/from the cluster be `*PROXY` Regions and 2) that a
{geode-name} requires 1) all client Regions that send data to/from the cluster be `*PROXY` Regions and 2) that a
server-side Region by the same name exists in the cluster.
Switching the data management policy for all client Regions' from `*PROXY` to `LOCAL` when pulling your application code
@@ -887,7 +887,7 @@ to our main `@SpringBootApplication` class:
include::{samples-dir}/intro/getting-started/src/main/java/example/app/crm/CrmApplication.java[tags=runner]
----
The runner creates a new `Customer` "_JonDoe_", persists "_JonDoe_" to Apache Geode in the "_/Customers_" client `LOCAL`
The runner creates a new `Customer` "_JonDoe_", persists "_JonDoe_" to {geode-name} in the "_/Customers_" client `LOCAL`
Region, runs an OQL query to lookup "_JonDoe_" by name using a wildcard query with the LIKE operator and argument
"_%Doe_", then asserts that the result is correct.
@@ -942,7 +942,7 @@ Customer was [Customer(name=JonDoe)]
SBDG, with the help of `@EnableEntityDefinedRegions` and `@EnableClusterAware`, along with Spring Data, has already done
quite a bit of work for us:
1. SBDG _auto-configured_ a `ClientCache` instance required to use Apache Geode in the application.
1. SBDG _auto-configured_ a `ClientCache` instance required to use {geode-name} in the application.
2. The `@EnableEntityDefinedRegion` annotation created the required "_/Customers_" client Region from our `Customer`
entity class.
3. SBDG _auto-configured_ the Spring Data Repository infrastructure and supplied an implementation for
@@ -1019,21 +1019,21 @@ image::{images-dir}/customer-service-application-jondoe.png[]
[[spring-geode-samples-getting-started-run-app-clientserver]]
== Run the Application in a Client/Server Topology
Now that we have a simple Spring Boot, Apache Geode `ClientCache` application running locally inside our IDE, we want to
Now that we have a simple Spring Boot, {geode-name} `ClientCache` application running locally inside our IDE, we want to
expand on this bit and switch to a client/server topology.
Although we are not quite ready to move to a managed cloud platform environment, like _Pivotal Platform_ (formerly
known as _Pivotal CloudFoundry_) using _Pivotal Cloud Cache_ (PCC), we no longer want to maintain the data locally.
known as _Pivotal CloudFoundry_) using _{cloudcache-name}_ (PCC), we no longer want to maintain the data locally.
Without persistence, we would lose all our data if the client application were shutdown since the data is maintained
in-memory. Additionally, by maintaining the data locally, other client applications, or even other instances of our
existing application (e.g. in a Microservices landscape) would not be able to use this data, which is useless!
To switch to a client/server topology, we need to first configure and bootstrap an Apache Geode cluster.
To switch to a client/server topology, we need to first configure and bootstrap an {geode-name} cluster.
The Example Code for this Guide already provides the necessary Geode shell script (_Gfsh_) to start a cluster:
.Gfsh shell script to start an Apache Geode cluster
.Gfsh shell script to start an {geode-name} cluster
[source,txt]
----
include::{samples-dir}/intro/getting-started/src/main/resources/geode/bin/start-cluster.gfsh[]
@@ -1049,7 +1049,7 @@ gfsh> run --file=@SBDG_HOME@/spring-geode-samples/intro/getting-started/src/main
NOTE: Be sure to change the `@SBDG_HOME@` placeholder variable with the location of your cloned copy of SBDG.
The _Gfsh_ shell script starts an Apache Geode cluster with 1 _Locator_ and 2 _Servers_.
The _Gfsh_ shell script starts an {geode-name} cluster with 1 _Locator_ and 2 _Servers_.
The output from the shell script will look similar to:
@@ -1256,7 +1256,7 @@ the best data management policy and organization for transactional data. The "_
on our 2 _Servers_, "ServerOne" and "ServerTwo".
WARNING: You must have redundancy (and optionally, persistence) configured in your cluster to prevent (complete)
data loss, which forms the basis for high-availability (HA) in Apache Geode and Pivotal Cloud Cache (PCC).
data loss, which forms the basis for high-availability (HA) in {geode-name} and {cloudcache-name} (PCC).
We can query "_JonDoe_" from _Gfsh_:
@@ -1348,10 +1348,10 @@ Once again, SBDG is providing you with tremendous power and convenience that you
While there are very apparent things happening, there are also a few non-apparent things happening as well.
In addition to the aforementioned things in the last section, we are now benefiting from:
1. SBDG appropriately configured and relied on Apache Geode internal features to connect the client to the cluster.
1. SBDG appropriately configured and relied on {geode-name} internal features to connect the client to the cluster.
2. Configuration metadata for our application's required client Regions (e.g. "_/Customers_") was sent to the cluster
and created on the servers to leverage the client/server topology.
3. SBDG _auto-configured_ PDX, Apache Geode's highly powerful Serialization framework and alternative to
3. SBDG _auto-configured_ PDX, {geode-name}'s highly powerful Serialization framework and alternative to
_Java Serialization_.
Once we migrate to a managed cloud platform environment, we'll see the full effects of SBDG's _auto-configuration_
@@ -1361,14 +1361,14 @@ at play.
*****
Anytime you need to send data over the network, persist or overflow data to disk, your objects need to be serializable.
SBDG employs Apache Geode's {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX Serialization]
SBDG employs {geode-name}'s {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX Serialization]
framework so your application entity classes do not need to implement `java.io.Serializable`. In other cases,
implementing `java.io.Serializable` may not even be possible if your application domain types are composed of types
from 3rd party libraries for which you have no control over.
Perhaps you don't want to use _Java Serialization_ given the inherit overhead of the _Java Serialization_ format.
In any case, using Apache Geode PDX Serialization is ideal if you have large number of objects forming a complex graph
In any case, using {geode-name} PDX Serialization is ideal if you have large number of objects forming a complex graph
where missing a type that needs to be serialized is easy to do. PDX allows you to query data in serialized form
and even allows non-Java clients (e.g. native clients written in C#/C++) to access the same data.
@@ -1491,7 +1491,7 @@ gfsh> create region --name=Example --type=PARTITION ...
While this can be scripted and the script can be checked into source control (a definitive plus) the same as
the application code, you sill need to create matching Regions on the client, for which there is no assistance
provided by Apache Geode or Pivotal Cloud Cache.
provided by {geode-name} or {cloudcache-name}.
This is why `@EnableClusterAware` will help you be much more productive during development. After you are ready to
promote the application to the next environment, it is a simple matter to {apache-geode-docs}/tools_modules/gfsh/command-pages/export.html#topic_mdv_jgz_ck[export]
@@ -1508,16 +1508,16 @@ Again, this is highly recommended in practice.
== Run the Application in a Cloud Platform Environment
Now that we have built and ran our application locally as well as in a client/server topology, we are ready to push
the application to a managed cloud platform environment, like _Pivotal Platform_ using _Pivotal Cloud Cache_ (PCC).
the application to a managed cloud platform environment, like _Pivotal Platform_ using _{cloudcache-name}_ (PCC).
This is the final step in our journey to the cloud and SBDG makes this a non-event!
While SBDG handles most application development concerns, _Pivotal Cloud Cache_ (PCC), in conjunction with
While SBDG handles most application development concerns, _{cloudcache-name}_ (PCC), in conjunction with
_Pivotal Platform_, handles most operational concerns.
.Using Pivotal Platform
*****
To deploy this application to _Pivotal Platform_ and use _Pivotal Cloud Cache_ (PCC), you will need access to
To deploy this application to _Pivotal Platform_ and use _{cloudcache-name}_ (PCC), you will need access to
a _Pivotal Platform_ environment (e.g. PWS) with the PCC tile installed.
Please see https://run.pivotal.io/[Pivotal Web Services] (PWS) website for more details on how to get started.
@@ -1530,10 +1530,10 @@ See link:../index.html#cloudfoundry-geode[Hybrid Cloud Environments] for more de
Once you have acquired a _Pivotal Platform_ environment and installed the required tools (e.g. CF CLI), then you can
package the application and deploy (i.e. "_push_") it to _Pivotal Platform_.
Before we package the application, we must switch the "_Spring (Boot) for Apache Geode_" dependency in our application
Before we package the application, we must switch the "_Spring (Boot) for {geode-name}_" dependency in our application
Maven POM file from:
.Spring Boot for Apache Geode dependency
.Spring Boot for {geode-name} dependency
[source,xml]
[subs="verbatim,attributes"]
----
@@ -1546,7 +1546,7 @@ Maven POM file from:
To:
.Spring Boot for Pivotal GemFire (a.k.a. Pivotal Cloud Cache (PCC)) dependency
.Spring Boot for {gemfire-name} (a.k.a. {cloudcache-name} (PCC)) dependency
[source,xml]
[subs="verbatim,attributes"]
----
@@ -1594,23 +1594,23 @@ is the server-side.
.Acquiring {cloudcache-name} Bits
*****
In order to acquire the Pivotal Cloud Cache (PCC) / Pivotal GemFire bits used by your Spring Boot application, you must
In order to acquire the {cloudcache-name} (PCC) / {gemfire-name} bits used by your Spring Boot application, you must
sign up and register on https://network.pivotal.io/[Pivotal Network] (a.k.a. "_PivNet_").
This should include instructions on how to configure your application Maven POM file with the necessary `<repository>`
declaration for acquiring the _Pivotal Cloud Cache_ / Pivotal GemFire bits pulled in by the
declaration for acquiring the _{cloudcache-name}_ / {gemfire-name} bits pulled in by the
`org.springframework.geode:spring-gemfire-starter` SBDG application dependency as well as the necessary settings in
`~/.m2/settings.xml` to authenticate and access the Pivotal Commercial Repository server.
This is absolutely necessary since Pivotal Cloud Cache (PCC) / Pivotal GemFire bits are not available in _Maven Central_.
This is absolutely necessary since {cloudcache-name} (PCC) / {gemfire-name} bits are not available in _Maven Central_.
You can also find more details on acquiring the bits in the Pivotal GemFire
You can also find more details on acquiring the bits in the {gemfire-name}
https://gemfire.docs.pivotal.io/{pivotal-gemfire-version}/gemfire/getting_started/installation/obtain_gemfire_maven.html[documentation].
*****
.Required Spring Boot Actuator Bits
*****
As of Apache Geode 1.9 and Pivotal GemFire 9.8, upon which Pivotal Cloud Cache (PCC) 1.8 is {pivotal-cloudcache-docs}/product-snapshot.html[based],
As of {geode-name} 1.9 and {gemfire-name} 9.8, upon which {cloudcache-name} (PCC) 1.8 is {pivotal-cloudcache-docs}/product-snapshot.html[based],
both GemFire and Geode require and declare Micrometer on the classpath as a compile-time dependency.
Technically, the Micrometer bits are pulled in by `org.apache.geode:geode-core:1.9.0` and the Micrometer version
@@ -1626,7 +1626,7 @@ is determined by the version of Spring Boot you are using:
As of this writing, due to an https://github.com/cloudfoundry/java-buildpack-metric-writer/issues/6[Issue]
in the _Java buildpack_ for CloudFoundry, you are also required to put Spring Boot Actuator on the classpath
for your Spring Boot application using Apache Geode or PCC:
for your Spring Boot application using {geode-name} or PCC:
.Declaring Spring Boot Actuator on the application classpath
[source.xml]
@@ -1655,7 +1655,7 @@ OUT at o.s.c.a.TypeMappedAnnotation.getValue(TypeMappedAnnotation.java:403)
...
----
On the other hand, if you try to exclude Micrometer from the Apache Geode or PCC dependency, for example:
On the other hand, if you try to exclude Micrometer from the {geode-name} or PCC dependency, for example:
.Excluding the Micrometer dependency from `spring-gemfire-starter`
[source,txt]
@@ -1675,9 +1675,9 @@ On the other hand, if you try to exclude Micrometer from the Apache Geode or PCC
----
Then, you will get past the _Java buildpack_ Exception, but you will encounter another Exception when Spring Boot
tries to bootstrap Apache Geode on startup:
tries to bootstrap {geode-name} on startup:
.Exception in Apache Geode
.Exception in {geode-name}
[source,txt]
----
[OUT] Caused by: java.lang.NoClassDefFoundError: io/micrometer/core/instrument/MeterRegistry
@@ -1685,7 +1685,7 @@ tries to bootstrap Apache Geode on startup:
----
Therefore, you must include Spring Boot Actuator on your Spring Boot application classpath when deploying
to Pivotal Platform and using Pivotal Cloud Cache (PCC). Again, the easiest way to do that is include the
to Pivotal Platform and using {cloudcache-name} (PCC). Again, the easiest way to do that is include the
`org.springframework.geode:spring-gemfire-starter-actuator` dependency on your application classpath.
*****
@@ -1874,12 +1874,12 @@ Again, we see the "_crm-app_". You can click on the app name and drill in to ge
image::{images-dir}/pvtl-appsmanager-org-space-apps-crm-app-overview.png[]
If you click on "_Service (1)_" in the left navigation bar, you will see that the "_crm-app_" is bound to
the "_pccServiceOne_" Pivotal Cloud Cache service instance:
the "_pccServiceOne_" {cloudcache-name} service instance:
image::{images-dir}/pvtl-appsmanager-org-space-apps-crm-app-service.png[]
If you click on "_Settings_" in the left navigation bar and "REVEAL ENV VARS" you will find the "_Gfsh login string_"
that you can use to connect to the Pivotal Cloud Cache cluster using _Gfsh_ from your local development environment:
that you can use to connect to the {cloudcache-name} cluster using _Gfsh_ from your local development environment:
image::{images-dir}/pvtl-appsmanager-org-space-apps-crm-app-settings.png[]
@@ -1993,13 +1993,13 @@ id | name
1 | JonDoe
----
You successfully deployed the CRM, Spring Boot Apache Geode/Pivotal Cloud Cache `ClientCache` application to the cloud!
You successfully deployed the CRM, Spring Boot {geode-name}/{cloudcache-name} `ClientCache` application to the cloud!
In this final incarnation of our CRM, Spring Boot application, SBDG yet again handled many different concerns for us
so we did not need to. This is in addition to all the things mentioned above when running the application locally
as well as running the application using a client/server topology. Now, we also benefit from:
1. SBDG figures out the connection criteria needed to connect your client to the servers in the Pivotal Cloud Cache
1. SBDG figures out the connection criteria needed to connect your client to the servers in the {cloudcache-name}
(PCC) cluster, which is technically extracted from the VCAP environment. SBDG will connect the Spring Boot app to
the PCC Locators.
2. SBDG automatically authenticates your Spring Boot app with the PCC cluster providing your app was correctly bound to
@@ -2020,10 +2020,10 @@ specifically cover the details of doing so in this guide.
Running in a Hybrid Cloud Environment specifically means deploying your CRM, Spring Boot `ClientCache` application to
a managed cloud platform environment, such as Pivotal Platform, but connect the app to an externally managed
Apache Geode or Pivotal GemFire cluster, i.e. the GemFire/Geode cluster is running and managed off platform.
{geode-name} or {gemfire-name} cluster, i.e. the GemFire/Geode cluster is running and managed off platform.
NOTE: As of this writing, the inverse is also being explored, running your Spring Boot applications off platform,
but connecting those apps to managed data services (e.g. Pivotal Cloud Cache (PCC)) on platform.
but connecting those apps to managed data services (e.g. {cloudcache-name} (PCC)) on platform.
There may be cases where you are unable to move your data management architecture for your applications entirely to
the cloud. In those cases, SBDG supports a Hybrid Cloud Architecture, that is both an on-prem and off-prem arrangement.
@@ -2036,10 +2036,10 @@ link:../index.html#cloudfoundry-geode[here].
[[spring-geode-samples-getting-started-summary]]
== Summary
In this guide, we saw first-hand the power of Spring Boot for Apache Geode (SBDG) when building Apache Geode powered
In this guide, we saw first-hand the power of Spring Boot for {geode-name} (SBDG) when building {geode-name} powered
Spring Boot applications.
Apache Geode can truly make your Spring Boot applications highly resilient to failures, highly available, performant
{geode-name} can truly make your Spring Boot applications highly resilient to failures, highly available, performant
(i.e. high throughput and low latency), without sacrificing consistency, which is paramount to any data intensive
application.
@@ -2047,7 +2047,7 @@ SBDG handles a lot of low-level application concerns so you do not have to. You
can remain on building the application to meet your customers' needs, collect feedback, iterate rapidly, and realize
the value proposition sooner.
Indeed, our intended goal is to make developing Apache Geode applications with Spring, and Spring Boot in particular,
Indeed, our intended goal is to make developing {geode-name} applications with Spring, and Spring Boot in particular,
a highly productive and enjoyable experience.
We hope you enjoy!

2
spring-geode-docs/src/docs/asciidoc/index-docinfo.xml
View File

@@ -1,4 +1,4 @@
<productname>Spring Boot for Apache Geode &amp; Pivotal GemFire</productname>
<productname>Spring Boot for Apache Geode &amp; VMware Tanzu GemFire</productname>
<releaseinfo>{spring-boot-data-geode-version}</releaseinfo>
<copyright>
<year>2020</year>

7
spring-geode-docs/src/docs/asciidoc/index.adoc
View File

@@ -1,5 +1,5 @@
[[spring-boot-data-geode]]
= Spring Boot for Apache Geode & Pivotal GemFire Reference Guide
= Spring Boot for Apache Geode & VMware Tanzu GemFire Reference Guide
John Blum
:revdate: {localdate}
:revnumber: {version}
@@ -19,6 +19,7 @@ John Blum
:apache-geode-javadoc: https://geode.apache.org/releases/latest/javadoc
:apache-geode-website: https://geode.apache.org/
:apache-geode-wiki: https://cwiki.apache.org/confluence/display/GEODE
:pivotal-cloudcache-name: VMware Tanzu GemFire for VMs
:pivotal-cloudcache-version: {pivotal-cloudcache-doc-version}
:pivotal-cloudcache-docs: https://docs.pivotal.io/p-cloud-cache/{pivotal-cloudcache-version}
:pivotal-cloudcache-website: https://pivotal.io/pivotal-cloud-cache
@@ -259,7 +260,3 @@ include::{include-dir}/cloudfoundry.adoc[]
include::{include-dir}/docker.adoc[]
include::{include-dir}/samples.adoc[]
include::{include-dir}/appendix.adoc[]

2
spring-geode-docs/src/main/java/org/springframework/geode/docs/example/app/locator/SpringBootApacheGeodeLocatorApplication.java
View File

@@ -30,7 +30,7 @@ import org.springframework.geode.config.annotation.UseLocators;
/**
* The {@link SpringBootApacheGeodeLocatorApplication} class is a Spring Boot application that configures and bootstraps
* an Apache Geode or Pivotal GemFire {@link Locator} application JVM process.
* an Apache Geode {@link Locator} application JVM process.
*
* @author John Blum
* @see org.apache.geode.distributed.Locator

2
spring-geode-samples/boot/configuration/src/main/resources/application-security.properties
View File

@@ -1,4 +1,4 @@
# Security Configuration for Apache Geode/Pivotal GemFire using Spring Boot and Spring Data GemFire properties
# Security Configuration for Apache Geode using Spring Boot and Spring Data for Apache Geode properties
spring.boot.data.gemfire.security.ssl.keystore.name=example-trusted-keystore.jks
spring.data.gemfire.security.username=test

2
spring-geode-samples/boot/configuration/src/main/resources/application.properties
View File

@@ -1,4 +1,4 @@
# Configuration for Apache Geode/Pivotal GemFire using Spring Boot and Spring Data GemFire properties
# Configuration for Apache Geode using Spring Boot and Spring Data for Apache Geode properties
spring.application.name=CustomerServiceApplication
spring.data.gemfire.cache.log-level=error

2
spring-geode/src/main/java/org/springframework/geode/cache/support/CacheWriterSupport.java vendored
View File

@@ -21,7 +21,7 @@ import org.apache.geode.cache.EntryEvent;
import org.apache.geode.cache.RegionEvent;
/**
* Class supporting the implementation of Apache Geode / Pivotal GemFire (PCC) {@link CacheWriter CacheWriters}.
* Class supporting the implementation of Apache Geode {@link CacheWriter CacheWriters}.
*
* @author John Blum
* @see org.apache.geode.cache.CacheWriter

2
spring-geode/src/main/java/org/springframework/geode/cache/support/RepositoryCacheLoaderWriterSupport.java vendored
View File

@@ -34,7 +34,7 @@ import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* Abstract base class supporting the implementation of Apache Geode / Pivotal GemFire {@link CacheLoader CacheLoaders}
* Abstract base class supporting the implementation of Apache Geode {@link CacheLoader CacheLoaders}
* and {@link CacheWriter CacheWriters} backed by Spring Data {@link Repository Repositories}.
*
* @author John Blum

2
spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterAvailableConfiguration.java
View File

@@ -24,7 +24,7 @@ import org.springframework.data.gemfire.config.annotation.EnableClusterConfigura
/**
* The {@link ClusterAvailableConfiguration} class is a Spring {@link Configuration @Configuration} class that enables
* configuration when an Apache Geode or Pivotal GemFire cluster of servers are available.
* configuration when an Apache Geode cluster of servers are available.
*
* @author John Blum
* @see org.springframework.boot.autoconfigure.condition.AnyNestedCondition

2
spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfiguration.java
View File

@@ -39,7 +39,7 @@ import org.springframework.lang.Nullable;
/**
* The {@link ClusterNotAvailableConfiguration} class is a Spring {@link Configuration @Configuration} class that
* enables configuration when an Apache Geode or Pivotal GemFire cluster of servers is not available.
* enables configuration when an Apache Geode cluster of servers is not available.
*
* @author John Blum
* @see org.springframework.beans.factory.config.BeanPostProcessor

5
spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableClusterAware.java
View File

@@ -25,9 +25,8 @@ import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;
/**
* The {@link EnableClusterAware} helps an Spring Boot application using Apache Geode (or Pivotal GemFire
* / Pivotal Cloud Cache (PCC)) decide whether it needs to operate in {@literal local-only mode}
* or {@literal client/server}.
* The {@link EnableClusterAware} helps an Spring Boot application using Apache Geode decide whether it needs to operate
* in {@literal local-only mode} or {@literal client/server}.
*
* @author John Blum
* @see java.lang.annotation.Annotation

2
spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManager.java
View File

@@ -26,7 +26,7 @@ import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;
/**
* Spring {@link Annotation} to enable Apache Geode or Pivotal GemFire (PCC) Security (Auth).
* Spring {@link Annotation} to enable Apache Geode Security (Auth).
*
* @author John Blum
* @see java.lang.annotation.Annotation

Some files were not shown because too many files have changed in this diff Show More