All Classes and Interfaces

Class
Description
Base implementation for a subscription handling the channel/pattern registration so subclasses only have to deal with the actual registration/unregistration.
Base implementation for ValkeyCollection.
 
Sort aggregation operations.
ValkeyPersistentEntity implementation.
Collection of predefined BatchStrategy implementations using the Valkey KEYS or SCAN command.
A BatchStrategy to be used with ValkeyCacheWriter.
HashMapper based on Apache Commons BeanUtils project.
The actual BITFIELD command representation holding several BitFieldSubCommands.BitFieldSubCommands to execute.
 
The GET sub command used with BitFieldSubCommands.
 
The INCRBY sub command used with BitFieldSubCommands.
 
The SET sub command used with BitFieldSubCommands.
 
Sub command to be used as part of BitFieldSubCommands.
The actual Valkey bitfield type representation for signed and unsigned integers used with BitFieldSubCommands.BitFieldSubCommand.
GeoOperations bound to a certain key.
Hash Field Expiration operations bound to a certain hash key and set of hash fields.
Hash operations bound to a certain key.
Represents a geospatial bounding box defined by width and height.
Key Expiration operations bound to a key.
Operations over a Valkey key.
List operations bound to a certain key.
Set operations bound to a certain key.
Valkey stream specific operations bound to a certain key.
Value (or String in Valkey terminology) operations bound to a certain key.
ZSet (or SortedSet) operations bound to a certain key.
Bounding box defined by width and height.
Bucket is the data bag for Valkey hash structures to be used with ValkeyData.
Value object representing a path within a Bucket.
Mapper translating Valkey bulk value responses (typically returned by a sort query) to actual objects.
 
Simple wrapper class used for wrapping arrays so they can be used as keys inside maps.
A Record within the stream backed by a collection of binary field/value pairs.
A Record within the stream backed by a collection of binary field/value pairs.
Some handy methods for dealing with byte arrays.
CacheKeyPrefix is a callback hook for creating custom prefixes prepended to the actual key stored in Valkey.
Cache statistics for a ValkeyCache.
The statistics collector supports capturing of relevant ValkeyCache operations such as hits & misses.
Interface to be implemented by objects that expose CacheStatistics identified by cacheName.
Cancelable allows stopping long running tasks and freeing underlying resources.
Base class for Bean wrappers.
Channel Topic implementation mapping to a Valkey channel.
Exception thrown when at least one call to a clustered valkey environment fails.
ClusterCommandExecutor takes care of running commands across the known cluster nodes.
Callback interface for Valkey 'low level' code using the cluster client directly.
Callback interface for Valkey 'low level' code using the cluster client to execute multi key commands.
ClusterInfo gives access to cluster information such as cluster_state and cluster_slots_assigned provided by the CLUSTER INFO command.
 
ClusterNodeResourceProvider provides access to low level client api to directly execute operations against a Valkey instance.
Valkey operations for cluster specific operations.
ClusterRedirectException indicates that a requested slot is not served by the targeted server but can be obtained on another one.
Utility class encapsulating functionality commonly used for cluster slot hashing.
DataAccessResourceFailureException indicating the current local snapshot of cluster state does no longer represent the actual remote state.
ClusterTopology holds snapshot like information about ValkeyClusterNodes.
ClusterTopologyProvider manages the current cluster topology and makes sure to refresh cluster information.
Utility class used mainly for type conversion by the default collection implementations.
Composite IndexResolver implementation that iterates over a given collection of delegate IndexResolver instances.
Utilities for examining a ValkeyConnection
Value object representing a Stream consumer within a consumer group.
Common type converters.
ConvertingCursor wraps a given cursor and applies given Converter to items prior to returning them.
Cursor abstraction to scan over the keyspace or elements within a data structure using a variant of a SCAN command.
Value class representing a cursor identifier.
Enumeration of the Valkey data types.
Simple class containing various decoding utilities.
Specifies that the connection decorates another ValkeyConnection.
Delegating hash mapper used for flattening objects into Strings.
Deprecated.
Deprecated.
Default message implementation.
Default implementation of ReactiveScriptExecutor.
Default implementation of ScriptExecutor.
Default implementation for SortParameters.
Default implementation for StringValkeyConnection.StringTuple interface.
Default implementation of StringValkeyConnection.
Default implementation for Tuple interface.
Default implementation of TypedTuple.
Default implementation of ValkeyGlideClientConfiguration.
Default implementation for ValkeyList.
Default implementation for ValkeyMap.
Default implementation of ValkeyScript.
Default implementation for ValkeySet.
Default implementation of ValkeyTypeMapper allowing configuration of the key to lookup and store type information via Bucket.BucketPropertyPath in buckets.
Default implementation for ValkeyZSet.
Utilties for working with MessageDigest
Annotation to activate Valkey repositories.
Mapper for Query-by-Example examples to an actual query.
Potentially translates an Exception into appropriate DataAccessException.
Expiration holds a numeric value with an associated TimeUnit.
Expiration options for Expiation updates.
Conditions to apply when changing expiration.
Builder to build ExpirationOptions
Value Object linking a number of keys to their Expirations.TimeToLive retaining the order of the original source.
Collection of timeouts associated with a TimeUnit.
Expiration holds time to live Expirations.TimeToLive.raw() values as returned by a Valkey Client.
Value Object linking a number of keys to their ExpireChanges.ExpiryChangeState retaining the order of the original source.
 
