mrkeyoor.comAsk

redisson/redissontested 11 Nov 2026commit 05d1891

redisson review

Use Redisson when its distributed locks, typed objects or cache integrations meet a specific Java application requirement.

  • Safety failed
  • Build failed
169 sto install
  • Tests failed
Dataevaluationupdated 21 Nov 2026
trackingstars / 7d

Redisson is a Java client for Redis and Valkey with distributed collections, objects, locks and services. It exposes Java APIs for shared data and coordination across application processes.

Verdict

Use Redisson when its distributed locks, typed objects or cache integrations meet a specific Java application requirement. Teams needing only ordinary RedisTemplate operations and basic TTL caching should choose Spring Data Redis, following Redisson's own comparison. Source contributors should account for our failed build at commit 05d1891: compilation stopped in redisson-micronaut-50 after 126 seconds, and the test command also exited 1.

Redisson infographic: share data across Java application processes, plus its uses, our test result, pitfalls and who it suits
Tested 11 November 2026: the source build failed. Before that: source install 169 s.

We ran it

Lab card: what happened when we ran redisson
Lab card from our sandbox run
Screenshot of redisson (redisson.pro)
redisson.pro
Install✓ · 169s
Build✗ · 126s
Tests✗ · 33sran, no count parsed
Repo3873 files~628,644 lines of source · 25.5 MB · 2 CI workflows

Answers from our run

Does redisson build from source?

Dependencies installed in 169 seconds, and the build failed. We cloned commit 05d1891 into a clean Debian container with 3 CPUs and no project-specific setup.

Do redisson's tests pass?

No. The project's own test command exited unsuccessfully after 33 seconds, and its output did not expose an individual test count.

Who should not use redisson?

Spring applications whose requirements stop at ordinary RedisTemplate operations and basic TTL caching: Redisson's own comparison recommends Spring Data Redis for that scope.

What are the alternatives to redisson?

Spring Data Redis, Lettuce, Jedis. Use Redisson when its distributed locks, typed objects or cache integrations meet a specific Java application requirement.

Setup2/5Our source checkout installed but the build failed.Editor’s note: Source installation succeeded, but build and test commands failed; application setup with a published dependency was not exercised.
Docs3/5The 3,358-character README has no install instructions or usage instructions or examples of its own and points to separate documentation, which we did not assess.Editor’s note: Readable guides describe dependencies and RLock renewal, but operational accuracy across the documented integrations was not tested.
Community5/5Last push on 2026-11-21, 24,436 stars and maintainers answered or closed 10 of the 10 most-discussed issues we sampled.Editor’s note: Sampled issues contain maintainer replies and reporter follow-ups, without measuring typical response time or commercial support quality.
Maturity4/5Latest release redisson-4.8.0 on 2026-10-02, repository created 2014-01-11 and its test suite did not pass in our sandbox.Editor’s note: Release metadata and historical deployment reports do not measure production reliability of version 4.8.0.

How we score

Who it’s for

Java teams that need distributed locks or typed shared collections.
Spring developers selecting a particular Redisson cache integration.
Source contributors investigating the recorded Micronaut annotation-processor failure.

Who it’s NOT for

Spring applications whose requirements stop at ordinary RedisTemplate operations and basic TTL caching: Redisson's own comparison recommends Spring Data Redis for that scope.
Buyers choosing Community Edition on the strength of the vendor's Redisson PRO benchmark against Jedis.
Teams expecting the recorded source installation to represent a passing build and test suite.

Setup reality

Our November 11, 2026 run at commit 05d1891 installed successfully in 169 seconds. The build failed with exit 1 after 126 seconds, and the test command failed with exit 1 after 33 seconds. Maven reported a compilation failure in redisson-micronaut-50 because MixinVisitorProcessor had been compiled by a more recent Java runtime, class-file version 69.0. The test tail contains skipped tests, 1 error and module SUCCESS lines.

The configured sandbox had 3 CPUs, 10g RAM and image label lab-jvm:21. The November 20 Compose attempt failed its safety check because none of the four accepted Compose filenames existed; teardown succeeded. The official getting-started guide begins with a Java dependency and client configuration.

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.

Alternatives

ProjectWhat it isPick it when
Spring Data RedisSpring's Redis abstraction for templates and caching.Choose it for ordinary RedisTemplate operations and basic TTL caching, as Redisson's own comparison recommends.
LettuceA Redis client with reactive interfaces, described in Redisson's comparison.Consider it when command access and reactive interfaces fit your application better than Redisson's distributed-object APIs.
JedisA lightweight Redis Java client contrasted with Redisson in the vendor comparison.Consider it when your application needs command-oriented access rather than Redisson's distributed toolkit.

What people are saying

  1. [velocity-scout] redisson/redisson

Sources

  1. Redisson README
  2. Getting started
  3. Spring Data Redis comparison
  4. RLock watchdog configuration
  5. Edition comparison
  6. Lettuce comparison
  7. Jedis comparison
  8. Tencent Cloud recovery reproduction
  9. Upstash connection tutorial

More data reviews