spring-projects/spring-data-redis

This system is a Java library for interacting with Redis, providing connection abstractions for standalone, Sentinel, and Cluster topologies via Jedis and Lettuce drivers. It offers high-level APIs for caching, Pub/Sub messaging, Streams, and repository-style data access, while supporting reactive programming models and Kotlin coroutines. The library also includes utilities for atomic operations, collections, and serialization, with built-in support for Ahead-of-Time compilation in native environments.

32 changes.

This period focused on upgrading Spring Data Redis to version 4.0, introducing foundational support for Redis Sentinel and Cluster modes alongside a comprehensive migration to Jackson 3 and reactive programming models. The work involved refactoring core connection and listener infrastructures, adding granular key expiration and atomic operation APIs, and establishing robust test coverage for the new features.

29 changes.

This period focused on establishing a comprehensive repository and mapping layer for Spring Data Redis, introducing features like Query-by-Example, DTO projections, and reactive Lua script execution. Significant work included refactoring the core mapping subsystem to align with Spring Data KeyValue APIs, adding initial support for the Lettuce driver with Redis Cluster, and expanding test coverage across conversion, caching, and CDI integration components.

23 changes.

This period focused on expanding Spring Data Redis capabilities by introducing native support for Redis Streams, Kotlin Coroutines, and geospatial queries. Significant effort was also dedicated to enabling Ahead-Of-Time (AOT) compilation for native image execution and migrating the project's build and documentation infrastructure to modern standards.

8 changes.

This period focused on introducing comprehensive support for Redis Pub/Sub messaging and Redis JSON operations. Key additions include annotation-driven listener registration, a new messaging template leveraging Spring Messaging abstractions, and low-level connection abstractions for JSON data structures. The work was accompanied by extensive test coverage and Docker-based infrastructure to validate these new features.

A new AOT configuration class, LettuceRuntimeHints, has been introduced to register reflection hints for the Lettuce Redis client. This ensures that io.lettuce.core.RedisClient and its associated StandaloneConnectionProvider are properly handled during native image compilation, resolving potential runtime issues when running in AOT environments.

src/main/java/org/springframework/data/redis/connection/lettuce/aot · high confidence

The application now includes Ahead-Of-Time (AOT) compilation support for Redis repositories. This is achieved by registering specific runtime hints for both the core Redis data module and the Lettuce connection factory, ensuring that necessary classes and proxies are available at runtime when running in native or AOT-compiled environments.

src/main/resources/META-INF/spring · high confidence

This change introduces the \RedisRuntimeHints\ class, which registers the necessary reflection, serialization, and proxy hints required for Spring Data Redis to function correctly in native images. By explicitly declaring support for core components such as \RedisTemplate\, \RedisCacheManager\, and various command interfaces (including \RedisJsonCommands\), as well as key-value adapter support and bound operations, this configuration ensures that AOT tools can correctly analyze and prepare Redis dependencies at build time, preventing runtime failures in native execution environments.

src/main/java/org/springframework/data/redis/aot · high confidence

A new XSD schema file (spring-redis-1.0.xsd) has been added to define the configuration elements for Spring Data Redis support. This allows users to configure Redis listener containers using XML 'shortcut' style, specifying attributes such as connection factory, task executors, topic serializers, and listener bean references directly in their Spring configuration files.

src/main/resources/org · high confidence

This change introduces the configuration infrastructure for annotation-driven Redis Pub/Sub listeners in the \org.springframework.data.redis.config\ package. It adds the \RedisListenerBootstrapConfiguration\ to register the \RedisListenerAnnotationBeanPostProcessor\ and \RedisListenerEndpointRegistry\ when \@EnableRedisListeners\ is used. It also defines the core endpoint model (\RedisListenerEndpoint\, \AbstractRedisListenerEndpoint\, \SimpleRedisListenerEndpoint\, and \MethodRedisListenerEndpoint\) and the \RedisListenerEndpointRegistrar\ to manage the registration and lifecycle of these endpoints. Additionally, it provides the \RedisListenerConfigurer\ interface for customizing converters and argument resolvers, and updates the XML namespace handlers (\RedisNamespaceHandler\) to support the \\<listener-container\>\ and \\<collection\>\ elements.

src/main/java/org/springframework/data/redis/config · high confidence

