API Models
Synchronous and Asynchronous API¶
Redisson instances are fully thread-safe.
Synchronous and Asynchronous API could be reached via RedissonClient interface.
Most Redisson objects extend asynchronous interface with asynchronous methods which mirrors synchronous methods. Like below:
// RAtomicLong extends RAtomicLongAsync
RAtomicLong obj = client.getAtomicLong("myLong");
obj.compareAndSet(1, 401);
RAtomicLongAsync objAsync = client.getAtomicLong("myLong");
RFuture<Boolean> future = objAsync.compareAndSetAsync(1, 401);
future.whenComplete((res, exception) -> {
// handle both result and exception
});
// or
future.thenAccept(res -> {
// handle result
}).exceptionally(exception -> {
// handle exception
});
Note
Avoid using blocking methods in RFuture listeners. Listeners executed by netty-threads and delays in listeners may cause errors in Redis or Valkey request/response processing.
Use the following methods to execute blocking methods in listeners:
future.whenCompleteAsync((res, exception) -> {
// handle both result and exception
}, executor);
// or
future.thenAcceptAsync(res -> {
// handle result
}, executor).exceptionallyAsync(exception -> {
// handle exception
}, executor);
Reactive API¶
Reactive API could be reached via RedissonReactiveClient interface.
Redisson's implementation based on Project Reactor.
Usage example:
RedissonReactiveClient client = redissonClient.reactive();
RAtomicLongReactive atomicLong = client.getAtomicLong("myLong");
Mono<Boolean> cs = longObject.compareAndSet(10, 91);
Mono<Long> get = longObject.get();
get.doOnSuccess(res -> {
// ...
}).subscribe();
RxJava API¶
RxJava API could be reached via RedissonRxClient interface.
Redisson's implementation based on RxJava3.
Usage example:
RedissonRxClient client = redissonClient.rxJava();
RAtomicLongRx atomicLong = client.getAtomicLong("myLong");
Single<Boolean> cs = longObject.compareAndSet(10, 91);
Single<Long> get = longObject.get();
get.doOnSuccess(res -> {
// ...
}).subscribe();
Retry policy¶
Redisson implements auto-retry policy per operation. Retry policy is controlled by retryAttempts and retryInterval settings. These settings are applied to each Redisson object. timeout setting is applied when the Redis or Valkey command was successfully sent.
Settings above can be overridden per Redisson object instance. These settings apply to each method of a given Redisson object instance.
Here is an example with RBucket object:
Config config = new Config();
config.useSingleServer()
.setRetryAttempts(2)
.setRetryInterval(1800)
.setTimeout(5000)
.setAddress("redis://127.0.0.1:6789");
RedissonClient client = Redisson.create(config);
// instance uses global retryInterval and timeout parameters
RBucket<MyObject> bucket = client.getBucket('myObject');
// instance with overridden retryInterval and timeout parameters
RBucket<MyObject> bucket = client.getBucket(PlainOptions.name('myObject')
.timeout(Duration.ofSeconds(3))
.retryInterval(Duration.ofSeconds(5)));