ValkeyCacheWriter.TtlFunction implementation returning the given, predetermined Duration used for per cache entry time-to-live (TTL) expiration.
The result of an asynchronous operation
Generic Jackson 2-based ValkeySerializer that maps objects to and from JSON using dynamic typing.
Builder for configuring and creating a GenericJackson2JsonValkeySerializer.
Generic String to byte[] (and back) serializer.
 
Mark properties value to be included in a secondary index.
IndexedData implementation indicating storage of data within a Valkey GEO structure.
 
Valkey operations for geo commands.
Reference point for GEOSEARCH and GEOSEARCHSTORE commands.
 
 
Search predicate for GEOSEARCH and GEOSEARCHSTORE commands.
 
Core mapping contract between Java types and Valkey hashes/maps.
Function that returns a HashMapper for a given type.
Valkey map specific operations working on a hash.
 
IndexConfiguration allows programmatic setup of indexes.
IndexDefinition allow to set up a blueprint for creating secondary index structures in Valkey.
 
Context in which a particular value is about to get indexed.
IndexDefinitionProvider give access to IndexDefinitions for creating secondary index structures.
Registry that allows adding IndexDefinition.
Mark properties value to be included in a secondary index.
IndexedData represents a secondary index for a property path in a given keyspace.
IndexResolver extracts secondary index structures to be applied on a given path, PersistentProperty and value.
Converter implementation that is used to transform values for usage in a particular secondary index.
ObjectMapper based HashMapper implementation that allows flattening.
ValkeySerializer that can read and write JSON using Jackson's and Jackson Databind ObjectMapper.
Defines the contract for Object Mapping readers.
Defines the contract for Object Mapping writers.
Java Serialization ValkeySerializer.
Strategy interface for customizing JedisClientConfig.
Valkey client configuration for jedis.
Builder for Pooling-related JedisClientConfiguration.
Builder for SSL-related JedisClientConfiguration.
ValkeyClusterConnection implementation on top of JedisCluster.
Uses the native JedisCluster api where possible and falls back to direct node communication using Jedis where needed.
 
Jedis specific implementation of ClusterTopologyProvider.
ValkeyConnection implementation on top of Jedis library.
Connection factory creating Jedis based connections.
Converts Exceptions thrown from Jedis to DataAccessExceptions
Converts the value returned by Jedis script eval to the expected ReturnType
 
Helper class to register JSR-310 specific Converter implementations.
 
MessageListener publishing ValkeyKeyExpiredEvents via ApplicationEventPublisher by listening to Valkey keyspace notifications for key expirations.
Options to be used for with SCAN commands.
KeyspaceConfiguration allows programmatic setup of keyspaces and time to live options for certain types.
 
Base MessageListener implementation for listening to Valkey keyspace notifications.
Valkey client configuration for lettuce.
 
Builder for SSL-related LettuceClientConfiguration.
ValkeyClusterConnection implementation on top of Lettuce Valkey client.
Lettuce specific implementation of ClusterCommandExecutor.ClusterCommandCallback.
Lettuce specific implementation of ClusterCommandExecutor.MultiKeyClusterCommandCallback.
ValkeyConnection implementation on top of Lettuce Valkey client.
Strategy interface to control pipelining flush behavior.
State object associated with flushing of the currently ongoing pipeline.
Connection factory creating Lettuce-based connections.
Defines a provider for Lettuce connections.
Extension to LettuceConnectionProvider for providers that allow connection creation to specific nodes.
Lettuce type converters
Converts Lettuce Exceptions to DataAccessExceptions
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.4 for removal with the next major revision.
Valkey client configuration for lettuce using a driver level pooled connection by adding pooling specific configuration to LettuceClientConfiguration.
 
 
 