Spring Data Redis now supports declarative Pub/Sub listeners via the new @EnableRedisListeners annotation and @RedisListener method annotation. By adding @EnableRedisListeners to a configuration class, Spring automatically detects methods annotated with @RedisListener on managed beans and registers them as endpoints against a RedisMessageListenerContainer (defaulting to the bean named 'redisMessageListenerContainer'). The @RedisListener annotation allows specifying the target topic and container, supports flexible method signatures (including Spring Messaging abstractions like @Payload and @Header), and enables content-type negotiation via the 'consumes' attribute. This change introduces the annotation model and the bean post-processor that wires these annotated methods into the Redis listener infrastructure.

src/main/java/org/springframework/data/redis/annotation · high confidence

The application now supports configuring Redis repositories and the Redis XML namespace via Spring's auto-configuration mechanism. This is achieved by registering the RedisRepositoryFactory in spring.factories, mapping the redis namespace to its handler in spring.handlers, and providing schema definitions (including HTTPS support) in spring.schemas. Additionally, IDE tooling metadata is added to support auto-completion and validation for the redis namespace.

src/main/resources/META-INF · high confidence

This change introduces the initial implementation of the Lettuce driver for Redis Cluster, adding the core connection provider, client configuration, and command-specific wrappers (Geo, Hash, HyperLogLog, JSON, Key, List, Server, and ZSet) to the \org.springframework.data.redis.connection.lettuce\ package. Users can now connect to and execute commands against a Redis Cluster using the Lettuce client library.

src/main/java/org/springframework/data/redis/connection/lettuce · high confidence

The Redis core API now exposes dedicated expiration management through new \BoundKeyExpirationOperations\ and \BoundHashFieldExpirationOperations\ interfaces. Users can access these via \BoundKeyOperations.expiration()\ to perform fine-grained time-to-live operations on individual keys or specific hash fields, supporting modern \Duration\ and \Instant\ types alongside legacy \TimeUnit\ for backward compatibility.

src/main/java/org/springframework/data/redis/core · high confidence

This release adds the \org.springframework.data.redis.stream\ package, providing two new APIs for consuming Redis Streams. The synchronous \StreamMessageListenerContainer\ allows polling for messages using an \Executor\-based event loop, supporting configurable read offsets, consumer groups, and error handling. The reactive \StreamReceiver\ delivers stream records as a \Flux\, enabling integration with reactive pipelines. Both implementations support standalone consumption, consumer-group-based consumption with manual or auto-acknowledgment, and customizable serialization strategies.

src/main/java/org/springframework/data/redis/stream · high confidence

The \org.springframework.data.redis.support.collections\ package now provides a set of classes that expose Redis data structures as standard Java collections. This includes \DefaultRedisList\, \DefaultRedisSet\, \DefaultRedisZSet\, \DefaultRedisMap\, and \RedisProperties\, which implement the \List\, \Set\, \SortedSet\, \Map\, and \Properties\ interfaces respectively. A \RedisCollectionFactoryBean\ is also provided to facilitate the creation of these collections in Spring applications. These implementations allow developers to interact with Redis using familiar Java collection APIs while leveraging Redis as the underlying storage.

src/main/java/org/springframework/data/redis/support/collections · high confidence

The \src/main/java/org/springframework/data/redis/core/convert\ package now contains the core implementation for mapping domain objects to Redis data structures. This includes the \MappingRedisConverter\ for serializing and deserializing entities, \BinaryConverters\ and \Jsr310Converters\ for handling type conversions (including Java 8 date/time types), and \Bucket\ as the underlying data bag for Redis hash structures. Additionally, the package introduces \IndexResolver\ and related classes (\CompositeIndexResolver\, \PathIndexResolver\, \GeoIndexedPropertyValue\) to support secondary indexing and geo-spatial lookups, along with \KeyspaceConfiguration\ and \MappingConfiguration\ for programmatic setup of keyspaces and index definitions.

src/main/java/org/springframework/data/redis/core/convert · high confidence

Adds a new reactive scripting API for Spring Data Redis, allowing users to execute Lua scripts asynchronously via \ReactiveScriptExecutor\ and \Flux\<T\>\ return types. This complements the existing synchronous \ScriptExecutor\ by providing non-blocking script execution that automatically handles \EVALSHA\ caching with fallback to \EVAL\, while ensuring reactive streams are properly terminated on null values or errors.

