Skip to content
CAI
Software that uses CAICheck a score

spring-projects/spring-data-redis

59.6

Adequate · 9 November 2026

126.4k

lines of production code

Java

primary language

10

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Redis Streams connection model interfaces

Introduces a new set of interfaces and value objects in the \org.springframework.data.redis.connection.stream\ package to support Redis Streams. This includes \Record\, \MapRecord\, \ObjectRecord\, \StringRecord\, \ByteRecord\, and \ByteBufferRecord\ for representing stream entries, along with \StreamOffset\ and \ReadOffset\ for managing read positions, \Consumer\ and \PendingMessage\ for consumer group tracking, and \StreamSerialization\ for handling data conversion.

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

Added AOT runtime hints for Lettuce Redis client

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

Added AOT support for Redis repositories

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

Added Ahead-of-Time (AOT) runtime hints for Spring Data Redis

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

Added Spring XML schema for Redis listener container configuration

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

Annotation-driven Redis Pub/Sub listener support

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

Annotation-driven Redis Pub/Sub listeners

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

Enable Spring XML configuration for Redis repositories and namespaces

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

Introduce BoundKeyExpirationOperations for granular key and hash field expiration control

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

Introduce Expiration type for Redis key expiration control

Added the new Expiration class in the org.springframework.data.redis.core.types package to provide a structured way to define key expiration policies. This type supports various expiration modes including relative time (seconds/milliseconds), absolute timestamps (EXAT/PXAT), keeping the existing TTL, and setting keys as persistent. It also includes utility methods for converting between Duration and TimeUnit, ensuring proper precision handling for Redis operations.

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

Introduce Lettuce-based Redis connection infrastructure

This change adds the core implementation classes for the Lettuce Redis client integration, including the main factory, connection providers, and cluster-specific command handlers. Users can now configure and obtain Redis connections using the Lettuce driver, with support for cluster topologies, SSL/TLS settings, and connection pooling via the new \LettuceClientConfiguration\ and \LettuceConnectionFactory\ classes.

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

Introduce Redis Hash mapping API and implementations

This change introduces a new \org.springframework.data.redis.hash\ package that provides a dedicated API for mapping Java objects to and from Redis hashes. It defines the \HashMapper\ interface and includes several implementations: \ObjectHashMapper\ for complex objects with nested properties using the \RedisConverter\, \BeanUtilsHashMapper\ for simple POJOs via Apache Commons BeanUtils, and \DecoratingStringHashMapper\ to flatten generic mappers into string-based hashes. The package also includes internal utilities like \FlatEric\ for handling dot-notation key unflattening.

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

Introduce Redis Streams support for synchronous and reactive consumption

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

Introduce Redis repository factory support with Query by Example capability

This change adds the core factory infrastructure for Spring Data Redis repositories, specifically introducing RedisRepositoryFactory and RedisRepositoryFactoryBean to wire up Redis-specific query execution and entity mapping. A key user-facing capability enabled by this factory is Query by Example support: when a repository interface extends QueryByExampleExecutor, the factory automatically registers a QueryByExampleRedisExecutor, allowing users to perform dynamic, example-based queries against Redis data stores.

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

Introduce Redis-backed collection support classes

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

Introduce new Redis mapping and conversion infrastructure

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

Introduce reactive Lua script execution support

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

Introduce secondary index abstractions and Geo indexing support

This change introduces a new set of classes and interfaces in the \org.springframework.data.redis.core.index\ package to define and manage secondary indexes in Redis. It adds the \@Indexed\ annotation for standard SET-based indexes and the new \@GeoIndexed\ annotation for GEO-based indexes, along with corresponding \IndexDefinition\ implementations (\SimpleIndexDefinition\, \GeoIndexDefinition\, \SpelIndexDefinition\). The package also provides \IndexConfiguration\ and \IndexDefinitionProvider\ interfaces to allow programmatic registration and querying of these index definitions.

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

Introduction of Redis Repository Core Interfaces and Implementation

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

Kotlin Coroutines and Flow extensions for reactive Redis operations

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

New Redis Cache configuration and management APIs

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

New Redis JSON connection abstractions

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

New Redis Pub/Sub messaging template and operations

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

New Redis caching infrastructure with batch strategies and statistics

The Redis caching layer now includes a new \DefaultRedisCacheWriter\ implementation that supports configurable batch strategies for cache cleanup (via \BatchStrategies\ using \KEYS\ or \SCAN\), per-cache statistics collection (\DefaultCacheStatisticsCollector\), and fixed-duration TTL functions (\FixedDurationTtlFunction\). Additionally, a new \PassThroughExceptionTranslationStrategy\ allows custom exception translation for Redis operations.

spring-data-redis · high confidence

New Redis listener adapter classes for Spring Data Redis 4.1

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

New Redis-backed atomic number classes and CAS support

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

New connection infrastructure for Redis Sentinel and Cluster support

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

New internal utility package for Redis connection helpers

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