Message subscription on top of Lettuce.
 
Converts a List of values of one type to a List of values of another type
Valkey list specific operations.
Value object representing the where from part for the LMOVE command.
Value object representing the where to from part for the LMOVE command.
Converts Longs to Booleans
Converts a Map of values of one key/value type to a Map of values of another type
MappingConfiguration is used for programmatic configuration of secondary indexes, key prefixes, expirations and the such.
ValkeyConverter implementation creating flat binary map structure out of a given domain type.
Value object representing a binary Valkey Hash/Object identifier composed from keyspace and object id in the form of keyspace:id.
Value object representing a Valkey Hash/Object identifier composed from keyspace and object id in the form of keyspace:id.
ValkeyEntityInformation implementation using a ValkeyPersistentEntity instance to lookup the necessary information.
A Record within the stream backed by a collection of field/value pairs.
 
Class encapsulating a Valkey message body and its properties.
Listener of messages published in Valkey.
Message listener adapter that delegates the handling of messages to target listener methods via reflection, with flexible message type conversion.
Metrics supported by Valkey.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.4 for removal with the next major revision.
 
A Record within the stream mapped to a single object.
Serializer adapter on top of Spring's O/X Mapping.
PartialUpdate allows to issue individual property updates without the need of rewriting the whole entity.
 
 
IndexDefinition that is based on a property paths.
IndexResolver implementation considering properties annotated with Indexed or paths set up in IndexConfiguration.
Topic pattern matching multiple Valkey channels.
Value object representing a single pending message containing its ID, the consumer that fetched the message and has still to acknowledge it, the time elapsed since the messages last delivery and the the total number of times delivered.
Value object holding detailed information about pending messages in consumer group for a given Range and offset.
Value Object summarizing pending messages in a consumer group.
Exception thrown when there are issues with a resource pool
Repository fragment implementing Valkey Query-by-Example operations.
Utilities for SortQuery implementations.
Radius defined by Distance.
Interface for the cluster commands supported by Valkey executed using reactive infrastructure.
 
 
 
 
 
 
 
 
Valkey Server commands executed in cluster environment using reactive infrastructure.
 
 
 
 
Valkey Geo commands executed using reactive infrastructure.
GEOADD command parameters.
GEODIST command parameters.
GEOHASH command parameters.
GEOPOS command parameters.
GEORADIUSBYMEMBER command parameters.
GEORADIUS command parameters.
GEOSEARCH command parameters.
GEOSEARCHSTORE command parameters.
Reactive Valkey operations for Geo Commands.
Valkey Hash commands executed using reactive infrastructure.
 
ReactiveValkeyConnection.Command for hash-bound operations.
 
 
Reactive Valkey operations for Hash Commands.
Valkey HyperLogLog commands executed using reactive infrastructure.
PFADD command parameters.
PFCOUNT command parameters.
PFMERGE command parameters.
Reactive Valkey operations for working on a HyperLogLog multiset.
Valkey Key commands executed using reactive infrastructure.
MOVE command parameters.
EXPIREAT/PEXPIREAT command parameters.
EXPIRE/PEXPIRE command parameters.
MOVE command parameters.
RENAME command parameters.
Valkey List commands executed using reactive infrastructure.
BLMOVE command parameters.
 
BRPOPLPUSH command parameters.
 
