The short answer: choose Redisson for a specific distributed API
Redisson adds distributed Java objects and services to Redis and Valkey; our source build stopped in redisson-micronaut-50 after 126 seconds. Use it when your application needs those APIs. Choose Spring Data Redis when ordinary RedisTemplate operations and basic TTL caching cover the requirement, following Redisson's Spring comparison. A distributed lock, shared collection or framework cache integration gives you a concrete selection criterion: identify the operation your application needs before choosing the client.
A distributed lock coordinates access across application processes, while a shared map exposes data through a familiar Java interface. The Redisson README describes distributed collections, objects, reliable queues and services. Those interfaces are the reason to consider the client. The deployment reports below add operational questions: what happens when an endpoint changes address, when a session moves between nodes, or when a lock operation encounters a timeout?
GitHub activity and the recorded release
GitHub reported 24,436 stars and 245 open issues and pull requests on November 21, 2026, with the latest push recorded that day in the repository metadata. The release record identifies redisson-4.8.0, published October 2, 2026. The getting-started guide also shows dependency version 4.8.0. The source checkout used for our build was commit 05d1891, and its test tail names a 4.8.1-SNAPSHOT reactor module.
The README calls Redisson a top-1% Maven Central publisher by popularity and lists more than 2,000 unit tests. Our test command exited 1, with skipped-test messages in its tail. These records answer different questions: GitHub describes repository activity, the guide names a dependency, and the execution log records the outcome of a particular source checkout. The issue discussions add configurations, errors and reporter follow-ups to that picture.
What people use redisson for
GitHub users describe Redisson deployments for Spring caching, distributed daemon locks, endpoint connections and Tomcat sessions, with specific outcomes in each discussion.
| Who used it | What they did | What happened |
|---|---|---|
| GitHub user oleg-gr | Added a Spring @Cacheable layer with database fallback | Reported cache times reaching 800,000 ms under a long TTL and roughly 4-5 queries per minute. Spring cache report #198 |
| GitHub user sindhuvaidy's team | Connected Redisson 3.5.0 to Redis Labs Enterprise in single-server mode | Reported retries against the previous active-node IP after the endpoint changed. Endpoint report #1178 |
| GitHub user ant76050391 | Ran a multithreaded daemon across four EC2 instances | Described locking every 3 seconds, with two thread pools per application, and fewer but continuing errors after settings changed. Daemon report #4248 |
| GitHub user k3vinwan's team | Used Redisson for Tomcat sessions | Reported too many timeout errors after adding six nodes and a rollback to sticky sessions. Tomcat report #1402 |
These deployments put different responsibilities on the client. In the Spring cache report, the application attempted a database fallback after Redis exceptions, yet the reporter described cache latency far beyond the intended timeout. In the Tomcat discussion, the team returned to sticky routing. A cache lookup's elapsed time and a session's visibility across nodes are distinct acceptance conditions, even when both applications store their data in Redis.
What happened when we ran it
Our November 11 run installed successfully in 169 seconds, then failed the build after 126 seconds and the test command after 33 seconds at commit 05d1891.
| November 11 source step | Our result | What the log tells you |
|---|---|---|
| Install | Succeeded in 169 seconds | The installation step completed. |
| Build | Failed, exit 1, in 126 seconds | Compilation failed in redisson-micronaut-50. |
| Tests | Failed, exit 1, in 33 seconds | The tail contains Tests are skipped., 1 error and module SUCCESS lines. |
We measured these results in our November 11 source run, configured with 3 CPUs, 10g RAM and image label lab-jvm:21. The checkout scan counted 3,873 files, approximately 628,644 source lines and 25.5 MB. It found two CI workflow files, no Dockerfile and no tests directory. The README separately lists more than 2,000 unit tests, and the Maven tail names integration-test modules; the directory scan and Maven output describe different aspects of the checkout.
The build log reports that io/micronaut/annotation/processing/MixinVisitorProcessor had been compiled by a more recent Java runtime, with class-file version 69.0. Maven names redisson-micronaut-50 as the failing project and maven-compiler-plugin:3.13.0:compile as the goal in our compiler output. The test tail identifies a 4.8.1-SNAPSHOT reactor module and includes six integration-module SUCCESS entries alongside skipped tests and 1 error. The overall test command exited 1.
The November 20 attempt failed at the safety step because none of compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml existed. Its run summary describes a deployment with ports bound to 127.0.0.1, conflicting with that failed step. The recorded sequence includes the failed safety check and successful teardown. The official application setup instead starts by adding a dependency and creating a client.
Where people get stuck: separate the error paths
Historical reports describe DNS recovery, session class loading, session visibility and lock failover as separate failures, with different outcomes after attempted changes.
| Symptom and reporter | Attempted change | Outcome in the discussion |
|---|---|---|
| sindhuvaidy: Redisson 3.5.0 retried the previous endpoint address | Added -Dsun.net.inetaddr.ttl=0 | The reporter said operation resumed. DNS discussion #1178 |
| miriamccp and other participants: DTO class loading and non-sticky sessions | Used the thread's ContextClassLoader | Class loading improved; the participant separated that from the continuing non-sticky issue. Session discussion #974 |
| servionsolutions: lock sharing after cluster failover | Tested a 3.19.4 snapshot and retry changes | Three local failovers succeeded; ElastiCache still produced a lock stuck on one node. Failover discussion #4822 |
| AlexMog: command and batch timeouts | Increased pools and upgraded from 3.10.0 to 3.10.1 | The reporter continued seeing errors. Timeout discussion #1879 |
The session discussion reports that ContextClassLoader resolved class loading but not the non-sticky issue. That distinction gives a session-manager evaluation two concrete checks: loading the application's DTO class and observing changed attributes when requests reach another node. The failover report separates three successful local failovers from the continuing ElastiCache failure. Its outcome depends on which environment and follow-up you read.
On X, kalayciburak96 reported a local Redisson experiment in which a retry doubled a reentrant lock's hold count, while disabling retries still left one hold after a timeout. A reentrant lock tracks repeated acquisitions by its owner. The report raises a specific state question after a timed-out acquisition: how many holds remain? Both configurations in the report left a consequential lock state after timeout.
Pool capacity and DNS settings address different resources
Issue #1879 discusses subscription resources alongside lock concurrency, while #4248 describes DNS and cluster-state errors that decreased but continued after configuration changes.
The #1879 discussion connects active locks to subscription capacity. The reporter also described timeouts after pool increases and an upgrade. Concurrent lock demand and subscription settings therefore belong beside the exception when describing that deployment. The Tomcat discussion distinguishes command-send failures from server-response timeouts; its response-timeout example names HGETALL and 3000 ms. Pool capacity and response waiting time concern different parts of the command's progress.
The daemon operator in #4248 reported fewer occurrences but continuing errors, despite an earlier follow-up saying the configuration initially appeared trouble-free. The application processed data under a lock every 3 seconds across four EC2 instances, with two thread pools per application. The later follow-up changes the reported outcome from an initially successful observation to recurring errors at a reduced frequency.
TLS examples and the documented RLock watchdog condition
Upstash's tutorial uses rediss:// for TLS, and Redisson's configuration limits its RLock watchdog setting to acquisitions without an explicit leaseTimeout parameter.
The Upstash tutorial says TLS is enabled for its databases and uses a rediss:// address. Its example supplies a password through setPassword and creates a single-server client before obtaining an RMap, writing foo with value bar, and reading it back. The tutorial's dependency is 3.15.4. The official getting-started guide shows 4.8.0 and describes creating a shared RedissonClient instance for application use.
The configuration guide gives lockWatchdogTimeout a default of 30000 milliseconds and says it applies when RLock is acquired without leaseTimeout. It describes expiry if the watchdog fails to extend the lock into the next interval. A lease is the period after which a lock expires unless renewed. The acquisition's lease parameter is therefore central to the documented renewal behavior; the method name tryLock alone does not express that condition.
Redisson vs Lettuce, Jedis and Spring Data Redis
Redisson's comparisons distinguish distributed-object APIs from Lettuce's reactive interfaces, Jedis's lightweight client approach and ordinary Spring Redis operations.
| Choice | Pick it for | Evidence behind the distinction |
|---|---|---|
| Spring Data Redis | RedisTemplate operations and basic TTL caching | Redisson's comparison recommends it when caching stops at storing a value with a TTL. Spring comparison |
| Lettuce | Command access with reactive interfaces | Redisson's article describes Lettuce as a client for non-blocking reactive applications. Lettuce comparison |
| Jedis | Lightweight command-oriented client requirements | Redisson's article describes Jedis as a relatively lightweight Redis Java client. Jedis comparison |
| Redisson Community or PRO | Particular distributed objects and framework integrations | The edition page lists basic local caching and additional local-cache implementations. Edition comparison |
Redisson's published Jedis benchmark compares Redisson PRO with Jedis. The benchmark description excludes blocking commands from its speed claim and names HSET, RPUSH, SADD, SET and INCR among the commands included. The edition comparison separately advertises extra local-cache implementations for named frameworks. A command benchmark and a local-cache implementation describe different operations and purchasing choices.
For Spring developers, the vendor comparison places ordinary get, set, hash and list operations with @Cacheable on the Spring Data Redis side, and distributed locks, typed objects and near caching on the Redisson side. Its Spring integration discussion describes keeping RedisTemplate and @Cacheable code with Redisson underneath. The practical selection sequence is the required API, the integration that supplies it, and the edition containing that implementation.
Outdated claims, corrected
The watchdog condition concerns an omitted lease timeout, Upstash's dependency example is 3.15.4, and Tencent Cloud's recovery reproduction concerns Redisson 3.23.4.
The mikechen tutorial's statement that watchdog use requires tryLock conflicts with the official configuration's condition concerning leaseTimeout. The Spring comparison also describes watchdog renewal broadly across locks and synchronizers. The configuration gives a narrower rule for RLock: the parameter applies to acquisition without leaseTimeout. This correction replaces the blanket method-name rule with the documented parameter condition.
The Upstash setup tutorial shows 3.15.4, while the official getting-started guide shows 4.8.0. Separately, the README lists auto-reconnection, while Tencent Cloud describes connections recovering but business requests returning to normal only after a client restart. Tencent Cloud identifies 3.23.4 as the version in that reproduction. Connection recovery and successful application requests are distinct outcomes in its account.
FAQ
Redisson is a Java client for Redis and Valkey, and the official getting-started guide shows org.redisson:redisson:4.8.0 for Community Edition.
What is Redisson, and how does it relate to Redis?
Redisson is the Java client; Redis or Valkey is the server it connects to. The README describes additional distributed collections, objects, queues and services. For a Java application, the selection question is whether those APIs match the work it needs to share across processes. A distributed lock and a cached value put different requirements on the client even when they use the same server.
Which Maven dependency and version should I use for Redisson?
The getting-started guide shows org.redisson:redisson:4.8.0 for Community Edition and pro.redisson:redisson:4.8.0 for PRO. It then creates a configuration, creates a Redisson instance, and obtains an object or service. Our source run used commit 05d1891, whose test tail names a 4.8.1-SNAPSHOT module. The published dependency coordinates and source reactor version identify different artifacts.
Should I choose Redisson, Lettuce, or Jedis?
Choose Redisson for its distributed-object APIs; consider Lettuce or Jedis for command-oriented access. Redisson's Lettuce article describes reactive interfaces, while its Jedis article describes a relatively lightweight client. An application needing a shared typed collection has a different selection criterion from one issuing individual commands. Existing Spring applications should also compare their requirement with the RedisTemplate and TTL-caching option above.
How does Redisson performance compare with Lettuce and Jedis?
Redisson's Jedis comparison reports a Redisson PRO command benchmark, excluding blocking commands. Its edition page attaches separate speed claims to extra local-cache implementations. Those figures concern different work: executing a server command and serving a cache operation through a particular implementation. Our 169-second install, 126-second failed build and 33-second failed test command measure source execution steps.
When should I use Redisson instead of Spring Data Redis?
Use Redisson for a required distributed lock, typed shared object or additional service; the vendor comparison recommends Spring Data Redis for ordinary RedisTemplate operations and basic TTL caching. TTL means time to live, the expiry period attached to cached data. The comparison specifically names near caching behind @Cacheable as a Redisson use case and ordinary get, set, hash and list operations as Spring Data Redis use cases.
Can I use Redisson with my existing RedisTemplate and @Cacheable code?
Redisson's Spring integration discussion describes keeping existing RedisTemplate and @Cacheable code and backing it with Redisson. Its Spring comparison also discusses near caching for hot reads. The edition page lists extra local-cache implementations for Spring Cache and other frameworks. The cache manager and edition are therefore concrete parts of the integration choice, alongside the application's existing template operations.
What is the difference between Redisson lock() and tryLock()?
For watchdog renewal, the documented distinction is acquisition without leaseTimeout, rather than a rule that only tryLock enables renewal. The configuration states that condition for RLock and gives a default watchdog timeout of 30000 milliseconds. This answers the renewal part of the question: identify whether the acquisition specifies a lease timeout before applying the watchdog setting to an example.
How much does Redisson PRO cost, and do paying users recommend it?
PunDefeated's r/redis question asks for PRO pricing and experiences from users. The author names Valkey support and a desired JCache swap with Caffeine as reasons for considering it. The edition comparison directs buyers to Request Pricing. Its feature list identifies the implementations being sold, including additional local-cache integrations, while the discussion records the buyer's evaluation priorities.
Which advanced near-cache features require Redisson PRO?
The edition comparison lists extra local-cache implementations for Map Cache, Spring Cache, Hibernate Cache, JCache and other integrations. It lists basic local caching separately. Match the implementation by name: a local map and a framework cache manager occupy different entries in that comparison. The page also separates performance acceleration, an ultra-fast engine and web-session implementations from the basic local-cache entry.
Has anyone used Redisson near caching with Valkey?
Affectionate-Fuel521 describes evaluating Redisson with Valkey to replace an Oracle Coherence cluster. The post asks how basic and advanced local-cache features compare with Coherence's near-cache modes. That identifies a concrete migration requirement: matching the application's existing caching behavior, rather than choosing a replacement from a general feature count. The discussion contains the evaluator's questions and no replies.
Can Lua scripts provide server-side cache-entry filtering when replacing Oracle Coherence with Valkey and Redisson?
The Coherence evaluator asks whether Lua could supply server-side filtering, and the Redisson README lists Lua scripting support. The requested behavior is filtering cache entries on the server, alongside the evaluator's near-cache requirements. Those are the specific migration criteria to carry into a comparison with the existing Coherence application; the post contains no implementation or replies.
Will cache entries expire if the application using Redisson Community Edition stops running?
PunDefeated attributes expiry and deletion to the application JVM in the r/redis buyer question. The author connects this concern to a proposed JCache setup that could be swapped with Caffeine for tests. The edition comparison lists multiple cache implementations, making the exact cache object part of this question. The all-JVMs-stopped behavior belongs among the implementation questions collected below.
What we have not tested yet
Our execution covers commit 05d1891's failed source build and test command, plus the November 20 blocked Compose attempt; it includes no running lock or cache workload.
The sandbox image label lab-jvm:21 does not identify the actual Java or operating-system version; those require complete toolchain logs. Published-dependency application setup, throughput, memory under load, failover recovery and session consistency on 4.8.0 remain untested. The test tail does not expose enough of the underlying error to diagnose the failed test command. The runs include no security audit or vulnerability count. Historical issue outcomes describe their reported versions, rather than current-release behavior.
The getting-started guide documents valkeys:// for Valkey SSL connections; we did not test that connection mode. The documentation read for this review does not resolve PRO password-file encryption, RFencedLock behavior or receiving-side fencing checks. It also does not resolve expiry after all application JVMs stop, implementation-specific JCache cleanup, or classic RMapCache versus native expiry. The Reddit author's expiry statement is a user report. No corrected code example was executed as part of this revision.
We have not reproduced the acquisition-timeout experiment, linked #4822 to a confirmed fixed release, or rerun Tencent Cloud's 3.23.4 recovery scenario on 4.8.0. We also lack an independent Community-versus-Lettuce-versus-Jedis benchmark, a published PRO price, a detailed paying-customer assessment, a Caffeine runtime-swap result and a working Coherence filtering migration. Vendor comparisons, buyer questions and migration evaluations serve those narrower roles. DNS and subscription settings in historical reports are deployment-specific leads, without a complete operational diagnosis connecting them.
The November 20 deployment summary conflicts with its failed Compose safety step, so it cannot support a successful deployment claim. No screenshot records accompany these runs. The video results concern Radisson hotels and contribute no Java-client demonstration. Rendered layout, automatic related links, recommendation modules and template content were outside this text review; no new execution, source retrieval or publication occurred during the correction.