src/main/java/org/springframework/data/redis/core/script · high confidence

This change introduces the core domain interfaces and implementation for Redis repository support. It adds the \RedisEntityInformation\ interface, which extends the standard Spring Data \EntityInformation\, and the \MappingRedisEntityInformation\ class, which implements this interface using a \RedisPersistentEntity\ to resolve entity metadata and validates that an explicit ID field is present. The package is also annotated with JSpecify's \@NullMarked\ to enforce nullness checks.

src/main/java/org/springframework/data/redis/repository/core · high confidence

This release adds Kotlin-specific extensions for all reactive Redis operations (Geo, Hash, HyperLogLog, List, Set, Stream, Value, and ZSet), allowing developers to use Kotlin Coroutines (suspend functions) and Kotlin Flows instead of reactive streams. It also introduces reified generic helpers for creating RedisScript and PartialUpdate instances, and provides type-casting extensions for JSON operation results.

src/main/kotlin · high confidence

This release introduces several new APIs to enhance Redis cache configuration and management. Users can now define custom key prefixes using the new CacheKeyPrefix interface and the prefixCacheNameWith() method on RedisCacheConfiguration. Batch clearing of cache keys is supported via the new BatchStrategy interface and BatchStrategies utility, offering both KEYS and SCAN-based strategies. Additionally, per-cache statistics are now available through the CacheStatistics and CacheStatisticsCollector interfaces, allowing monitoring of hits, misses, and lock wait times. The RedisCacheManager and RedisCacheWriter also expose new configuration options for cache locking, statistics collection, and batch strategies.

src/main/java/org/springframework/data/redis/cache · high confidence

The \org.springframework.data.redis.connection.json\ package now provides the core data structures and interfaces for interacting with Redis JSON. This includes the \JsonPath\ interface for navigating JSON documents using RedisJSON 2.0 syntax, the \JsonValue\ interface with factory methods for creating JSON representations of Java types (booleans, numbers, strings, nulls, and raw bytes), and the \JsonSetCondition\ enum to control \JSON.SET\ behavior (upsert, if-exists, if-not-exists). These classes form the low-level connection layer for Redis JSON operations.

src/main/java/org/springframework/data/redis/connection/json · high confidence

This release introduces a new \RedisMessageSendingTemplate\ and the \RedisMessageSendingOperations\ interface in the \org.springframework.data.redis.messaging\ package, providing a Spring Messaging-oriented way to publish messages to Redis Pub/Sub channels. Unlike the existing \RedisOperations.convertAndSend\ which relies on the underlying \RedisTemplate\'s value serializer, this new template delegates payload conversion to a \MessageConverter\ (defaulting to \RedisMessageConverters.createMessageConverter()\) and resolves channel destinations via a \TopicResolver\ backed by \TopicDestinationResolver\. This allows users to leverage Spring's standard messaging abstractions, including content-type headers and post-processors, for Redis Pub/Sub communication.

src/main/java/org/springframework/data/redis/messaging · high confidence