LINDEX command parameters.
LINSERT command parameters.
LMOVE command parameters.
LPOS command parameters.
LREM command parameters.
LSET command parameters.
LPOP/RPOP command parameters.
LPUSH/RPUSH command parameters.
RPOPLPUSH command parameters.
Reactive Valkey operations for List Commands.
Valkey numeric commands executed using reactive infrastructure.
DECRBY command parameters.
HINCRBY command parameters.
INCRBY command parameters.
Valkey Pub/Sub commands executed using reactive infrastructure.
Executes ValkeyScripts using reactive infrastructure.
Valkey Scripting commands executed using reactive infrastructure.
Valkey Server commands executed using reactive infrastructure.
Valkey Set commands executed using reactive infrastructure.
SADD command parameters.
SDIFF command parameters.
SDIFFSTORE command parameters.
SINTER command parameters.
SINTERSTORE command parameters.
SISMEMBER command parameters.
SMISMEMBER command parameters.
SMOVE command parameters.
SPOP command parameters.
SRANDMEMBER command parameters.
SREM command parameters.
SUNION command parameters.
SUNIONSTORE command parameters.
Reactive Valkey operations for Set Commands.
Stream-specific Valkey commands executed using reactive infrastructure.
XACK command parameters.
XADD command parameters.
XDEL command parameters.
 
 
Value Object holding parameters for obtaining pending messages.
XRANGE/XREVRANGE command parameters.
XRANGE/XREVRANGE command parameters.
XTRIM command parameters.
XCLAIM command parameters.
 
Reactive Valkey operations for Stream Commands.
Valkey String commands executed using reactive infrastructure.
APPEND command parameters.
BITCOUNT command parameters.
BITFIELD command parameters.
BITOP command parameters.
 
GETBIT command parameters.
MSET command parameters.
SETBIT command parameters.
SET command parameters.
SETRANGE command parameters.
Subscription for Valkey channels using reactive infrastructure.
Value object for a Valkey channel message.
ReactiveSubscription.Message represents a Valkey channel message within Valkey pub/sub.
Value object for a Valkey channel message received from a pattern subscription.
Generic callback interface for code that operates on a low-level ReactiveValkeyConnection.
 
Valkey connection using reactive infrastructure declaring entry points for reactive command execution.
ReactiveValkeyConnection.CommandResponse implementation for ByteBuffer responses for absent keys.
Base interface for Valkey commands executed with a reactive infrastructure.
Base class for command responses.
ReactiveValkeyConnection.Command for key-bound operations.
ReactiveValkeyConnection.Command for key-bound scan operations like SCAN, HSCAN, SSCAN and ZSCAN.
ReactiveValkeyConnection.CommandResponse implementation for List responses.
 
Thread-safe factory of reactive Valkey connections.
Container providing a stream of ReactiveSubscription.ChannelMessage for messages received via Valkey Pub/Sub listeners.
Interface that specified a basic set of Valkey operations, implemented by ReactiveValkeyTemplate.
Generic callback interface for code that wants to use the same ReactiveValkeyConnection avoiding connection allocation overhead upon each Template API method call.
Central abstraction for reactive Valkey data access implementing ReactiveValkeyOperations.
Reactive Valkey operations for simple (or in Valkey terminology 'string') values.
Valkey Sorted Set commands executed using reactive infrastructure.
BZPOPMIN/BZPOPMAX command parameters.
 
ZADD command parameters.
ZINTER/ZUNION command parameters.
ZINTERSTORE/ZUNIONSTORE command parameters.
ZCOUNT command parameters.
ZDIFF command parameters.
ZDIFFSTORE command parameters.
ZINCRBY command parameters.
ZINTERSTORE command parameters.
ZLEXCOUNT command parameters.
ZMSCORE command parameters.
ZPOPMIN/ZPOPMAX command parameters.
ZRANDMEMBER command parameters.
ZRANGEBYLEX/ZREVRANGEBYLEX command parameters.
ZRANGEBYSCORE/ZREVRANGEBYSCORE.
ZRANGE/ZREVRANGE command parameters.
ZRANGESTORE command parameters.
 
ZRANK/ZREVRANK command parameters.
ZREM command parameters.
ZREMRANGEBYLEX command parameters.
ZREMRANGEBYRANK command parameters.
ZREMRANGEBYSCORE command parameters.
ZSCORE command parameters.
ZUNIONSTORE command parameters.
Reactive Valkey operations for Sorted (ZSet) Commands.
Value object representing read offset for a Stream.
A single entry in the stream consisting of the entry-id and the actual entry-value (typically a collection of field/value pairs).
The id of a single Record within a stream.
ReferenceResolver retrieves Objects marked with Reference from Valkey.
RemoveIndexedData represents a removed index entry from a secondary index for a property path in a given keyspace.
Represents a data type returned from Valkey, currently used to denote the expected return type of Valkey scripting commands
Valkey client agnostic Cursor implementation continuously loading additional results from Valkey server until reaching its starting point zero.
ScanIteration holds the values contained in Valkey Multibulk reply on exectuting SCAN command.
Options to be used for with SCAN commands.
 