New support classes for Redis Pub/Sub topic resolution

Added \PubSubHeaders\, \TopicResolver\, and \TopicResolvers\ to the \org.springframework.data.redis.listener.support\ package. These classes provide pre-defined header constants for Pub/Sub message attributes and a strategy interface for resolving string destination names into \ChannelTopic\ or \PatternTopic\ instances, facilitating integration with Spring Messaging.

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

New utility classes for byte manipulation, key handling, and client identification

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

Support for Query-by-Example and DTO projections in Redis repositories

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

Removals

Removal of Eclipse JDT core preferences file

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

Removal of Redis Datastore Template

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

Behavioural changes

CDI support for Redis repositories

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

Introduce Jackson 3 JSON serialization and deprecate Jackson 2

Users can now serialize and deserialize JSON using Jackson 3 via the new JacksonJsonRedisSerializer, JacksonObjectReader, and JacksonObjectWriter classes. The previous Jackson 2-based serializers (Jackson2JsonRedisSerializer, Jackson2ObjectReader, Jackson2ObjectWriter) are now deprecated and will be removed in a future version. Additionally, a new DefaultRedisMessageConverters utility is provided to automatically configure message converters for Redis listener endpoints, supporting Jackson 3, Jackson 2, Gson, JSON-B, and Kotlin Serialization based on classpath availability.

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

Migrate CDI extension registration to Jakarta EE 9 namespace

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

Migrate Jedis connection layer to UnifiedJedis and RedisClient abstractions

The Jedis connection implementation has been refactored to use Jedis's modern \UnifiedJedis\, \RedisClient\, and \RedisClusterClient\ abstractions, replacing the legacy \Jedis\ and \JedisCluster\ direct usage. This change introduces new configuration interfaces (\JedisClientConfiguration\, \JedisClientConfigBuilderCustomizer\, \JedisClientBuilderCustomizer\) to manage client-specific settings like SSL, pooling, and timeouts, and updates \JedisConnectionFactory\ to leverage these new abstractions for creating connections. Existing constructors and methods relying on the old client types are now deprecated in favor of the new unified approach.

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

Migrate build to Spring Develocity Conventions and update JVM flags

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

Migrate documentation site to Antora

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

New top-level types for ZSet connection operations

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

Redis mapping subsystem refactored to align with Spring Data KeyValue APIs

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

Redis repository configuration now supports custom message listener containers and shadow copy control

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

Refactored Redis Pub/Sub topic abstraction and added reactive subscription synchronization

The listener package introduces an abstract base class for topics, allowing ChannelTopic and PatternTopic to expose their names via getTopic() and implement proper equals/hashCode for reliable identification. The reactive listener container now supports awaiting subscription completion through receiveLater() and receive() methods, coordinated by a new SynchronizingMessageListener that tracks channel and pattern registration states. Additionally, the KeyspaceEventMessageListener now configures Redis notify-keyspace-events via Properties, and the Topic interface provides static factory methods for creating channel and pattern topics.

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

Refactored Redis connection converters with new implementations and deprecations

The converter classes in the connection package have been restructured to improve type safety and maintainability. New generic converters (ListConverter, MapConverter, SetConverter) now handle collection transformations, with SetConverter specifically preserving insertion order. Several legacy converters (LongToBooleanConverter, MapToPropertiesConverter, StringToDataTypeConverter, StringToPropertiesConverter) are now deprecated in favor of static factory methods in the central Converters utility class. Additionally, a new TransactionResultConverter handles transaction execution results and exception mapping, while StringToRedisClientInfoConverter supports parsing CLIENT LIST output. Null-safety annotations from JSpecify have been applied throughout the package.

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

Refactored Redis exception hierarchy and core classes

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

Standardize project setup with Maven wrapper and Docker-based test infrastructure

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

Test coverage

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.

Dependencies

Spring Data Redis 4.2.0-SNAPSHOT dependency update

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