Spring Data Redis 4.1 introduces a new \org.springframework.data.redis.listener.support\ package that provides utilities for Redis Pub/Sub messaging. This includes a \TopicResolver\ strategy interface with a \SimpleTopicResolver\ implementation that automatically distinguishes between channel and pattern topics (detecting glob characters like \\*\, \?\, \\[\) and caches resolutions via \CachingTopicResolver\. Additionally, a \PubSubHeaders\ interface is added to define standard message header keys (\topic\, \channel\, \pattern\) for accessing Redis Pub/Sub attributes in generic message headers.

src/main/java/org/springframework/data/redis/listener/support · high confidence

Introduces a new set of connection-layer types for Redis Streams, including record interfaces (Record, MapRecord, ObjectRecord, ByteRecord, ByteBufferRecord) for representing stream entries, value objects for stream metadata and consumer groups (StreamInfo, PendingMessage, PendingMessages, PendingMessagesSummary, Consumer), and configuration helpers (StreamOffset, ReadOffset, StreamReadOptions). These classes provide the foundational data structures and serialization/deserialization support for interacting with Redis Streams.

src/main/java/org/springframework/data/redis/connection/stream · high confidence

This change introduces new domain types in the \org.springframework.data.redis.core.types\ package to support advanced Redis operations. \Expiration\ and \Expirations\ provide structured handling for key time-to-live (TTL) values, supporting various time units, Unix timestamps, and bulk TTL retrieval, which enables more precise control over key expiration in SET and related commands. Additionally, \RedisClientInfo\ offers a structured way to parse and access detailed statistics about Redis client connections, such as idle time, buffer usage, and subscription counts, facilitating better client monitoring and management.

src/main/java/org/springframework/data/redis/core/types · high confidence

This change introduces the \org.springframework.data.redis.listener.adapter\ package, adding \MessageListenerAdapter\ for delegating Redis messages to target listener methods via reflection and serialization, and \HandlerMethodMessageListenerAdapter\ for integrating with Spring Messaging's \InvocableHandlerMethod\. It also includes \RedisListenerExecutionFailedException\ for error handling and updates the package-level null-safety annotations using JSpecify.

src/main/java/org/springframework/data/redis/listener/adapter · high confidence

The \org.springframework.data.redis.support.atomic\ package now includes \RedisAtomicInteger\, \RedisAtomicLong\, and \RedisAtomicDouble\ classes that mirror \java.util.concurrent.atomic\ types using Redis keys. These classes support initialization with an optional initial value, standard atomic operations (get, set, getAndSet, increment/decrement), and compare-and-set (CAS) operations via a new \CompareAndSet\ helper that uses Redis \WATCH\/\MULTI\/\EXEC\ transactions. Additionally, the package is now marked as null-safe using JSpecify annotations.

src/main/java/org/springframework/data/redis/support/atomic · high confidence

This change introduces the foundational connection classes for Redis Sentinel and Cluster modes. It adds AbstractRedisConnection to manage Sentinel connections with active node selection and caching, and a suite of cluster-specific components (ClusterCommandExecutor, ClusterTopology, ClusterSlotHashUtil) to handle command execution across cluster nodes, topology management, and slot hashing. Additionally, it includes new API types like BitFieldSubCommands for complex bit operations and CompareCondition for conditional value operations.

src/main/java/org/springframework/data/redis/connection · high confidence

Added new domain classes in the \org.springframework.data.redis.domain.geo\ package to support the Redis \GEOSEARCH\ and \GEOSEARCHSTORE\ commands. This includes \GeoReference\ for defining search centers (by member or coordinate), \GeoShape\ with implementations \RadiusShape\ and \BoxShape\ (using \BoundingBox\) for defining search predicates, \GeoLocation\ for representing stored geo entries, and \Metrics\ enum for supported distance units. These classes provide the type-safe domain model required to construct geo queries.

src/main/java/org/springframework/data/redis/domain · high confidence

The package now provides a core HashMapper interface and several concrete implementations for mapping Java objects to and from Redis hashes. BeanUtilsHashMapper offers a simple mapping using Apache Commons BeanUtils, while DecoratingStringHashMapper allows wrapping other mappers to flatten values into strings. ObjectHashMapper leverages the MappingRedisConverter to support nested properties and simple types. Jackson2HashMapper is included but deprecated in favor of the new JacksonHashMapper, which uses Jackson 3 (tools.jackson) and supports both hierarchical and flattened dot-notation mapping with configurable polymorphic type validation.

src/main/java/org/springframework/data/redis/hash · high confidence

This change introduces the \org.springframework.data.redis.connection.util\ package, providing internal support classes for Redis connection management. It adds \AbstractSubscription\ to standardize channel and pattern subscription tracking and lifecycle management, \ByteArrayWrapper\ and \ByteArraySet\ to enable correct equality and hashing for byte arrays in collections, and \DecodeUtils\ (deprecated since 4.0) for Base64 encoding/decoding operations.

src/main/java/org/springframework/data/redis/connection/util · high confidence

This change introduces a new \org.springframework.data.redis.util\ package containing three new utility classes. \ByteUtils\ provides methods for concatenating and splitting byte arrays, merging arrays, and extracting bytes from \ByteBuffer\ while respecting position and limits. \KeyUtils\ offers a generic \splitKeys\ method to separate the first key from remaining keys in an array, supporting composite key operations. \RedisClientLibraryInfo\ enables client identification via \CLIENT SETINFO\ by exposing the framework name and version. These utilities support internal driver implementations and general Redis data manipulation tasks.

src/main/java/org/springframework/data/redis/util · high confidence

The \org.springframework.data.redis.listener\ package has been significantly restructured to improve API usability and add reactive capabilities. A new \Topic\ abstraction with \ChannelTopic\ and \PatternTopic\ implementations provides a cleaner way to define subscription targets, replacing direct string usage. The synchronous \RedisMessageListenerContainer\ has been revised to support \SubscriptionListener\ callbacks, allowing applications to be notified when subscriptions are established or removed, and includes improved lifecycle management and error handling. Additionally, a new \ReactiveRedisMessageListenerContainer\ has been introduced to support non-blocking, reactive Pub/Sub message streams via Project Reactor, offering \receive\ and \receiveLater\ methods for subscribing to channels and patterns. Existing listeners like \KeyspaceEventMessageListener\ and \KeyExpirationEventMessageListener\ have been updated to work with these new container and topic structures.

src/main/java/org/springframework/data/redis/listener · high confidence

Redis repositories now support Query-by-Example (QBE) queries, allowing users to find entities by providing a probe instance with example values, and support for DTO projections, enabling derived query methods to return data mapped to specific DTO interfaces or classes rather than full entity objects. These capabilities are implemented via new query execution components in the repository query package, including the ExampleQueryMapper for translating QBE probes into Redis operations, the RedisPartTreeQuery for handling projection post-processing, and the RedisQueryCreator for parsing derived query methods.

src/main/java/org/springframework/data/redis/repository/query · high confidence

Redis repositories now support Query-by-Example (QBE) operations. The \RedisRepositoryFactory\ has been updated to detect when a repository interface extends \QueryByExampleExecutor\ and automatically injects the \QueryByExampleRedisExecutor\ implementation. This allows users to query Redis data using \Example\ objects, enabling flexible, pattern-based searches without writing explicit query methods.

src/main/java/org/springframework/data/redis/repository/support · high confidence

The .settings/org.eclipse.jdt.core.prefs file, which previously configured the Eclipse IDE to compile Java source and target platforms at version 1.5, has been deleted. This change removes the project-specific Eclipse compiler settings, likely as part of a broader cleanup to eliminate non-portable IDE configuration files or to shift build configuration to a different tool.

.settings · high confidence

The Redis-specific datastore template implementation has been removed from the codebase. This change eliminates the legacy Redis integration component that previously extended the abstract datastore template, effectively removing support for this specific key-value store abstraction in this module.

src/main/java/org/springframework/datastore · high confidence

The CDI integration for Spring Data Redis repositories has been migrated to Jakarta EE 9, replacing javax.enterprise imports with jakarta.enterprise equivalents. This change updates the underlying CDI bean wrappers (CdiBean, RedisRepositoryBean, etc.) to use the new Jakarta namespace, ensuring compatibility with modern Jakarta EE containers while preserving the existing repository injection and lifecycle management behavior.

src/main/java/org/springframework/data/redis/repository/cdi · high confidence

The serializer package now includes new Jackson 3-based implementations, specifically \GenericJacksonJsonRedisSerializer\ and \JacksonJsonRedisSerializer\, which utilize the \tools.jackson\ namespace. To support this transition, the previous Jackson 2-based classes (\GenericJackson2JsonRedisSerializer\, \Jackson2JsonRedisSerializer\, \Jackson2ObjectReader\, and \Jackson2ObjectWriter\) have been marked as deprecated for removal in version 4.0. Additionally, the \DefaultRedisMessageConverters\ utility has been updated to detect and prioritize Jackson 3 (\tools.jackson.databind.ObjectMapper\) over Jackson 2 when constructing default message converters for Redis listener endpoints.

src/main/java/org/springframework/data/redis/serializer · high confidence

The service provider configuration for the CDI extension has been updated to use the Jakarta EE 9 namespace. The file \src/main/resources/META-INF/services/jakarta.enterprise.inject.spi.Extension\ now registers \org.springframework.data.redis.repository.cdi.RedisRepositoryExtension\, replacing the previous Java EE 8 path (\javax.enterprise.inject.spi.Extension\). This change ensures the Redis repository CDI extension is correctly discovered and loaded in Jakarta EE 9+ environments.

src/main/resources/META-INF/services · high confidence

The Maven build now uses the Spring Develocity Conventions extension (version 0.0.26) to connect to ge.spring.io for build analytics and caching. Additionally, new JVM arguments have been added to export and open internal JDK compiler and base packages, ensuring compatibility with the build tooling and extensions.

.mvn · high confidence

The reference documentation has been restructured to use the Antora static site generator. This migration introduces a new navigation structure (nav.adoc), links example code from the test sources via a symlink, and includes an appendix listing supported Redis commands. It also updates the observability section to reflect the removal of the custom MicrometerTracingAdapter in favor of Lettuce's native Micrometer support.

src/main/antora/modules/ROOT · high confidence

The ZSet connection API now exposes dedicated top-level types for core concepts: the Aggregate enum defines SUM, MIN, and MAX aggregation modes; the Tuple interface and DefaultTuple implementation represent sorted set members with scores and raw byte values; and the Weights value object manages multiplication factors for input sorted sets. These types, located in the org.springframework.data.redis.connection.zset package, provide a structured, null-safe foundation for ZSet operations using JSpecify annotations.

src/main/java/org/springframework/data/redis/connection/zset · high confidence

The Redis mapping layer has been restructured to integrate with the Spring Data KeyValue abstraction. This introduces new core classes—BasicRedisPersistentEntity, RedisPersistentEntity, RedisPersistentProperty, and RedisMappingContext—which replace the previous implementation to support unified key-space resolution, explicit Time-To-Live (TTL) property handling, and improved ID property detection. Users benefit from consistent mapping behavior aligned with the broader Spring Data Commons, including better support for partial updates and nullable API validation.

src/main/java/org/springframework/data/redis/core/mapping · high confidence

The \@EnableRedisRepositories\ annotation now exposes configuration attributes that allow users to specify a custom \RedisMessageListenerContainer\ bean for keyspace event subscriptions and control whether shadow copies of expiring entities are stored. Additionally, a custom \BeanNameGenerator\ can be provided to influence how repository beans are named during context initialization.

src/main/java/org/springframework/data/redis/repository/configuration · high confidence

The \src/main/java/org/springframework/data/redis/connection/convert\ package has been restructured to consolidate common type conversion logic. A new \Converters\ utility class now provides static methods for converting Redis responses (such as \INFO\ output, \CLUSTER NODES\ lines, and boolean/status replies) and includes generic converters for \List\, \Map\, and \Set\ types. Previously existing converter classes (e.g., \LongToBooleanConverter\, \StringToDataTypeConverter\, \StringToPropertiesConverter\) are now deprecated in favor of using these new static methods or generic converter instances, streamlining the API for handling Redis data types.

src/main/java/org/springframework/data/redis/connection/convert · high confidence

The Redis module's exception hierarchy has been restructured to align with Spring Data conventions. New specific exceptions for cluster operations—ClusterRedirectException, ClusterStateFailureException, and TooManyClusterRedirectionsException—have been introduced to provide clearer error context for cluster-aware applications. The legacy RedisConnectionFactory class has been removed and replaced by a simplified RedisSystemException for unclassified errors. Additionally, the exception translation strategy has been refactored into a modular interface (ExceptionTranslationStrategy) with PassThrough and Fallback implementations, allowing for more flexible error handling. Null-safety annotations from JSpecify have been added throughout the package to improve API validation.

src/main/java/org/springframework/data/redis · high confidence

The project now includes a Maven wrapper (mvnw/mvnw.cmd) to ensure consistent builds without requiring a pre-installed Maven, and replaces legacy Eclipse project files (.classpath, .project) with a modern .gitignore. Additionally, a Makefile is introduced to manage local integration testing by spinning up Redis instances (Standalone, Sentinel, Cluster) via Docker Compose, simplifying the developer environment setup.

(repo-wide) · high confidence

Added CDI integration tests for Redis repositories; Added Docker Compose test infrastructure for Redis environments; Added JUnit 5 extension for managing Jedis connection factories in tests; Added Lua scripts for Redis test resources; Added example applications for reactive and synchronous Redis usage; Added integration and unit tests for Lettuce Redis connection handling; Added integration and unit tests for Redis Streams support; Added integration and unit tests for Redis atomic counters; Added integration and unit tests for Redis listener configuration and endpoint registration; Added integration tests for BoundKeyOperations; Added integration tests for Lettuce DefaultScriptExecutor; Added integration tests for QueryByExampleRedisExecutor; Added integration tests for Redis repository cluster support and custom type mapping; Added test configuration resources for Redis integration tests; Added test infrastructure and utilities for Spring Data Redis; Added test logging configuration files; Added test resources for Redis collection support; Added test support utilities for Redis integration tests; Added tests for Redis HashMapper implementations; Added tests for Redis collections; Added tests for Redis script execution; Added tests for annotation-driven Redis Pub/Sub listeners; Added unit and integration tests for Redis listener adapters; Added unit tests for BoundingBox; Added unit tests for ByteUtils and a ConnectionVerifier test utility; Added unit tests for Kotlin Redis extensions; Added unit tests for MappingRedisEntityInformation; Added unit tests for Redis cluster node conversion; Added unit tests for Redis core types; Added unit tests for Redis mapping and TTL configuration; Added unit tests for Redis repository configuration and registration; Added unit tests for Redis repository query mapping and creation; Added unit tests for Redis serializer components; Added unit tests for RedisMessageSendingTemplate; Added unit tests for SimpleTopicResolver; Added unit tests for StreamReadOptions; Comprehensive integration and unit tests for Redis connection operations; Expanded test coverage for Jedis Redis connection integration; Expanded test coverage for Redis caching components; Expanded test coverage for Redis core operations and infrastructure; Expanded test coverage for Redis listener containers; Expanded unit test coverage for Redis core conversion and indexing components; New JUnit 5 test condition annotations for Redis integration tests; New JUnit 5 test extensions for Redis connection management; New test utility classes for Redis integration testing.

The underlying Jedis client library has been upgraded to version 8.0.0. This update brings the latest features, performance improvements, and bug fixes from the Jedis project to Spring Data Redis, ensuring compatibility with modern Redis server versions and enhanced stability for cluster and standalone connections.

src/main/java/org/springframework/data/redis/connection/jedis · high confidence

The project has been upgraded to version 4.2.0-SNAPSHOT, shifting the group ID to org.springframework.data and artifact ID to spring-data-redis. This update brings significant dependency upgrades, including Lettuce to 7.7.0.RELEASE, Jedis to 8.0.1, Netty to 4.2.17.Final, XStream to 1.4.21, and Commons Pool2 to 2.13.1. The build now inherits from the spring-data-parent BOM and includes optional dependencies for Jackson 3 (tools.jackson.core) alongside Jackson 2, as well as Reactor Core for reactive support.

(dependencies) · high confidence

The Maven Wrapper configuration has been updated to use Maven version 3.9.16. This ensures that all developers and CI environments use a consistent, specific version of the Maven build tool when executing wrapper scripts, eliminating potential discrepancies caused by different locally installed Maven versions.

.mvn/wrapper · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 62 → 57 (-5.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 83 → 90 (+7.0)
• Architecture 100 → 59 (-40.5)
• Maturity 57 → 55 (-1.9)
• Readiness 62 → 63 (+0.7)
• Security 57 → 51 (-5.7)
• Domain Modelling 100 → 100 (+0.0)

• Change coupling: BoundHashOperations.java ↔ HashOperations.java (src/main/java/org/springframework/data/redis/core/BoundHashOperations.java)
• Change coupling: RedisAtomicInteger.java ↔ RedisAtomicLong.java (src/main/java/org/springframework/data/redis/support/atomic/RedisAtomicInteger.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterKeyCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterListCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterSetCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterSetCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterSetCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterSetCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterSetCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/lettuce/LettuceClusterListCommands.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/connection/lettuce/StreamConverters.java)
• Duplicated block (10 lines × 2) (src/main/java/org/springframework/data/redis/listener/ReactiveRedisMessageListenerContainer.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisConnectionFactory.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/redis/connection/jedis/StreamConverters.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveHashCommands.java)
• Duplicated block (11 lines × 2) (src/main/java/org/springframework/data/redis/core/script/ScriptUtils.java)
• …and 95 more

• Change coupling clique: DefaultLettuceClientConfiguration.java, DefaultLettucePoolingClientConfiguration.java, LettuceConnectionFactory.java (src/main/java/org/springframework/data/redis/connection/lettuce/DefaultLettuceClientConfiguration.java)
• Change coupling clique: RedisAtomicDouble.java, RedisAtomicInteger.java, RedisAtomicLong.java (src/main/java/org/springframework/data/redis/support/atomic/RedisAtomicDouble.java)
• Change coupling clique: RedisClusterConfiguration.java, RedisSentinelConfiguration.java, RedisStandaloneConfiguration.java (src/main/java/org/springframework/data/redis/connection/RedisClusterConfiguration.java)
• Change coupling: BoundHashOperations.java ↔ DefaultHashOperations.java (src/main/java/org/springframework/data/redis/core/BoundHashOperations.java)
• Change coupling: BoundListOperations.java ↔ ListOperations.java (src/main/java/org/springframework/data/redis/core/BoundListOperations.java)
• Change coupling: BoundSetOperations.java ↔ SetOperations.java (src/main/java/org/springframework/data/redis/core/BoundSetOperations.java)
• Change coupling: DefaultReactiveValueOperations.java ↔ DefaultValueOperations.java (src/main/java/org/springframework/data/redis/core/DefaultReactiveValueOperations.java)
• Change coupling: DefaultReactiveValueOperations.java ↔ ValueOperations.java (src/main/java/org/springframework/data/redis/core/DefaultReactiveValueOperations.java)
• Change coupling: DefaultReactiveZSetOperations.java ↔ DefaultZSetOperations.java (src/main/java/org/springframework/data/redis/core/DefaultReactiveZSetOperations.java)
• Change coupling: DefaultStringRedisConnection.java ↔ JedisClusterStringCommands.java (src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java)
• Change coupling: DefaultStringRedisConnection.java ↔ JedisStringCommands.java (src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java)
• Change coupling: JacksonHashMapper.java ↔ JacksonJsonRedisSerializer.java (src/main/java/org/springframework/data/redis/hash/JacksonHashMapper.java)
• Change coupling: JdkSerializationRedisSerializer.java ↔ StringRedisSerializer.java (src/main/java/org/springframework/data/redis/serializer/JdkSerializationRedisSerializer.java)
• Change coupling: JedisClusterServerCommands.java ↔ JedisServerCommands.java (src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterServerCommands.java)
• Change coupling: JedisKeyCommands.java ↔ LettuceKeyCommands.java (src/main/java/org/springframework/data/redis/connection/jedis/JedisKeyCommands.java)
• Change coupling: JedisZSetCommands.java ↔ LettuceZSetCommands.java (src/main/java/org/springframework/data/redis/connection/jedis/JedisZSetCommands.java)
• Change coupling: LettuceReactiveStreamCommands.java ↔ DefaultReactiveStreamOperations.java (src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveStreamCommands.java)
• Change coupling: ReactiveStreamCommands.java ↔ StreamConverters.java (src/main/java/org/springframework/data/redis/connection/ReactiveStreamCommands.java)
• Change coupling: ReactiveStreamCommands.java ↔ StreamConverters.java (src/main/java/org/springframework/data/redis/connection/ReactiveStreamCommands.java)
• Change coupling: ReactiveValueOperations.java ↔ ValueOperations.java (src/main/java/org/springframework/data/redis/core/ReactiveValueOperations.java)
• …and 2400 more

• 44 commits — 38 feature/other, 6 fixes

• src/main — 29 commits
• (root) — 6 commits
• src/test — 5 commits
• (repo) — 2 commits
• .github/workflows — 1 commit
• .mvn/extensions.xml — 1 commit

• fix: Fix broken links in Redis reference documentation.
• fix: Fix failing test.
• fix: Fix flaky test
• fix: Fix inverted equals in RedisStreamCommands.TrimOptions.
• fix: Fix race condition in non-blocking clear test
• fix: Fix wrong assertion for XACKDEL tests
• change: Add 3.x to 4.x migration guide.
• change: Add lengthOfValue command to ReactiveHashOperations.
• change: Add release train automation.
• change: Add support for Redis JSON.
• change: Always use Redis' expire when Jedis expire API is called
• change: Check for integer overflow in lPop and rPop.
• change: Check for integer overflow in sort LIMIT, scan and geo COUNT.
• change: Compare raw TTL values as long in Expirations.TimeToLive.
• change: Convert Expiration to the requested precision and align hashCode with equals.
• change: Deprecate duplicate converters.
• change: Enter rampdown phase for 4.2.0-M1.
• change: Enter rampdown phase for 4.2.0-M2.
• change: Fetch hash field TTLs in seconds in DefaultHashOperations.
• change: Parse Redis INFO output without using Properties.load().
• …and 24 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

spring-projects/spring-data-redis was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.