Executes ValkeyScripts
RuntimeException thrown when issues occur with ValkeyScripts
Generic exception indicating a serialization/deserialization error.
Utility class with various serialization-related methods.
Callback executing all operations against a surrogate 'session' (basically against the same underlying Valkey connection).
Converts a Set of values of one type to a Set of values of another type preserving item order.
Valkey set specific operations.
PathBasedValkeyIndexDefinition for including property values in a secondary index.
IndexedData implementation indicating storage of data within a Valkey Set.
Internal interface part of the Sort DSL.
Entity containing the parameters for the SORT operation.
Sorting order.
Utility class wrapping the 'LIMIT' setting.
High-level abstraction over a Valkey SORT (generified equivalent of SortParameters).
Simple builder class for constructing SortQuery.
SpelIndexDefinition defines index that is evaluated based on a SpelExpression requires the SpelIndexResolver to be evaluated.
An IndexResolver that resolves IndexedData using a SpelExpressionParser.
 
 
 
 
Value object holding general information about consumer groups associated with a Valkey Stream.
 
Value object holding general information about a Valkey Stream.
StreamListener<K,V extends Record<K,?>>
Listener interface to receive delivery of messages.
Abstraction used by the framework representing a message listener container.
Request to read a Valkey Stream with a Consumer.
Request to read a Valkey Stream.
Value object representing a Stream Id with its offset.
Valkey stream specific operations.
Options for reading messages from a Valkey Stream.
StreamReceiver<K,V extends Record<K,?>>
A receiver to consume Valkey Streams using reactive infrastructure.
Options for StreamReceiver.
StreamRecords provides utilities to create specific Record instances.
Builder for Record.
A Record within the stream backed by a collection of String field/value pairs.
Converts Strings to DataTypes
Converts Strings to Properties
Converter implementation to create one ValkeyClientInfo per line entry in given String array.
Convenience extension of ValkeyConnection that accepts and returns Strings instead of byte arrays.
String-friendly ZSet tuple.
Simple String to byte[] (and back) serializer.
String-focused extension of ValkeyTemplate.
Subscription for Valkey channels.
The Subscription is the link to the actual running Task.
Listener for subscription notifications.
The actual Task to run within the StreamMessageListenerContainer.
The Task.State defining the lifecycle phase the actual Task.
Helper class featuring methods for calculating Valkey timeouts
TimeToLive marks a single numeric property on aggregate root to be used for setting expirations in Valkey.
TimeToLiveAccessor extracts the objects time to live used for EXPIRE.
DataRetrievalFailureException thrown when following cluster redirects exceeds the max number of edges.
Topic for a Valkey message.
Converts the results of transaction exec using a supplied Queue of FutureResults.
ZSet tuple.
Base class for ValkeyTemplate implementations defining common properties.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.3, will be removed in a future revision in favor of Spring's Assert utility.
 
Atomic double backed by Valkey.
Atomic integer backed by Valkey.
Atomic long backed by Valkey.
Cache implementation using Valkey as the underlying store for cache data.
Immutable ValkeyCacheConfiguration used to customize ValkeyCache behavior, such as caching null values, computing cache key prefixes and handling binary serialization.
CacheManager implementation for Valkey backed by ValkeyCache.
Builder for creating a ValkeyCacheManager.
ValkeyCacheWriter provides low-level access to Valkey commands (SET, SETNX, GET, EXPIRE,...) used for caching.
Function to compute the time to live from the cache key and value.
Callback interface for Valkey 'low level' code.
ValkeyClientInfo provides general and statistical information about client connections.
 
 
Callback interface for low level operations executed against a clustered Valkey environment.
Interface for the cluster commands supported by Valkey.
 
Provides access to ValkeyClusterCommands and the segregated command interfaces.
Configuration class used to set up a ValkeyConnection via ValkeyConnectionFactory for connecting to Valkey Cluster.
ValkeyClusterConnection allows sending commands to dedicated nodes within the cluster.
Representation of a Valkey server within the cluster.
 
 
 
Builder for creating new ValkeyClusterNode.
 
