All Classes and Interfaces
Class
Description
An abstract base class encapsulating functionality common to all Spring Data for Apache Geode (SDG) annotations
and configuration classes used to configure Apache Geode objects using Spring Data for Apache Geode.
AbstractAnnotationConfigSupport.TypeResolver is a FunctionalInterface defining a contract to encapsulate logic
used to resolve a particular type.The
AbstractAuthInitialize class is an abstract support class and basic implementation
of the AuthInitialize interface used in the authentication of a client or peer
with a secure GemFire/Geode cluster.Abstract base class for
CacheFactoryBean and ClientCacheFactoryBean classes,
used to create Apache Geode peer Cache and ClientCache instances, respectively.Callback interface for initializing a
CacheFactory or a ClientCacheFactory instance,
which is used to create an instance of GemFireCache.Callback interface to configure PDX.
AbstractCacheConfiguration is an abstract base class for configuring either a Pivotal GemFire/Apache Geode
client or peer-based cache instance using Spring's Java-based, Annotation Configuration support.Thread-safe, abstract
CacheResolver implementation to "cache" the instance reference to the (single)
GemFireCache so that the GemFireCache object is only ever resolved once.RegionResolver implementation capable of caching the results of a Region resolution (lookup) operation.Abstract base class encapsulating functionality for (externally) configuring an Apache Geode
ClientCache
or peer Cache as a bean in the Spring context.The
AbstractDependencyStructuringBeanFactoryPostProcessor class is a Spring BeanFactoryPostProcessor
post processing the Spring BeanFactory to help ensure that the dependencies between different Apache Geode
or Pivotal GemFire objects (e.g.An abstract Spring
FactoryBean base class implementation encapsulating operations common to all
Spring Data for Apache Geode (SDG) FactoryBean implementations.Abstract base class and configuration source for Function Executions.
AbstractGemfireAdminOperations is an abstract base class encapsulating common functionality
supporting administrative (management) operations against a Pivotal GemFire or Apache Geode cluster.AbstractGemFireAsLastResourceAspectSupport is an abstract base class encapsulating functionality common
to all AOP Aspect extensions/implementations involving the Apache Geode JCA ResourceAdapter object registered in
the JNDI context of a managed environment.AbstractIndexSupport is an abstract base class supporting the implementation
of the Pivotal GemFire / Apache Geode Index interface.Abstract base class for
Configurer interface implementations, encapsulating logic and functionality
common to all lazy resolving, composable Configurer implementations.The
AbstractPageSupport class is an abstract Spring Data Page type supporting the implementation of
application specific Page implementations.Abstract Spring XML parser for peer
Region bean definitions.The
AbstractPropertyEditorConverterSupport class is an abstract base class for Spring Converter
implementations that also implement the JavaBeans PropertyEditor interface.Abstract base class encapsulating logic to resolve or create a
GemFireCache instance.An abstract base class implementation of Apache Geode's
SelectResults interface and Java Collection
interface, which delegates to, and is backed by a given, required SelectResults instance.The
AbstractSliceSupport class is an abstract Spring Data Slice type
supporting the implementation of application specific Slice implementations.AbstractSmartLifecycle is an abstract base class implementing the SpringSmartLifecycle interface
to support custom implementations.Abstract base class for WAN Gateway objects.
The
AddCacheServerConfiguration class is a Spring ImportBeanDefinitionRegistrar that registers
a CacheServerFactoryBean definition for the CacheServer
configuration meta-data defined in EnableCacheServer annotation.The
AddCacheServersConfiguration class registers CacheServerFactoryBean
bean definitions for all EnableCacheServer annotation configuration meta-data defined in
the EnableCacheServers annotation on a GemFire peer cache application class.The
AddPoolConfiguration class is a Spring ImportBeanDefinitionRegistrar that registers
a PoolFactoryBean definition for the Pool
configuration meta-data defined in EnablePool annotations.The
AddPoolsConfiguration class registers PoolFactoryBean
bean definitions for all EnablePool annotation configuration meta-data defined in
the EnablePools annotation on a GemFire client cache application class.The
AdministrativeConfiguration class is a Spring @Configuration class that registers
SDG Administrative Functions used by SDG's EnableClusterConfiguration without HTTP enabled.The
AnnotationBasedExpiration class is an implementation of the CustomExpiry interface
that determines the Time-To-Live (TTL) or Idle-Timeout (TTI) expiration policy of a Region entry
by introspecting the Region entry's class type and reflecting on any Region entries annotated
with SDG's Expiration-based Annotations.The ExpirationMetaData class encapsulates the settings constituting the expiration policy including
the expiration timeout and the action performed when expiration occurs.
Annotation based configuration source for
Function Executions.The
ApacheShiroSecurityConfiguration class is a Spring @Configuration component
responsible for configuring and initializing the Apache Shiro security framework in order to secure Apache Geode
administrative and data access operations.A Spring
Condition to determine whether the user has included (declared) the 'shiro-spring' dependency
on their application's classpath, which is necessary for configuring Apache Shiro to secure Apache Geode
in a Spring context.ArrayUtils is an abstract utility class used to work with Object arrays.ASM based
InstantiatorGenerator implementation.Spring
FactoryBean for constructing, configuring and initializing AsyncEventQueues.The
AuthConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration using Pivotal GemFire/Apache Geode Properties to configure
Pivotal GemFire/Apache Geode Authentication and Authorization framework and services.The
AutoConfiguredAuthenticationConfiguration class is a Spring @Configuration class
that auto-configures Pivotal GemFire / Apache Geode Authentication by providing a implementation
of the AuthInitialize interface along with setting the necessary GemFire / Geode
properties.The
AutoConfiguredAuthenticationInitializer class is an AuthInitialize implementation,
which auto-configures security, and specifically authentication, for Apache Geode/Pivotal GemFire.The
AutoRegionLookupBeanPostProcessor class is a Spring BeanPostProcessor that post processes
a GemFireCache by registering all cache Regions that have not been explicitly defined
in the Spring application context.The
AutoRegionLookupConfiguration class is a Spring ImportBeanDefinitionRegistrar that enables
the automatic lookup of GemFire Regions, which may have been defined else where, such as in cache.xml
or using GemFire's Cluster Configuration Service.The
BeanDefinitionRegistryPostProcessorSupport is an abstract class supporting the implementation
of the Spring BeanDefinitionRegistryPostProcessor interface.Cacheable
CacheResolver implementation capable of resolving a GemFireCache instance
from the Spring BeanFactory.The
BeanFactoryLocatorConfiguration class extends the Spring application configuration by enabling
Spring Data GemFire/Geode's GemfireBeanFactoryLocator in order to auto-wire and configure any
GemFire/Geode Objects declared in GemFire/Geode config (e.g.Spring
FactoryBean used to construct, configure and initialize a peer Cache instance.Strategy interface for resolving a instance reference to a
GemFireCache.The CacheServerApplication annotation enables an embedded GemFire
CacheServer instance in a Spring Data GemFire based application.Spring
Configuration class used to construct, configure and initialize a CacheServer instance
in a Spring application context.The
CacheServerConfigurer interface defines a contract for implementing Objects in order to
customize the configuration of a CacheServerFactoryBean used to construct, configure and initialize
an instance of CacheServer.Spring
FactoryBean used to construct, configure and initialize a CacheServer.The
CacheTypeAwareRegionFactoryBean class is a smart Spring FactoryBean that knows how to
create a client or server Region depending on whether the GemFireCache is a ClientCache
or a peer Cache.CacheUtils is an abstract utility class encapsulating common operations for working with
Cache and ClientCache instances.The
CachingDefinedRegionsConfiguration class is a Spring @Configuration class
that applies configuration to a Spring (Data GemFire/Geode) application to create GemFire/Geode cache
Regions based on the use of Spring's Cache Abstraction to enable caching for application
service classes and methods.CachingDefinedRegionsConfiguration.AbstractCacheNameResolver is an abstract base class encapsulating reusable functionality common
to all CachingDefinedRegionsConfiguration.CacheNameResolver implementations.CachingDefinedRegionsConfiguration.CacheNameResolver is a FunctionalInterface declaring a contract for all implementations
used to resolve all cache names declared and used by a Spring application.The
CallableCacheLoaderAdapter class is a Callable and GemFire CacheLoader implementation
that adapts the Callable interface into an instance of the CacheLoader interface.The
ClientCacheApplication annotation enables a Spring Data for Apache Geode based application
to become an Apache Geode cache client by creating a ClientCache instance.Spring
Configuration class used to construct, configure and initialize
a ClientCache instance in a Spring application context.The
ClientCacheConfigurer interface defines a contract for implementing Objects in order to
customize the configuration of a ClientCacheFactoryBean used to construct, configure and initialize
an instance of a ClientCache.PoolResolver implementation used to resolve the DEFAULT Pool from a ClientCache
instance by lazily resolving the ClientCache instance and calling ClientCache.getDefaultPool()
on DEFAULT Pool resolution.Spring
FactoryBean used to construct, configure and initialize a ClientCache.The ClientCachePoolBeanFactoryPostProcessor class...
Annotation defining the Client Region in which the application persistent entity will be stored.The
ClientRegionCollector class is an extension of the RegionCollector which applies additional
filtering to find only client Regions in a given context.Spring
FactoryBean used to construct, configure and initialize a client Region.ClientRegionPoolBeanFactoryPostProcessor is a Spring BeanFactoryPostProcessor implementation
ensuring a proper dependency is declared between a client Region and a client Pool it references
and uses, providing the client Pool has been defined and configured with Spring Data for Apache Geode
configuration metadata (e.g.The ClientRegionShortcutConverter class is a Spring Converter implementation converting String value Client Region
Shortcut representations into actual GemFire ClientRegionShortcut enumerated values.
The ClientRegionShortcutWrapper enum is a Java enumerated type that wraps GemFire's ClientRegionShortcuts
with Spring Data GemFire ClientRegionShortcutWrapper enumerated values.
Spring
@Configuration class defining Spring beans that will record the creation of
Apache Geode / Pivotal GemFire Regions defined in Spring config (i.e.The
ClusterDefinedRegionsConfiguration class configures client Proxy-based Regions
for all Regions defined in the cluster to which the cache client is connected.Abstract utility class used to operate on Java Collections Framework and classes.
Composition of
CacheResolvers using
the Composite Software Design Pattern that acts,
and can be referred to, as a single instance of CacheResolver.Composite of
PoolResolvers functioning as a single PoolResolver.RegionResolver implementation used to compose a collection of RegionResolvers.The
ComposableSchemaObjectCollector class is a SchemaObjectCollector implementation composed of
multiple SchemaObjectCollector objects wrapped in a facade and treated like a single
SchemaObjectCollector using the Composite Software Design Pattern.ComposableSchemaObjectDefiner is an implementation of SchemaObjectDefiner
as well as a composition of SchemaObjectInstanceHandlers composed
using the Composite Software Design Pattern.The ComposableSnapshotFilter class is a GemFire SnapshotFilter implementation of the Composition design pattern
allowing 2 or more SnapshotFilters to be combined by logical AND and OR operators acting as a single SnapshotFilter.
Operator is an enumeration of logical operators (AND, OR) used to compose SnapshotFilters
into a boolean expression.
An implementation of Apache Geode's
TransactionWriter interface that uses the Composite Software Design
Pattern to compose multiple TransactionWriter objects into a single instance.A Spring
TypeFilter implementation using the Composite Software Design Pattern to compose multiple
TypeFilters acting a single instance of TypeFilter.The
CompressionConfiguration class is a Spring ImportAware implementation capable of
enabling Pivotal GemFire/Apache Geode cache Regions data compression.ConfigurableRegionFactoryBean is an abstract base class encapsulating functionality common
to all configurable Region FactoryBeans.The
Configurer interface defines a contract for implementing objects that can modify some aspect
of configuration given a reference to the Spring component responsible for the configuration of some
Apache Geode or Pivotal GemFire Object declared as a bean in the Spring container.The ConnectionEndpoint class models a GemFire connection endpoint in the format of hostname[portnumber],
where hostname is the network name or IP address of the host.
The
ContinuousQuery annotation to define a GemFire/Geode Continuous Query (CQ) on a POJO method
which handles all CQ events and errors.The
ContinuousQueryConfiguration class is a Spring @Configuration class enabling
Continuous Query (CQ) Pivotal GemFire/Apache Geode capabilities in this cache client application.Class type for defining a
CqQuery.Continuous Query (CQ) listener listening for events and notifications by a GemFire Continuous Query (CQ).
Event listener adapter that delegates the handling of messages to target listener methods via reflection,
with flexible event type conversion.
Container providing asynchronous processing/handling for Apache Geode Continuous Queries (CQ).
The
ContinuousQueryListenerContainerConfigurer interfaces defines a contract for implementing Objects
in order to customize the configuration of a ContinuousQueryListenerContainer when enabling Continuous Query
(CQ) functionality in a Spring Boot, Apache Geode/Pivotal GemFire ClientCache applications.The CreateIndexFunction class...
The CreateRegionFunction class...
CustomEditorBeanFactoryPostProcessor is a Spring BeanFactoryPostProcessor implementation
used to register custom PropertyEditors / Spring Converters
that are used to perform type conversions between String-based configuration metadata
and actual Apache Geode or Spring Data for Apache Geode defined (enumerated) types.The DataPolicyConverter class converts String values into GemFire DataPolicy enumerated values.
Convenience class for Spring aware, Apache Geode
Declarable components.The
DefaultableDelegatingPoolAdapter class is a wrapper class around Pool
allowing default configuration property values to be provided in the case that the Pool's
settings were null.Implementation of
GemfireEntityInformation and Spring Data's PersistentEntityInformation
that returns the Region name associated with the PersistentEntity.DefinedIndexesApplicationListener is a Spring ApplicationListener used to create all
"defined" GemFire Indexes by using the QueryService,
defineXxxIndex(..) methods.DelegatingPoolAdapter is an abstract implementation of GemFire's Pool interface and extension of
FactoryDefaultsPoolAdapter that delegates operations to the provided Pool instance.Spring
ApplicationContextInitializer implementation that disables the Spring container's
(ConfigurableApplicationContext) default behavior of bean definition overriding.The
DiskStoreConfiguration class is a Spring ImportBeanDefinitionRegistrar used to register
a GemFire/Geode DiskStore bean definition.The
DiskStoreConfigurer interface defines a contract for implementing Objects in order to
customize the configuration of a DiskStoreFactoryBean used to construct, configure and initialize
a DiskStore.The
DiskStoreDirectoryBeanPostProcessor processes any GemFire DiskStore,
DiskStoreFactoryBean.DiskDir Spring beans defined in the application context to ensure that the directory actually exists
before creating the DiskStore.Spring
FactoryBean used to create a DiskStore.The
DiskStoresConfiguration class is a Spring ImportBeanDefinitionRegistrar
used to register multiple GemFire/Geode DiskStore bean definitions.DistributedSystemUtils is an abstract utility class for working with the GemFire DistributedSystem.
An abstract base class supporting the configuration of Apache Geode embedded services.
Spring
BeanPostProcessor used to process before initialization Pivotal GemFire or Apache Geode
Properties defined as a bean in the Spring application context.The
EmptySlice class is an implementation of an empty Spring Data Slice.The
EnableAuth annotation marks a Spring @Configuration annotated Class
to configure and enable Pivotal GemFire/Apache Geode's Authentication and Authorization framework and services.The
EnableAutoRegionLookup annotation configures a Spring Configuration annotated class
with the ability to automatically look up and register any Apache Geode or Pivotal GemFire Regions
which may have be defined in cache.xml or by using the Cluster Configuration Service.The
EnableBeanFactoryLocator annotation annotates a Spring @Configuration class
enabling SDG's GemfireBeanFactoryLocator in order to auto-wire and configure GemFire/Geode Objects
declared in GemFire/Geode config.The
EnableCacheServer annotation configures a Spring Configuration
annotated class with a GemFire CacheServer bean in the Spring application context.The
EnableCacheServers annotation enables 1 or more CacheServers
to be defined and used in a peer cache application configured with Spring (Data GemFire/Geode).The
EnableCachingDefinedRegions annotation marks a Spring @Configuration application
annotated class to enable the creation of GemFire/Geode Regions based on Spring's Cache Abstraction
Annotations applied to application service methods and types.The
EnableClusterConfiguration annotation enables Apache Geode / Pivotal GemFire schema object definitions
defined in a Spring [Boot], Apache Geode / Pivotal GemFire ClientCache application using Spring config
to be pushed to an Apache Geode / Pivotal GemFire cluster, similar to how schema commands (e.g.The
EnableClusterDefinedRegions annotation marks a Spring @Configuration application
annotated class to enable the creation of client Proxy-based Regions for all Regions
defined in an Apache Geode/Pivotal GemFire cluster.The
EnableCompression annotation marks a Spring @Configuration annotated application
Class to configure and enable Pivotal GemFire/Apache Geode Region data compression.The
EnableContinuousQueries annotation marks a Spring @Configuration annotated
application configuration class to enable Pivotal GemFire / Apache Geode Continuous Queries (CQ) feature.The
EnableDiskStore annotation marks a Spring @Configuration annotated Class
to configure a single GemFire/Geode DiskStore bean in the Spring application context
in which to persist or overflow data from 1 or more cache Regions.The
EnableDiskStores annotation marks a Spring @Configuration
annotated application class to configure 1 or more GemFire/Geode DiskStore beans
in the Spring context in which to persist or overflow data from 1 or more GemFire/Geode
RegionsThe
EnableEntityDefinedRegions annotation marks a Spring @Configuration application
annotated class to enable the creation of GemFire/Geode Regions based on
the application persistent entities.The
EnableEviction annotation marks a Spring @Configuration annotated class
to enable Region Eviction.Definition for a specific Eviction policy that can be applied to 1 or more
Regions.The
EnableExpiration annotation marks a Spring @Configuration
annotated class to enable Region entry expiration for individual entries.Definition for a specific Expiration policy that can be applied to 1 or more
Regions.EnableExpiration.ExpirationType defines different types of GemFire/Geode Expiration policies such as
(Entry) Idle Timeout (TTI) and (Entry) Time to Live (TTL).The
EnableGatewayReceiver annotation creates a GatewayReceiver within an Apache Geode
or Pivotal GemFire peer Cache.This
Annotation is responsible for configuring a single GatewaySender.This
Annotation is responsible for the configuration of multiple GatewaySenders.The
EnableGemFireAsLastResource annotation is used to enable GemFire as a Last Resource in a Spring,
CMT/JTA Transaction.The
EnableGemfireCacheTransactions annotation enables Pivotal GemFire or Apache Geode Cache Transactions
in Spring's Transaction Management infrastructure.The
EnableGemfireCaching annotation enables Pivotal GemFire or Apache Geode as a caching provider
in Spring's Cache Abstraction.Enables classpath scanning for interfaces annotated as GemFire function executions (function invocations).
Enables GemFire annotated Function implementations.
The
EnableGemFireProperties annotation marks a Spring @Configuration
annotated class to configure GemFire/Geode System properties at runtime during [Spring Boot] application startup.Annotation to enable Apache Geode, Spring Data
Repositories.The
EnableHttpService annotation marks a Spring @Configuration
annotated Class to configure and enable Pivotal GemFire/Apache Geode's embedded HTTP service.The
EnableIndexing annotation marks a Spring @Configuration annotated application class
to enable the creation of GemFire/Geode Indexes and LuceneIndexes based on
application persistent entity field/property annotations, such as the {@link @Id}, {@link @Indexed}
and {@link @LuceneIndex} annotations.The
EnableLocator annotation configures a Spring @Configuration annotated Class
to start an embedded Pivotal GemFire/Apache Geode Locator service in this cluster member.The
EnableLogging annotation marks a Spring @Configuration annotated Class
to configure and enable Pivotal GemFire/Apache Geode system logging.The
EnableManager annotation marks a Spring @Configuration annotated Class
to configure, embed and start a Pivotal GemFire/Apache Geode Manager service in this cluster member.The
EnableMcast annotation marks a Spring @Configuration annotated Class
to configure and enable Pivotal GemFire/Apache Geode's multi-cast networking features.The
EnableMemcachedServer annotation marks a Spring @Configuration
annotated Class to start an embedded Memcached Server (Gemcached) service in this cluster member.Valid values for the Memcached Network Protocol on-the-wire transport.
The
EnableOffHeap annotation marks a Spring @Configuration annotated application
Class to configure and enable Off-Heap Memory data storage in cache Regions.The
EnablePdx annotation marks a Spring @Configuration annotated Class
to enable the Apache Geode PDX features and functionality in this peer cache, cluster member or cache client
application.The
EnablePool annotation configures a Spring Configuration
annotated class with a "named" GemFire client Pool bean in the application context.The
EnablePools annotation enables 1 or more GemFire Pools
to be defined and used in a GemFire client cache application configured with Spring (Data GemFire).The EnableRegionDataAccessTracing class...
The
EnableSecurity annotation marks a Spring @Configuration annotated Class
to configure and enable Pivotal GemFire/Apache Geode's Security features for authentication, authorization
and post processing.The
EnableSsl annotation marks a Spring @Configuration annotated Class
to configure and enable Pivotal GemFire/Apache Geode's TCP/IP Socket SSL.The
EnableStatistics annotation marks a Spring @Configuration annotated Class
to configure and enable statistics and runtime metrics of a running Pivotal GemFire/Apache Geode system.The
EntityDefinedRegionsConfiguration class is Spring ImportBeanDefinitionRegistrar used in
the EnableEntityDefinedRegions annotation to dynamically create GemFire/Geode Regions
based on the application persistent entity classes.The
EntityDefinedRegionsConfiguration.RegionBeanDefinitionMetadata class encapsulates details for creating a Region
from application persistent entities.Generic serializer for all Java Enums.
The
EvictingRegionFactoryBean interface specifies Region FactoryBeans capable
of supporting Eviction configuration, that is, evicting Region entries.The EvictionActionConverter class is a Spring Converter and JavaBeans PropertyEditor that converts
an Object value into an instance of GemFire EvictionAction.
The EvictionActionType enum is an enumeration of all the GemFire EvictionAction values.
Simple utility class used for defining nested factory-method like definitions w/o polluting the container with useless beans.
The
EvictionConfiguration class is a Spring @Configuration annotated class to enable
Eviction policy configuration on cache Regions.EvictionConfiguration.ComposableEvictionPolicyConfigurer is a EvictionConfiguration.EvictionPolicyConfigurer implementation that composes
multiple EvictionConfiguration.EvictionPolicyConfigurer objects into a composition using the Composite Software Design Pattern
making the composition appear as a single EvictionConfiguration.EvictionPolicyConfigurer.EvictionConfiguration.EvictionPolicyConfigurer configures the Eviction policy of an Apache Geode Region.The EvictionTypeConverter class is a Spring Converter used to convert a String value into
a corresponding EvictionType enumerated value.
The EvictionPolicyType enum is an enumeration of all GemFire Eviction policies, where the Eviction 'policy'
is a combination of the Eviction algorithm mixed with the monitored resource (e.g. such as JVM HEAP memory).
A
FunctionException indicating a timeout during execution.Expiration is an enumerated type encapsulating custom expiration settings for application domain objects
to express their general expiration policy.
The ExpirationActionTypeConverter class is a Spring Converter used to convert a String value into
a corresponding ExpirationActionType enumerated value.
The ExpirationActionType enum is a enumeration of GemFire ExpirationActions on expired Cache Region entries.
The ExpirationAttributesFactoryBean class is a Spring FactoryBean used to create GemFire ExpirationAttributes
to specify Expiration policies for Region Time-to-Live (TTL) and Idle-Timeouts (TTI) as well as
Entry Time-to-Live (TTL) and Idle-Timeouts (TTI).
ExpirationConfiguration is a Spring Configuration class used to configure expiration policies
for GemFire/Geode Regions.ExpirationConfiguration.ComposableExpirationPolicyConfigurer is a ExpirationConfiguration.ExpirationPolicyConfigurer implementation
that additionally implements the Composition Software Design Pattern to treat a collection of
ExpirationConfiguration.ExpirationPolicyConfigurer objects as a single instace of the ExpirationConfiguration.ExpirationPolicyConfigurer.Interface defining a contract for implementations that configure a
Region's expiration policy.ExpirationConfiguration.ExpirationPolicyMetaData is a ExpirationConfiguration.ExpirationPolicyConfigurer implementation that encapsulates
the expiration configuration meta-data (e.g. expiration timeout and action) necessary to configure
a Regions's expiration policy and behavior.The
ExpiringRegionFactoryBean interface signifies Region FactoryBeans
that support Expiration configuration.The ExportSnapshotApplicationEvent class is a Spring ApplicationEvent signaling a GemFire Cache or Region 'import'
snapshot event.
The ExportSnapshotException class is a RuntimeException indicating an error occurred while saving a snapshhot
of GemFire's Cache Regions.
FactoryDefaultsPoolAdapter is an abstract implementation of the Pool interface and extension of
PoolAdapter that provides default factory values for all configuration properties
(e.g. freeConnectionTimeout, idleTimeout, etc).Used to inject a set of cache keys into a function execution, The annotated parameter must be of type
Set.Spring
FactoryBean to create a instance of the FixedPartitionAttributes.Parser for a <function-executions> bean definition.
ImportBeanDefinitionRegistrar for EnableGemfireFunctionExecutions, which scans for interfaces
annotated with one of OnRegion, OnServer, OnServers, OnMember, OnMembers.Interface for Function Execution configuration sources (e.g.
The
FunctionGemfireAdminTemplate class is an implementation of the GemfireAdminOperations interface
supporting the Pivotal GemFire / Apache Geode administrative functions/operations via Function execution
in the cluster.Annotation to bind an interface method to a GemFire function id
Spring FactoryBean for registering instance of GemFire Function with the GemFire FunctionService.
Spring
Configuration class used to construct, configure and initialize a GatewayReceiver instance
in a Spring application context.GatewayReceiverConfigurer used to customize the configuration of a GatewayReceiverFactoryBean.Spring
FactoryBean used to construct, configure and initialize a GatewayReceiver.Spring
FactoryBean used to construct, configure and initialize parallel and serial
GatewaySenders.Spring
Configuration class used to construct, configure and initialize GatewaySender instances
in a Spring application context.GatewaySenderWrapper is an Adapter around an Apache Geode GatewaySender
providing the ability to control manual start and stop of the sender.GemfireAccessor is a base class for GemfireTemplate to encapsulate common operations and properties,
such as accessors to a Region.The
GemfireAdminOperations interface defines a set of operations to define schema objects in a remote
Apache Geode or Pivotal GemFire cluster.The
GemFireAsLastResourceConfiguration class is a Spring @Configuration
annotated class used to configure the GemFire "Last Resource" Spring Data GemFire Aspects.The
GemFireAsLastResourceConnectionAcquiringAspect class is a AbstractGemFireAsLastResourceAspectSupport
implementation responsible for acquiring a GemFire Connection from GemFire's JCA ResourceAdapter,
GFConnectionFactory after a CMT/JTA Transaction is began, which is initiated by
Spring's Transaction infrastructure.The
GemFireAsLastResourceConnectionClosingAspect class is a AbstractGemFireAsLastResourceAspectSupport
implementation responsible for closing the GemFire Connection obtained from the GemFire JCA ResourceAdapter
deployed in a managed environment when using GemFire as the Last Resource in a CMT/JTA Transaction
initiated from Spring's Transaction infrastructure.The
GemfireBeanFactoryLocator class stores a reference to the Spring
ApplicationContext / BeanFactory needed to auto-wire
user application GemFire objects implementing the Declarable interface
and defined in GemFire's native configuration format (e.g.Reference holder storing a reference to a Spring
BeanFactory.Core Spring Framework
CacheManager implementation backed by a GemFire cache instance
(either a client or peer cache).The
GemfireCacheTransactionsConfiguration class is a Spring @Configuration class
used to enable Spring's Transaction Management infrastructure along with SDG's GemfireTransactionManager
to manage local, cache transactions for either Pivotal GemFire or Apache Geode.Abstract utility class featuring methods for Apache Geode / Pivotal GemFire Cache or Region handling.
The
GemfireCachingConfiguration class is a Spring @Configuration class
used to configure Pivotal GemFire or Apache Geode as the caching provider in Spring's Cache Abstraction.Callback interface for GemFire code.
GemFire-specific class for exceptions caused by system cancellations.
The
GemFireComponentClassTypeScanner class is a classpath component scanner used to search
for GemFire components based on Class type.The GemfireConstants class define constants for Spring GemFire component bean names.
Convenient super class for GemFire Data Access Objects (DAO) implementing the Spring
DaoSupport abstract class.A Spring
BeanFactoryPostProcessor used to register a Client Region beans for each Region accessible to
an Apache Geode or Pivotal GemFire DataSource.EntityInformation capturing GemFire specific information.The GemfireFeature enum is an enumeration of features available in Apache Geode and Pivotal GemFire combined.
Used to declare a concrete method as a GemFire function implementation
Spring
BeanPostProcessor that discovers bean components configured as Function implementations,
i.e. beans containing methods annotated with GemfireFunction.Spring
ImportBeanDefinitionRegistrar to register the GemfireFunctionBeanPostProcessorA callback for Gemfire Function Templates
An interface for invoking Gemfire functions
A Proxy
FactoryBean for all non-Region Function Execution interfaces.Abstract class defining useful Java
Functions for Apache GeodeUtility class for registering a POJO as a GemFire/Geode
Function.Gemfire-specific subclass thrown on Index management.
Exception thrown when the execution of a listener method failed.
Spring Data
AbstractMappingContext implementation defining entity mapping meta-data
for GemFire persistent entities.GemfireOperations defines the {Region data access operations that can be performed
using the Template software design pattern.PersistentEntity implementation adding custom GemFire persistent entity related metadata, such as the
Region to which the entity is mapped, etc.PersistentProperty implementation to for Gemfire related metadata.An Enum (enumeration) of Apache Geode gemfire.properties.
The
GemFirePropertiesConfiguration class is a Spring ImportBeanDefinitionRegistrar
capable of configuring additional GemFire Properties on a (Spring Boot) application class at runtime
during startup.GemFire-specific subclass of
InvalidDataAccessResourceUsageException thrown on invalid
OQL query syntax.QueryMethod implementation for Apache Geode.ImportBeanDefinitionRegistrar to configure and setup Apache Geode Repositories
via EnableGemfireRepositories.Apache Geode extension of the Spring Data
PagingAndSortingRepository interface.RepositoryConfigurationExtension implementation handling Apache Geode specific extensions
in the Repository XML and Annotation-based configuration metadata.The GemfireRepositoryExtension class...
RepositoryFactorySupport implementation creating repository proxies
for Gemfire.Spring
FactoryBean adapter for GemfireRepositoryFactory.Abstract base class for Apache Geode specific
RepositoryQuery implementations.The GemfireSimpleTypeHolder class is a Spring Data Commons SimpleTypeHolder implementation adding additional
simple types to the collection.
GemFire-specific subclass of UncategorizedDataAccessException, for GemFire system errors that do not match any concrete
org.springframework.dao exceptions.The
GemfireTemplate class simplifies Apache Geode data access operations, converting Apache Geode
GemFireCheckedExceptions and GemFireExceptions into
Spring DataAccessExceptions, following the org.springframework.dao
Exception hierarchy.Gemfire-specific subclass of
TransactionException, indicating a transaction failure at commit time.Local Transaction Management for Pivotal GemFire.
Holder of GemFire cache transaction state.
GemFire local cache transaction object.
GemfireUtils is an abstract utility class encapsulating common functionality for accessing features
and capabilities of Apache Geode based on version as well as other configuration meta-data.The GenericRegionFactoryBean class is an extension of the abstract, base PeerRegionFactoryBean class enabling developers
to define a GemFire Cache Region with defaults.
The
GeodeIntegratedSecurityConfiguration class is a EmbeddedServiceConfigurationSupport implementation
that enables Apache Geode's Integrated Security framework and services.The Hint class is a annotation type indicating a GemFire OQL Query Hint.
The
HttpServiceConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration by way of Pivotal GemFire/Apache Geode Properties to configure
Pivotal GemFire/Apache Geode's embedded HTTP service and dependent services (e.g.IdleTimeoutExpiration is an enumerated type encapsulating custom expiration settings for application domain objects
to express their idle-timeout (TTI) expiration policy.
The Import class is a annotation type indicating a GemFire OQL Query Import to refer to the class of an object
in cases where the same class name resides in two different name scopes (packages), then you must be able to
differentiate the classes having the same name.
The ImportSnapshotApplicationEvent class is a Spring ApplicationEvent signaling a GemFire Cache or Region 'export'
snapshot event.
The ImportSnapshotException class is a RuntimeException indicating an error occurred while loading GemFire Snapshots
into the GemFire Cache Regions.
The
IndexCollector class is an implementation of the SchemaObjectCollector that is capable of
inspecting a context and finding all Index schema object instances that have been declared in that context.The
IndexConfiguration class is a Spring ImportBeanDefinitionRegistrar
and extension of EntityDefinedRegionsConfiguration used in the EnableIndexing annotation
to dynamically create GemFire/Geode Region Indexes based on
GemfirePersistentEntity GemfirePersistentProperty annotations.The
IndexConfigurer interface defines a contract for implementing Objects in order to
customize the configuration of Entity-defined Indexes when a user annotates her Spring application
Configuration Class with EnableIndexing.IndexDefinition is an Abstract Data Type (ADT) encapsulating the configuration meta-data used to define
a new Apache Geode / Pivotal GemFire Region Index.The
Indexed annotation is used to index a GemfirePersistentEntity GemfirePersistentProperty,
which creates a GemFire/Geode Index on a GemFire/Geode Region.Spring
FactoryBean used to construct, configure and initialize an Index.The IndexMaintenanceTypeConverter class is a Spring Converter and JavaBeans PropertyEditor capable of converting
a String into a specific SDG IndexMaintenancePolicyType.
The
IndexMaintenancePolicyType enum is a enumerated type of GemFire Index maintenance update options.IndexType is an enumerated type of Apache Geode Index Types.The IndexTypeConverter class is a Spring Converter implementation as well as a JavaBeans PropertyEditor
that converts a given String value into a proper IndexType.
FactoryBean that eases registration of custom Instantiator through
InstantiatorGenerators, inside the Spring container.Factory that generates
Instantiator classes to improve instantiation of
custom types.The Interest class holds details for registering a client interest.
Type of interest registration.
The InterestPolicyConverter class is a Spring Converter implementation and Java PropertyEditor handling
the conversion between Strings and GemFire InterestPolicy values.
The InterestPolicyType enum is an enumeration of all the GemFire Subscription, InterestPolicy values.
The InterestResultPolicyConverter class is a Spring Converter and JavaBeans PropertyEditor capable of converting
a String into a GemFire InterestResultPolicyConverter.
The InterestResultPolicyType enum is an enumeration of all client Register Interests (result) policy values.
Java class to represent the current version of the JRE or JVM.
The JndiDataSourceType class is an enumeration of valid JNDI DataSource implementation types supported by GemFire.
Spring/AspectJ AOP Aspect adapting a
Region to handle JSON data.Cache Region interest based on individual keys.
Composition for
CacheServerConfigurer.Composition for
ClientCacheConfigurer.Composition of
ContinuousQueryListenerContainerConfigurer.Composition of
DiskStoreConfigurer.Composition of
GatewayReceiverConfigurer.Composition of
GatewaySenderConfigurer.Composition for
IndexConfigurer.Composition for
LocatorConfigurer.Composition of
PeerCacheConfigurer.Composition of
PoolConfigurer.Composition for
RegionConfigurer.The
LazyWiringDeclarableSupport class is an implementation of GemFire's Declarable interface
that enables support for wiring GemFire components with Spring bean dependencies defined in
a Spring ApplicationContext.The Limit class is an annotation type indicating a GemFire OQL Query Limit on the number of results
that are returned.
The
ListablePage class is a Spring Data Page implementation wrapping a List as the content
for this page.The ListIndexesFunction class...
ListRegionsOnServerFunction is an Apache Geode Function
returning a List of names for all Regions
defined in the Apache Geode cache.Annotation defining the Local Region in which the application persistent entity will be stored.The
LocatorApplication Annotation enables a Spring Data for Apache Geode & Pivotal GemFire
application to become a Locator based application.Spring
@Configuration class used to configure and bootstrap an Apache Geode
or Pivotal GemFire Locator.The
LocatorConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration by way of Pivotal GemFire/Apache Geode Properties to configure
an embedded Locator.A Spring
Configurer used to apply additional, customized configuration for an Apache Geode or Pivotal GemFire
Locator.Spring
FactoryBean used to configure and initialize (bootstrap) an Apache Geode or Pivotal GemFire
Locator using the LocatorLauncher class.The
LoggingConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration using Pivotal GemFire/Apache Geode Properties to configure
Pivotal GemFire/Apache Geode logging.The LookupRegionFactoryBean class is a concrete implementation of ResolvableRegionFactoryBean for handling
>gfe:lookup-region/< SDG XML namespace (XSD) elements.
LuceneAccessor is an abstract class supporting implementations of the LuceneOperations interface
encapsulating common functionality necessary to execute Lucene queries.LuceneAccessorSupport is a LuceneAccessor class implementation providing support
for extending classes.The
LuceneIndexed annotation is used to index a GemfirePersistentEntity
GemfirePersistentProperty, creating a GemFire/Geode LuceneIndex
on a GemFire/Geode Region.Spring
FactoryBean used to construct, configure and initialize Lucene Indexes
on application domain object fields.The
LuceneIndexRegionBeanFactoryPostProcessor class is a Spring BeanFactoryPostProcessor ensuring
that a LuceneIndex is created before the Region on which the LuceneIndex is defined.The
LuceneOperations interface defines a contract for implementations defining data access operations
using Lucene queries.LuceneOperationsSupport is a abstract supporting class for implementations
of the LuceneOperations interface.The
LucenePage class is a Spring Data Page implementation supporting Spring Data style paging
of PageableLuceneQueryResults complete with Spring Data projections.LuceneTemplate is a Lucene data access operations class encapsulating functionality
for performing Lucene queries and other Lucene data access operations.The
ManagerConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration using Pivotal GemFire/Apache Geode Properties to configure an embedded Manager
in this cluster member.PdxSerializer implementation using the Spring Data for Apache Geode GemfireMappingContext
to read (deserialize) and write (serialize) entities from and to PDX.The
McastConfiguration class is a Spring ImportBeanDefinitionRegistrar
that applies additional GemFire configuration by way of GemFire System properties to configure and use
multi-cast networking for GemFire communication and distribution rather than the (preferred)
Locator-based location services.The
MemcachedServerConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration using Pivotal GemFire/Apache Geode Properties to configure
an embedded Memcached server in this cluster member.Abstract utility class providing functions for networking.
The
NoOpBeanFactoryPostProcessor class is a Spring BeanFactoryPostProcessor implementation
that performs no operation.The
OffHeapConfiguration class is a Spring ImportBeanDefinitionRegistrar capable of
enabling Pivotal GemFire/Apache Geode cache Regions to use Off-Heap Memory for data storage.Annotation to declare an interface as a GemFire OnMember Function Execution
Annotation to declare an interface as a GemFire OnMembers Function Execution
Annotation to declare an interface as a GemFire OnRegion Function Execution
Annotation to declare an interface as a GemFire OnServer Function Execution
Annotation to declare an interface as a GemFire OnServers Function Execution
The
OqlKeyword enum represents the complete set of keywords (Reserved Words)
in Apache Geode's Object Query Language (OQL).A Strategy interface for executing Apache Geode OQL queries (e.g.
The
OrderPolicyConverter class is a Spring Converter and JavaBeans PropertyEditor used to
convert a String into an appropriate GatewaySender.OrderPolicy enum.The OrderPolicyType class is an enumeration of GemFire Gateway Order Policies.
QueryString implementation handling paging functionality and behavior.An Apache Geode
SelectResults implementation with support for Paging.Spring
FactoryBean for creating PartitionAttributes.Spring
FactoryBean used to create an Apache Geode PARTITION Region.Annotation defining the Partition Region in which the application persistent entity will be stored.PartitionRegion.FixedPartition defined fixed partition meta-data within
a DataPolicy.PARTITION Region.GemfireRepositoryQuery backed by a PartTree, deriving an OQL query
from the backing QueryMethod's name/signature.The
PdxConfiguration class is a Spring Configuration class that configures PDX
on a GemFireCache instance.PdxDiskStoreAwareBeanFactoryPostProcessor is a Spring BeanFactoryPostProcessor that modifies
all GemFire Async Event Queue, Region and Disk Store beans in the Spring container to form a dependency on
the Cache's PDX DiskStore bean.The
PdxInstanceMethodInterceptor class is a MethodInterceptor wrapping a PdxInstance
to back a proxy during intercepted method invocations.The
PdxInstanceMethodInterceptorFactory class is a Spring Data MethodInterceptorFactory used to
identify PdxInstance types and instantiates an instance of the PdxInstanceMethodInterceptor
in order to intercept and handle invocations on the PdxInstance for the proxied projection.The
PeerCacheApplication annotation enables an embedded GemFire peer Cache
instance in a Spring Data GemFire based application.Spring
Configuration class used to construct, configure and initialize a peer Cache instance
in a Spring application context.The
PeerCacheConfigurer interface defines a contract for implementing Objects in order to
customize the configuration of a CacheFactoryBean used to construct, configure and initialize
an instance of a peer Cache.Spring
FactoryBean and abstract base class extended by other SDG FactoryBeans
used to construct, configure and initialize peer Regions.The
PoolAdapter class is an abstract base class and default, no-op implementation of
the Pool interface that conveniently enables implementing classes to extend this adapter
and choose which Pool methods/operations are supported by this implementation.The
PoolConfigurer interface defines a contract for implementing Objects in order to
customize the configuration of a PoolFactoryBean used to construct, configure and initialize a Pool.Spring
FactoryBean used to construct, configure and initialize a Pool.Callback interface to initialize the
PoolFactory used by this PoolFactoryBean
to create a Pool by providing additional or alternative configuration for the factory.PoolManagerPoolResolver is an implementation of PoolResolver that delegates all Pool
resolution logic to the Apache Geode PoolManager.PoolResolver is a strategy interface for resolving references to Apache Geode Pool instances.ProjectingLuceneAccessor is an abstract class supporting implementations of
the ProjectingLuceneOperations interface encapsulating common functionality
necessary to execute Lucene queries and work with application domain object views.ProjectingLuceneAccessorSupport is a ProjectingLuceneAccessor class implementation providing support
for extending classes.The
ProjectingLuceneOperations interface defines a contract for implementing classes to execute
Lucene data access operations and mapping the results to entity domain types.ProjectingLuceneOperationsSupport is a abstract supporting class for implementations
of the ProjectingLuceneOperations interface.ProjectingLuceneTemplate is a Lucene data access operations class encapsulating functionality
for performing Lucene queries and other Lucene data access operations and returning the query results
as application-specific domain object views.Builder for
Properties.The
QueryPostProcessor interface defines a contract for implementations to post process
a given query and possibly return a new or modified version of the same query.QueryString is a base class used to construct and model syntactically valid Apache Geode
OQL query statements.Cache interest based on regular expression rather then individual key types.
Annotation declaring the Region in which the application persistent entity will be stored.Spring
FactoryBean used to create RegionAttributes.The
RegionCollector class is an implementation of the SchemaObjectCollector that is capable of
inspecting a context and finding all Region schema object instances that have been declared in that context.The
RegionConfigurer interface defines a contract for implementing Objects in order to
customize the configuration of Entity-defined Regions when a user annotates her Spring application
Configuration Class with EnableEntityDefinedRegions or EnableCachingDefinedRegions.Used to inject Region data into a function execution.
The RegionDataAccessTracingAspect class...
The RegionDataAccessTracingConfiguration class...
RegionDefinition is an Abstract Data Type (ADT) encapsulating the configuration meta-data used to
define a new Apache Geode / Pivotal GemFire cache Region.The
RegionResolver interface is a Strategy interface used to encapsulate different algorithms
(Strategies) used to resolve a cache Region.RegionResolver implementation used to resolve a cache Region identified by name
using the configured RegionService.The RegionShortcutConverter class is a Spring Converter implementation converting String value Region Shortcut
representations into actual GemFire RegionShortcut enumerated values.
The RegionShortcutWrapper enum is a Java enumerated type that wraps GemFire's RegionShortcuts
with Spring Data GemFire RegionShortcutWrapper enumerated values.
The
RegionUtils class is an abstract utility class for working with Regions.Annotation defining the Replicate Region in which the application persistent entity will be stored.Spring
FactoryBean used to look up or create Regions.RestHttpGemfireAdminTemplate is class implementing the GemfireAdminOperations interface,
extending the FunctionGemfireAdminTemplate to support administrative (management) operations
on a Pivotal GemFire or Apache Geode cluster using the Management REST API interface over HTTP.Configurer for a
RestTemplate.The
RuntimeExceptionFactory class is a factory for creating common RuntimeExceptions
with the added convenience of message formatting and optional causes.The
SchemaObjectCollector interface defines a contract for implementing objects to search for
and find all schema objects of a particular type in a given context.The
SchemaObjectDefiner interface defines a contract for implementing objects
that can reverse engineer a schema object instance back into a definition of the schema object.SchemaObjectDefinition is an Abstract Data Type (ADT) encapsulating the definition of a single Apache Geode
or Pivotal GemFire schema object (e.g.SchemaObjectType defines an enumeration of all the types of Apache Geode or Pivotal GemFire schema objects
(e.g.The
ScopeConverter class is a Spring Converter and JavaBeans PropertyEditor
that converts a String into a Scope.The ScopeType enum is an enumeration of GemFire Scopes.
Simple, basic
PagingAndSortingRepository / CrudRepository implementation for Apache Geode.CacheResolver implementation that resolves to a configured, single GemFireCache instance.PoolResolver implementation that resolves a single, configured Pool.RegionResolver implementation resolving a single, configured Region object.Spring
FactoryBean used to construct a custom, determined CacheResolver that strategically
and lazily resolves a cache instance.The
SmartLifecycleSupport interface is an extension of Spring's SmartLifecycle interface
providing default, convenient behavior for many of the lifecycle methods as well as a serving
as a FunctionalInterface.The SnapshotApplicationEvent class is a Spring ApplicationEvent signaling a GemFire Cache or Region snapshot event,
used to trigger a snapshot to occur.
The SnapshotServiceFactoryBean class is a Spring FactoryBean used to configure and create an instance
of an appropriate GemFire Snapshot Service to perform data import and exports.
The ArchiveFileFilter class is a Java FileFilter implementation accepting any File that is either
a JAR file or ZIP file.
The CacheSnapshotServiceAdapter is a SnapshotServiceAdapter adapting GemFire's CacheSnapshotService.
The RegionSnapshotServiceAdapter is a SnapshotServiceAdapter adapting GemFire's RegionSnapshotService.
The SnapshotMetadata class encapsulates details of the GemFire Cache or Region data snapshot
on either import or export.
The SnapshotServiceAdapter interface is an Adapter adapting both GemFire CacheSnapshotService
and RegionSnapshotService to treat them uniformly.
SnapshotServiceAdapterSupport is an abstract base class for all SnapshotServiceAdapter implementations
encapsulating common reusable functionality.
The
SpringContextBootstrappingInitializer class is a GemFire configuration initializer used to bootstrap
a Spring ApplicationContext inside a GemFire Server JVM-based process.Abstract utility class encapsulating functionality common to
Objects, Class types
and Spring beans.The SpringServerLauncherCacheProvider class overrides the default behavior of GemFire's
ServerLauncher
to bootstrap the GemFire cache using a Spring ApplicationContext instead
of GemFire cache.xml inside a GemFire Server JVM-based process.The
SslConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration using Pivotal GemFire/Apache Geode Properties to configure SSL.The
StatisticsConfiguration class is a Spring ImportBeanDefinitionRegistrar that applies
additional configuration using Pivotal GemFire/Apache Geode Properties to configure
Pivotal GemFire/Apache Geode Statistics.The
StreamUtils class is a abstract utility class for working with Streams.GemfireRepositoryQuery using plain String based OQL queries.Spring
FactoryBean used for defining and constructing an Apache Geode SubscriptionAttributes object,
which determines the subscription policy used by cache Regions declaring their data interests.Enumeration of the various client subscription policies for
CacheServer.The SubscriptionEvictionPolicyConverter class is a Spring Converter and JavaBeans PropertyEditor for converting
Strings into a SubscriptionEvictionPolicy enumerated value.
TimeToLiveExpiration is an enumerated type encapsulating custom expiration settings for application domain objects
to express their time-to-live (TTL) expiration policy.
The Trace class is an annotation type to enable GemFire OQL Query debugging.
The
TransactionApplicationEvent is an implementation of ApplicationEvent which is fired during
a transaction.The
TransactionListenerAdapter class is an Apache Geode TransactionListener
and TransactionWriter implementation that publishes the TransactionEvent to application components
and beans declared in the Spring ApplicationContext using the ApplicationEventPublisher.An
FunctionException indicating a Function Execution RuntimeException
that has not be categorized, or identified by the framework.A Java
RuntimeException indicating that the Apache Geode OQL query could not be executed (i.e. handled)
by the OqlQueryExecutor.UsesGemFireProperties is a meta-annotation used to mark other SDG Annotations
that uses GemFire properties to configure the Spring-based GemFire cache instance.Declarable support class used to wire declaring, implementing instances through the Spring container.Apache Geode
Instantiator that performs instance wiring using the Spring IoC container, allowing common
properties to be injected before the object is hydrated/deserialized.Simple
value object holding an entity along with the external key in which the entity will be mapped.