Upgrade Maven Wrapper to version 3.9.16

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 58 → 60 (+2.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 83 → 83 (+0.0)
  • Architecture 62 → 62 (+0.3)
  • Maturity 48 → 52 (+4.1)
  • Readiness 63 → 64 (+1.3)
  • Security 61 → 61 (+0.0)
  • Domain Modelling 100 → 100 (+0.0)
  • Performance 100 → 100 (+0.0)

Resolved (566)

  • Change coupling: ReactiveStringCommands.java ↔ ReactiveValueOperations.java (src/main/java/org/springframework/data/redis/connection/ReactiveStringCommands.java)
  • Change-coupling hub: BoundValueOperations.java → DefaultReactiveValueOperations.java, DefaultValueOperations.java, ReactiveValueOperations.java, ValueOperations.java (src/main/java/org/springframework/data/redis/core/BoundValueOperations.java)
  • Change-coupling hub: HashOperations.java → ReactiveHashCommands.java, LettuceHashCommands.java, BoundHashOperations.java, ReactiveHashOperations.java (src/main/java/org/springframework/data/redis/core/HashOperations.java)
  • Change-coupling hub: ReactiveHashOperations.java → ReactiveHashCommands.java, StringRedisConnection.java, BoundHashOperations.java (src/main/java/org/springframework/data/redis/core/ReactiveHashOperations.java)
  • No assertions: addsFullyQualifiedClassNameUnderDefaultKeyByDefault (src/test/java/org/springframework/data/redis/core/convert/DefaultRedisTypeMapperUnitTests.java)
  • No assertions: bigDecimalShouldBeTreatedCorrectly (src/test/java/org/springframework/data/redis/mapping/Jackson2HashMapperUnitTests.java)
  • No assertions: bigDecimalShouldBeTreatedCorrectly (src/test/java/org/springframework/data/redis/mapping/JacksonHashMapperUnitTests.java)
  • No assertions: bigIntegerShouldBeTreatedCorrectly (src/test/java/org/springframework/data/redis/mapping/Jackson2HashMapperUnitTests.java)
  • No assertions: bigIntegerShouldBeTreatedCorrectly (src/test/java/org/springframework/data/redis/mapping/JacksonHashMapperUnitTests.java)
  • No assertions: bitPosShouldReturnPositionCorrectly (src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java)
  • No assertions: bitPosShouldReturnPositionInRangeCorrectly (src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java)
  • No assertions: containers (src/test/java/org/springframework/data/redis/core/BoundOperationsProxyFactoryUnitTests.java)
  • No assertions: dateValueShouldBeTreatedCorrectly (src/test/java/org/springframework/data/redis/mapping/Jackson2HashMapperUnitTests.java)
  • No assertions: dateValueShouldBeTreatedCorrectly (src/test/java/org/springframework/data/redis/mapping/JacksonHashMapperUnitTests.java)
  • No assertions: defaultInstanceReadsClasses (src/test/java/org/springframework/data/redis/core/convert/DefaultRedisTypeMapperUnitTests.java)
  • No assertions: defaultInstanceWritesClasses (src/test/java/org/springframework/data/redis/core/convert/DefaultRedisTypeMapperUnitTests.java)
  • No assertions: defaultSerializeAndDeserializeNullValueWithBuilderClass (src/test/java/org/springframework/data/redis/serializer/GenericJackson2JsonRedisSerializerUnitTests.java)
  • No assertions: defaultSerializeAndDeserializeNullValueWithBuilderClassAndCustomJsonFactory (src/test/java/org/springframework/data/redis/serializer/GenericJackson2JsonRedisSerializerUnitTests.java)
  • No assertions: doesNotWriteTypeInformationInCaseKeyIsSetToNull (src/test/java/org/springframework/data/redis/core/convert/DefaultRedisTypeMapperUnitTests.java)
  • No assertions: encodingReturnsCorrectly (src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java)
  • …and 546 more

New (9)

  • Assertions commented out: testEquals (src/test/java/org/springframework/data/redis/support/collections/AbstractRedisCollectionIntegrationTests.java)
  • Change coupling: BoundHashOperations.java ↔ HashOperations.java (src/main/java/org/springframework/data/redis/core/BoundHashOperations.java)
  • Change coupling: LettuceHashCommands.java ↔ HashOperations.java (src/main/java/org/springframework/data/redis/connection/lettuce/LettuceHashCommands.java)
  • Change-coupling hub: BoundValueOperations.java → DefaultReactiveValueOperations.java, ReactiveValueOperations.java, ValueOperations.java (src/main/java/org/springframework/data/redis/core/BoundValueOperations.java)
  • Change-coupling hub: ReactiveHashOperations.java → ReactiveHashCommands.java, StringRedisConnection.java, BoundHashOperations.java, HashOperations.java (src/main/java/org/springframework/data/redis/core/ReactiveHashOperations.java)
  • High interface indirection
  • No assertions: getAtSizeShouldThrowIndexOutOfBoundsException (src/test/java/org/springframework/data/redis/support/collections/AbstractRedisListIntegrationTests.java)
  • No assertions: getFromEmptyListShouldThrowIndexOutOfBoundsException (src/test/java/org/springframework/data/redis/support/collections/AbstractRedisListIntegrationTests.java)
  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 9 commits — 5 feature/other, 4 fixes

By area

  • src/main — 3 commits
  • src/test — 3 commits
  • (root) — 2 commits
  • .github/workflows — 1 commit

Notable commits

  • fix: Fix NPE in multi-member isMember(…) during transactions and pipelines.
  • fix: Fix RedisList putFirst to insert at the head of the list.
  • fix: Fix index bounds check in DefaultRedisList.get.
  • fix: Fix range and trim of reversed RedisList view.
  • change: Polish.
  • change: Polish.
  • change: Prepare next development iteration.
  • change: Remove contributor's agreement from readme.
  • change: Update portfolio train workflow (v0.0.8).

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit afed100945489e5c976f842c915dd255e4ce08ac — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-b921b700395b.