Valkey extension for the Collection contract.
Factory bean that facilitates creation of Valkey-based collections.
Collection types supported by this factory.
Enumeration of well-known Valkey commands.
Interface defining the commands supported by Valkey.
Provides access to ValkeyCommands and the segregated command interfaces.
Marker interface for configuration classes related to Valkey connection setup.
Configuration interface suitable for Valkey cluster environments.
Configuration interface suitable for single node valkey connections using local unix domain socket.
Configuration interface suitable for Valkey Sentinel environments.
Configuration interface suitable for Valkey master/replica environments with fixed hosts.
ValkeyConfiguration part suitable for configurations that may use authentication when connecting.
ValkeyConfiguration part suitable for configurations that use a specific database.
ValkeyConfiguration part suitable for configurations that use native domain sockets for connecting.
ValkeyConfiguration part suitable for configurations that use host/port combinations for connecting.
ValkeyConfiguration part suitable for configurations that may use authentication when connecting.
A connection to a Valkey server.
Connection-specific commands supported by Valkey.
Thread-safe factory of Valkey connections.
Fatal exception thrown when the Valkey connection fails completely.
Helper class that provides static methods for obtaining ValkeyConnection from a ValkeyConnectionFactory.
Subinterface of ValkeyConnection to be implemented by ValkeyConnection proxies.
Valkey specific EntityConverter.
Factory interface to create RedisCredentialsProvider from a ValkeyConfiguration.
Default anonymous RedisCredentials without username/password.
Value object to capture custom conversion.
Data object holding Bucket representing the domain object to be stored in a Valkey hash.
Strategy interface that specifies a deserializer that can deserialize a binary element representation stored in Valkey into an object.
Strategy interface that specifies a serializer that can serialize an element to its binary representation to be used as Valkey protocol payload.
 
Geo-specific Valkey commands.
Metrics supported by Valkey.
Arguments to be used with ValkeyGeoCommands.
A flag to be used.
ValkeyGeoCommands.GeoLocation representing a Point associated with a name.
Additional arguments (like count/sort/...) to be used with ValkeyGeoCommands.
 
Additional arguments (like count/sort/...) to be used with ValkeyGeoCommands.
Additional arguments (like count/sort/...) to be used with ValkeyGeoCommands.
Configuration interface for Valkey-Glide client settings.
Record representing OpenTelemetry configuration for Valkey-Glide client.
ValkeyClusterConnection implementation on top of GlideClusterClient.
Implementation of ValkeyKeyCommands for Valkey-Glide in cluster mode.
Implementation of ValkeyClusterServerCommands for Valkey-Glide.
Implementation of ValkeySetCommands for Valkey Glide in cluster mode.
Implementation of ValkeyStringCommands for Valkey-Glide.
Connection to a Valkey server using Valkey-Glide client.
Connection factory creating Valkey Glide based connections.
Converter utilities for mapping between Spring Data Valkey types and Valkey-Glide types.
A functional interface used to convert raw driver results (returned as ValkeyGlideConverters.ResultMapper) into a strongly typed result R.
Converts Valkey-Glide exceptions to Spring DAO exceptions.
Utility methods for working with Valkey-Glide CompletableFuture objects.
Functional interface for supplying a CompletableFuture.
Implementation of ValkeyGeoCommands for Valkey-Glide.
Implementation of ValkeyHashCommands for Valkey-Glide.
Implementation of ValkeyHyperLogLogCommands for Valkey-Glide.
Implementation of ValkeyKeyCommands for Valkey-Glide.
Implementation of ValkeyListCommands for Valkey-Glide.
Implementation of ValkeyScriptingCommands for Valkey-Glide.
Implementation of ValkeyServerCommands for Valkey-Glide.
Implementation of ValkeySetCommands for Valkey-Glide.
Implementation of ValkeyStreamCommands for Valkey-Glide.
Implementation of ValkeyStringCommands for Valkey-Glide.
Utility methods for Valkey-Glide connection implementation.
Exception thrown when a Valkey transaction is aborted due to a WATCH conflict.
Implementation of ValkeyZSetCommands for Valkey-Glide.
Factory for ValkeyGlideZSetCommands.
ValkeyHash marks Objects as aggregate roots to be stored in a Valkey hash.
Hash-specific commands supported by Valkey.
HyperLogLog specific commands supported by Valkey.
Base IndexDefinition implementation.
 
 
 
 
 
