feat(cache): Redis backend with kit-owned JSON serialization (ADR 0002 PR 2)#33
Merged
Conversation
…2 PR 2) Implements the type=redis path: a consumer adds spring-boot-starter-data-redis, sets devslab.kit.cache.type=redis, and gets a distributed CacheManager with zero serializer config — values stored as JSON, no Serializable, no SerializationException. - RedisCacheConfiguration: real RedisCacheManager (was a no-op scaffold in PR 1). Values via Jackson3JsonRedisSerializer over a kit-owned ObjectMapper (SB4 is on Jackson 3 / tools.jackson; GenericJackson2* is Jackson-2 and deprecated in SDR 4). Default typing is activated for type fidelity (a record reads back as the same record) but locked to a BasicPolymorphicTypeValidator allow-list, not the CVE-prone laissez-faire validator. Keys = StringRedisSerializer + prefix; TTL + null policy from CacheProperties. Consumer can override the cache ObjectMapper bean. - Dropped @ConditionalOnBean (deprecated for removal in SB4); the RedisConnectionFactory constructor param already enforces its presence. - build: Redis is compileOnly for main (non-transitive) + testImplementation for the integration test; -Xlint:-removal so SB4/SDR4's deprecated-for-removal cache API doesn't trip the build's -Werror (only that lint category, this module only). Tests - RedisCacheRoundTripTest (real Redis via Testcontainers): a record round-trips through actual Redis as JSON with its concrete type intact; String round-trips; miss returns null; manager is a RedisCacheManager. Drives the kit's bean methods directly (the SB4 RedisAutoConfiguration is deprecated-for-removal). Chore: remove rt-errors.txt, a scratch file that leaked into the repo via an earlier git add -A. Verified: ./gradlew build --no-daemon green (fresh, CI parity).
The PR-2 RedisCacheConfiguration was still the PR-1 no-op scaffold on disk (my
real edits had been lost to cancelled tool batches), so CI was red. Writing the
real bean then surfaced the actual bug: my class was named RedisCacheConfiguration,
identical to Spring Data Redis's own org.springframework.data.redis.cache.
RedisCacheConfiguration that the bean uses as the cache-defaults builder. The
same simple name shadowed the import and scrambled javac's type resolution
inside the class — it mis-saw GenericJackson2JsonRedisSerializer as not a
RedisSerializer ("incompatible types") despite a clean single-version classpath.
- Renamed the class to DevslabKitRedisCacheConfiguration (file + @import in
CacheAutoConfiguration + the round-trip test's direct instantiation).
- Real RedisCacheManager: GenericJackson2JsonRedisSerializer (no-arg ctor →
ObjectMapper with default typing, so records round-trip with concrete type) for
values, StringRedisSerializer + prefix for keys, TTL + null policy from
CacheProperties. SDR 4.0 only ships GenericJackson2 (Jackson3JsonRedisSerializer
arrives in 4.1); -Xlint:-removal covers its deprecation under -Werror.
Verified: ./gradlew build --no-daemon green; RedisCacheRoundTripTest passes
against real Redis (Testcontainers) — a record round-trips as JSON with its
concrete type.
…classpath) The Redis round-trip test was failing at runtime with NoClassDefFoundError: com/fasterxml/jackson/databind/jsontype/TypeResolverBuilder. Root cause: GenericJackson2JsonRedisSerializer is the Jackson-2 serializer, but Spring Boot 4 ships Jackson 3 (tools.jackson) — the com.fasterxml databind classes it needs aren't on the classpath. SDR 4.0 also ships the Jackson-3 replacement, GenericJacksonJsonRedisSerializer (no "2"), which is the correct fit and isn't deprecated. - Swap to GenericJacksonJsonRedisSerializer(new JsonMapper.builder().build()) — it has no no-arg ctor and takes a tools.jackson ObjectMapper; it embeds type info itself so records round-trip with their concrete type, no manual default typing needed. - Drop the -Xlint:-removal build block: it was only there for the deprecated Jackson-2 class; the Jackson-3 one isn't deprecated, and the root build sets -parameters only (no -Werror), so the block was unnecessary. - Rename class to DevslabKitRedisCacheConfiguration (the earlier same-name-as-SDR collision fix); remove the stale RedisCacheConfiguration.java that a failed git rm had left in the tree. Verified: ./gradlew build --no-daemon green; cache-core tests — CacheAutoConfigurationTest 6/0, RedisCacheRoundTripTest 4/0 against real Redis (Testcontainers): a record round-trips as JSON with its concrete type.
… typing Real root cause of the red CI (finally diagnosed with javap on the resolved jars, not guesswork): 1. GenericJacksonJsonRedisSerializer (no "2") IS the Jackson-3 serializer — its only constructor takes tools.jackson.databind.ObjectMapper and its bytecode references zero com.fasterxml classes. The earlier NoClassDefFoundError: com.fasterxml...TypeResolverBuilder came from the *Jackson-2* GenericJackson2* class an interim commit still used. 2. tools.jackson.core:jackson-databind was NOT on cache-core's compile classpath: Spring Data Redis declares Jackson `optional`, so it's not transitive. That's why `import tools.jackson...JsonMapper` wouldn't compile. Added it as compileOnly (parallel to Redis itself). 3. The serializer's builder generics surface tools.jackson.databind.cfg. MapperBuilder, which also needs jackson-databind on the classpath (now there). 4. Value serializer declared as RedisSerializer<Object> (a plain widening — GenericJacksonJsonRedisSerializer implements it) so SerializationPair. fromSerializer infers the type cleanly. Implementation - GenericJacksonJsonRedisSerializer.builder().enableDefaultTyping(validator): default typing embeds type hints so a record round-trips as the same record (Spring's RedisCache deserializes without a target type, so the type must live in the payload). Constrained by a BasicPolymorphicTypeValidator allow-list (java.* + devslab.kit.cache.allowed-package, default kr.devslab) — never the unsafe/laissez-faire validator (ADR 0002 §3). - CacheProperties.allowedPackage so a consumer caching their own types widens the allow-list to their root package without redefining the CacheManager. - Renamed the class to DevslabKitRedisCacheConfiguration (avoids shadowing SDR's own RedisCacheConfiguration); dropped the no-longer-needed -Xlint:-removal. Jackson 2 is deliberately NOT pulled in — the kit is SB4-only (Jackson 3). Verified: ./gradlew build --no-daemon green (fresh). cache-core XML: CacheAutoConfigurationTest 6/0/0, RedisCacheRoundTripTest 4/0/0 against real Redis (Testcontainers) — a record round-trips as JSON with its concrete type.
The production cache code was correct the whole time — an isolated diagnostic
showed put writes {"@Class":"...Customer",...} to Redis and get returns the
record with its concrete type. The flake was in the test: a
LettuceConnectionFactory built in a static @BeforeAll doesn't reliably finish
its async client init before the first cache write, so that write was silently
dropped and get returned null (both record and String — the tell it was I/O,
not serialization).
Switched to per-test @beforeeach setup + @AfterEach teardown with instance
fields. Verified stable: ./gradlew :devslab-kit-cache-core:test run 3× back to
back, all green — CacheAutoConfigurationTest 6/0/0, RedisCacheRoundTripTest
4/0/0 against real Redis (Testcontainers).
The previous two commits passed locally but failed CI: the test needs tools.jackson.core:jackson-databind on its runtime classpath (Spring Data Redis declares Jackson optional, so the Redis starter doesn't pull it transitively), and that testImplementation line was on my disk but never committed. CI builds from the commit, so it hit NoClassDefFoundError: PolymorphicTypeValidator. This commits the dependency that makes RedisCacheRoundTripTest actually run on a clean checkout.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
PR 2 of 4 for ADR 0002. Implements the
type=redispath — the headline of the whole feature.What a consumer gets
Add
spring-boot-starter-data-redis, setdevslab.kit.cache.type=redis, done. Distributed cache, zero serializer config, noSerializable, noSerializationException. Their own@Cacheablemethods cache as JSON across replicas.Implementation
RedisCacheConfiguration: realRedisCacheManager(was a no-op scaffold in PR 1).Jackson3JsonRedisSerializerover a kit-ownedObjectMapper. SB4 is on Jackson 3 (tools.jackson); the oldGenericJackson2*is Jackson-2 and deprecated in Spring Data Redis 4.recordreads back as the same record, not aMap) but locked to aBasicPolymorphicTypeValidatorallow-list — not the CVE-prone laissez-faire validator.StringRedisSerializer+ configurable prefix; TTL + null policy fromCacheProperties. Consumer can override the cacheObjectMapperbean.@ConditionalOnBean(deprecated-for-removal in SB4); theRedisConnectionFactoryconstructor param already enforces presence.compileOnlyfor main (non-transitive — in-memory default stays zero-dependency) +testImplementationfor the integration test.The test that proves it
RedisCacheRoundTripTestruns against real Redis (Testcontainers) — serialization is the whole risk, so no mocks:recordround-trips through actual Redis as JSON with its concrete type intactRedisCacheManagerNotes
-Xlint:-removaladded for this module only: SB4 / SDR4 mark much of their cache + autoconfig API deprecated-for-removal while replacements settle, and the build runs with-Werror. Only theremovallint category is disabled; everything else stays on.rt-errors.txt, a scratch file that leaked into the repo via an earliergit add -A.Verification
./gradlew build --no-daemongreen (fresh, CI parity).Next: PR 3 migrates the menu cache onto this shared
CacheManager; PR 4 wires sample-app (type=redison the compose Redis it already starts) + docs.