Exception thrown when subscribing to an expired/dead Subscription.
Key-specific commands supported by Valkey.
ValkeyKeyExpiredEvent is a Valkey specific ApplicationEvent published when a particular key in Valkey expires.
Valkey specific ApplicationEvent published when a key expires in Valkey.
Valkey specific KeyValueAdapter implementation.
 
Configuration flag controlling storage of phantom keys (shadow copies) of expiring entities to read them later when publishing ValkeyKeyspaceEvent.
CdiBean to create ValkeyKeyValueAdapter instances.
Valkey specific implementation of KeyValueTemplate.
Valkey specific KeyValueCallback.
CdiBean to create ValkeyKeyValueTemplate instances.
Valkey extension for the List contract.
List-specific commands supported by Valkey.
List move direction.
List insertion position.
Exception thrown when the execution of a listener method failed.
Map view of a Valkey hash.
Valkey specific MappingContext.
Container providing asynchronous behaviour for Valkey message listeners.
 
 
Builder for creating new ValkeyNode.
Deprecated, for removal: This API element is subject to removal in a future version.
since 3.4 for removal with the next major revision.
Simple set of operations required to run queries against Valkey.
 
 
Interface that specified a basic set of Valkey operations, implemented by ValkeyTemplate.
Valkey-specific implementation of KeyValuePartTreeQuery supporting projections.
Value object which may or may not contain a Valkey password.
Valkey specific PersistentEntity.
Valkey specific PersistentProperty implementation.
Exception thrown when executing/closing a pipeline that contains one or multiple invalid/incorrect statements.
Properties extension for a Valkey back-store.
PubSub-specific Valkey commands.
AbstractQueryCreator implementation for Valkey.
Valkey specific ImportBeanDefinitionRegistrar.
CdiRepositoryBean to create Valkey repository instances.
RepositoryConfigurationExtension for Valkey.
CDI extension to export Valkey repositories.
RepositoryFactorySupport specific of handing Valkey KeyValueRepository.
ValkeyRepositoryFactoryBean<T extends org.springframework.data.repository.Repository<S,ID>,S,ID>
Adapter for Springs FactoryBean interface to allow easy setup of ValkeyRepositoryFactory via Spring configuration.
RuntimeHintsRegistrar for Valkey operations and repository support.
A script to be executed using the Valkey scripting support available as of version 2.6
Scripting commands.
Valkey Sentinel-specific commands.
Configuration class used to set up a ValkeyConnection with ValkeyConnectionFactory for connecting to Valkey Sentinel(s).
 
Serialization context for reactive use.
Typed serialization tuple.
Basic interface serialization and deserialization of Objects to byte arrays (binary data).
 
 
Server-specific commands supported by Valkey.
 
 
 
Valkey extension for the Set contract.
Set-specific commands supported by Valkey.
Configuration class used for setting up ValkeyConnection via ValkeyConnectionFactory connecting to single Valkey using a local unix domain socket.
Configuration class used to set up a ValkeyConnection with ValkeyConnectionFactory for connecting to a single node Valkey instance.
Configuration class used for setting up ValkeyConnection via ValkeyConnectionFactory using the provided Master / Replica configuration to nodes know to not change address.
Basic interface for Valkey-based collections.
Stream-specific Valkey commands.
Additional options applicable for XADD command.
 
 
Value Object holding parameters for obtaining pending messages.
String/Value-specific commands supported by Valkey.
 
SET command arguments for NX, XX.
Exception thrown when issuing commands on a connection that is subscribed and waiting for events.
Exception thrown when we can't classify a Valkey exception into one of Spring generic data access exceptions.
Helper class that simplifies Valkey data access code.
Transaction/Batch specific commands supported by Valkey.
Valkey-specific TypeMapper exposing that Bucket.BucketPropertyPaths might contain a type key.
Valkey ZSet (or sorted set (by weight)).
ZSet(SortedSet)-specific commands supported by Valkey.
Deprecated.
since 3.0, use Limit instead.
Deprecated.
since 3.0, use Range or ValkeyZSetCommands.Range.toRange() instead.
 
ZADD specific arguments.
 
ValueEncoding is used for the Valkey internal data representation used in order to store the value associated with a key.
Default ValueEncoding implementation of encodings used in Valkey.
Valkey operations for simple (or in Valkey terminology 'string') values.
Value object encapsulating a multiplication factor for each input sorted set.
Valkey ZSet/sorted set specific operations.
Typed ZSet tuple.