Redisson Releases History ================================ Try __[Redisson PRO](https://redisson.pro)__ with **ultra-fast performance** and **support by SLA**. ### 3-Sep-2021 - 3.16.2 released Feature - Micronaut 3.0 integration Feature - added batched `merge()` method to `RLiveObjectService` interface Feature - resolve hostnames used in Redis Cluster topology Feature - resolve hostnames used in Redis Sentinel topology Feature - added batched `addLast()` and `addFirst()` methods to `RDeque`, `RDequeRx` and `RDequeReactive` interfaces Feature - added `addAllCounted()` and `removeAllCounted()` methods to `RSet`, `RSetRx` and `RSetReactive` interfaces Fixed - Redis Stream trim command with MINID strategy is not fully supported Fixed - Quarkus requires `AutowiredAnnotationBeanPostProcessor` class during native image execution Fixed - issues with Quarkus Netty dependencies Fixed - `MOVED redirection loop detected` error in Redis Cluster Fixed - handling master with empty slots in Redis Cluster topology Fixed - SentinelConnectionManager should use unified compressed format for IPv6 Fixed - `RLocalCachedMap.readAllValues()` method uses key decoder instead of value Fixed - empty array passed to `RKeys.delete()` method causes thread blocking Fixed - cluster partition without address causes NPE Fixed - threads waiting for `RSemaphore` permits acquisition unable to acquire them if permits added Fixed - `RRateLimiter` allows limit overcome Fixed - `RMapCacheReactive` and `RMapCacheRx` interfaces miss method to define eviction algorithm Fixed - write-behind tasks aren't flushed after Redisson `shutdown()` method invocation Fixed - LiveObjects with indexed field can't be stored using batch persist method Fixed - failed master shouldn't skipped in Redis Cluster topology scan (thanks to @JerryWzc) Fixed - `RListReactive` iterator with filter returns non-deterministic result Fixed - `replicatedServers` mode should use ip addresses if nodes defined using hostnames Fixed - multiple masters check removed for `replicatedServers` mode Fixed - `MapWriter` should be defined along with writeBehind settings ### 26-Jul-2021 - 3.16.1 released Improvement - MarshallingCodec and JsonJacksonCodec warmup added Improvement - performance improvement for connection pool with few connections Fixed - connection leak after command error if Batch executed in REDIS_WRITE_ATOMIC mode Fixed - AsyncSemaphore race condition issue Fixed - Quarkus native remote service invocation fails Fixed - `nameMapper` setting isn't applied to `RTopic` object Fixed - Batch in REDIS_WRITE_ATOMIC mode doesn't respect batch settings Fixed - `UndeclaredThrowableException` is thrown when cache down while executing `RLiveObjectService.get()` method Fixed - Reactive Transactions aren't unlocking transactional locks Fixed - keySet() method of transactional map throws Exception Fixed - lock expiration renewal should be canceled if owner doesn't exist (thanks to @regidio) ### 28-Jun-2021 - 3.16.0 released Feature - GraalVM native-image support Feature - Spring Data Redis 2.5.x support Feature - [Helidon CDI](https://github.com/redisson/redisson/tree/master/redisson-helidon) integration Feature - [Quarkus](https://github.com/redisson/redisson/tree/master/redisson-quarkus) integration Feature - [Micronaut](https://github.com/redisson/redisson/tree/master/redisson-micronaut) integration Feature - data partitioning support for JCache Fixed - Live Object `Conditions.in()` aren't considered if defined in `Conditions.and()` clause Fixed - Redisson shutdown takes much time after `RBatch` execution Fixed - `RBatch` object in REDIS_WRITE_ATOMIC or REDIS_READ_ATOMIC mode can be corrupted by PING command Fixed - `RKeysReactive.getKeysByPattern()` method returns wrong result Fixed - `RExpirable.expire(Instant)` method doesn't work for RBloomFilter, RBoundedBlockingQueue, RDelayedQueue, RLock, RIdGenerator, RMultimap, RMapCache, RPriorityQueue, RRateLimiter, RReliableTopic, RSetMultimap, RTimeSeries objects Fixed - `RBlockingDequeReactive.takeElements()` method does not consume all elements Fixed - `RScheduledExecutorService` stops to work if task timeout occurred Fixed - `RedissonReactiveSubscription` removes listener after first 32 messages Fixed - `RedisNodeNotFoundException` is thrown after cluster failover (thanks to @UzimakiNaruto) ### 07-Jun-2021 - 3.15.6 released Fixed - `RedisSentinel.getMaster()` method throws NPE Fixed - `RSemaphore.drainPermits()` throws `ClassCastException` Fixed - missed implementation of few methods in Spring Data's RedissonConnection Fixed - `RLocalCachedMap.containsKey()` method doesn't invoke map loader Fixed - `RSemaphore` permits can't be acquired due to "Maximum permit count exceeded" error Fixed - `RedissonNode` unable to start due to `ClassNotFoundException` Fixed - SENTINEL SENTINELS command timeout (thanks to @zhwq1216) Fixed - `JCachingProvider` shouldn't depend on class from Jackson 2.12.x Fixed - `JCache.get()` method swallows Redis errors Fixed - `RLocalCachedMap` doesn't used MapLoader if storeMode = LOCALCACHE ### 12-May-2021 - 3.15.5 released Feature - `discard()` method added to `RBatch` object Feature - `broadcastSessionUpdates` setting added to Tomcat Session Manager Fixed - no error if jcache has wrong configuration in yaml format Fixed - frequent Redis master failover causes memory leak in `IdleConnectionWatcher` Fixed - `RedisStreamCommands.xGroupDelConsumer()` method in Spring Data module uses incorrect Redis command Fixed - `RLock` can't be acquired anymore if pubsub connection limit was reached (thanks to @zhwq1216) Fixed - PubSub Lock entries memory-leak during Lock acquisition (thanks to @zhwq1216) Fixed - dns monitor shouldn't use IP addresses as hostnames Fixed - failover handling stops to work if Redis Cluster node returned empty topology Fixed - `mGet()` and `mSet()` methods of Spring Data `RedissonConnection` object throw CROSSSLOT error Fixed - `touch()`, `mDel()`, `mUnlink()`, `expire()`, `pExpire()`, `expireAt()`, `pExpireAt()`, `persist()` methods of Spring Data `ReactiveKeyCommands` interface should be executed as write operation Fixed - RMap.computeIfPresent() doesn't update mutable objects Fixed - `MapReduce` timeout isn't applied if `ExecutorService` node is down Fixed - Redisson tries reconnect to Redis nodes which marked as shutdown by topology manager ### 20-Apr-2021 - 3.15.4 released Feature - sslProtocols setting added Feature - nameMapper setting added Feature - `getSigned()`, `setSigned()`, `incrementAndGetSigned()`, `getUnsigned()`, `setUnsigned()`, `incrementAndGetUnsigned()` methods added to `RBitSet` object Feature - `updateEntryExpiration()`, `getWithTTLOnly()` methods added to `RMapCache` object Improvement - Spring Cache, MyBatis Cache, Hibernate Cache implementations should read data from Redis slave if idleTime and cache size weren't specified Fixed - `ClusterConnectionManager.upDownSlaves()` method throws `ConcurrentModificationException` Fixed - `ClusterConnectionManager.checkMasterNodesChange()` method throws NPE Fixed - `JCache` `CacheEntryUpdatedListener` doesn't get old value of changed entry (thanks to @testower) ### 30-Mar-2021 - 3.15.3 released Feature - [connectionListener](https://github.com/redisson/redisson/wiki/2.-Configuration#connectionlistener) setting added Fixed - `tryAcquire()` and `availablePermits()` method of `RRateLimiter` object throw too many results to unpack error Fixed - `RRateLimiter` object throws LUA-script error Fixed - connection leak in Topology Manager for Replicated Redis config Fixed - `ConnectionListener.onConnect()` method isn't triggered during Redisson start Fixed - `addLastIfExists()` and `addLastIfExists()` methods of `RDeque` object don't work Fixed - `ArrayIndexOutOfBoundsException` is thrown if Redis master change was unsuccessful Fixed - `RScheduledExecutorService.scheduleAtFixedRate()` starts multiple instances of the same task if multiple workers defined Fixed - tasks scheduled via `RScheduledExecutorService.scheduleAtFixedRate()` method aren't executed after some time ### 22-Mar-2021 - 3.15.2 released Feature - `move()` method added to `RDeque` and `RBlockingDeque` objects Feature - `MINID` trimming strategy and `LIMIT` argument added to `RStream.add()` method Feature - new config `checkSlaveStatusWithSyncing` setting added Feature - enable tcpNoDelay setting by default (thanks to @mikawudi) Feature - `RedissonClient.reactive()` and `RedissonClient.rxJava()` methods added Feature - Spring Boot auto configuration should create `Reactive` and `RxJava` instances Improvement - simplified API of `RStream.read()` and `RStream.readGroup()` Fixed - Hibernate modules prior 5.3 version don't support fallback for `nextTimestamp()` method Fixed - `MarshallingCodec` doesn't release allocated ByteBuf object if exception thrown during encoding Fixed - `retryInterval` isn't used for next attempt if Redis client didn't send response Fixed - lease timeout updated in non-safe way in `org.redisson.RedissonLock#tryLockInnerAsync` method (thanks to @coding-tortoise) Fixed - references in RxJava objects aren't supported Fixed - Spring Data Redis module doesn't support `StreamReadOptions.isNoack()` option in `RedisStreamCommands.xReadGroup()` method. Fixed - trying to authentificate sentinel server without password Fixed - `RStream.getInfo()` method doesn't decode entries Fixed - Redisson doesn't reconnect slave if it was excluded before due to errors in failedSlaveCheckInterval time range. (thanks to @mikawudi) ### 03-Mar-2021 - 3.15.1 released Feature - `expireAt(Instant)` method added to `RExpirable` object Feature - `random()` method added to `RScoredSortedSet` object Feature - `randomKeys()` and `randomEntries()` methods added to `RMap` object Feature - count with any parameter added for search in `RGeo` object Feature - ability to search in box added for `RGeo` object Improvement - simplified RGeo API with `search` methods Improvement - added check for invocation of sync methods in async/rx/reactive listeners Fixed - continuous reconnecting to broken host if it was defined as hostname in Redisson Cluster config Fixed - `WeightedRoundRobinBalancer` filters master node in readMode=ReadMode.MASTER_SLAVE Fixed - `RPatternTopicReactive.removeListener()` method should return `Mono` Fixed - remove `authType` and `principal` attributes on Apache Tomcat logout Fixed - scheduled tasks via `RScheduledExecutorService` object can't be canceled Fixed - `RStream.claim()` method throws NPE if given id does not exist Fixed - `RPatternTopic` on keyspace/keyevent notification subscribes only to single master node in Redis cluster Fixed - Class cast exception is thrown during iteration of `RMapCache` entries Fixed - internal `RedissonBaseLock.evalWriteAsync()` method isn't executed again if cluster slaves amount > 0 Fixed - CPU spike after Slave failover if `subscriptionMode=SLAVE` Fixed - `rename()` method throws throws RedisException if `RBloomFilter` is empty Fixed - output full exception stacktrace if unable connect to sentinel server Fixed - duplicated `PING` sent when Redis connection got reconnected Fixed - Optional class can't be used as a result object in RemoteService interface Fixed - `redisson-spring-boot-starter` should use `redisson-spring-data-24` module Fixed - `RMapCacheRx.getLock()` returns `org.redisson.RedissonLock` instead of `org.redisson.api.RLockRx` Fixed - `RMapCacheReactive.getLock()` returns `org.redisson.RedissonLock` instead of `org.redisson.api.RLockReactive` ### 28-Jan-2021 - 3.15.0 released Feature - **Apache Tomcat 10** support added Feature - **Spin Lock** added. Please refer to [documentation](https://github.com/redisson/redisson/wiki/8.-Distributed-locks-and-synchronizers#89-spin-lock) for more details (thanks to @Vorotyntsev) Feature - `sentinelPassword` setting added (thanks to @ghollies) Feature - `RedisNode.getMemoryStatistics()` method added Feature - `setAndKeepTTL()` method added to `RBucket` object Feature - min idle time parameter added to `listPending()` and `pendingRange()` methods of `RStream` object Feature - `autoClaim()`, `fastAutoClaim()` and `createConsumer()` methods added to `RStream` object Feature - `addIfExists()`, `addIfGreater()` and `addIfLess()` methods added to `RScoredSortedSet` object Feature - `putIfExists()` and `fastPutIfExists()` methods added to `RMap` object Feature - `tryAdd()` and `addIfExists()` methods added to `RGeo` object Feature - `readUnion()`, `readIntersection()`, `diff()`, `readDiff()`, `rangeTo()`, `revRangeTo()` methods added to `RScoredSortedSet` object Feature - `ScoredSortedSetAddListener` added to `RScoredSortedSet` object Improvement - use `System.nanoTime()` in `IdleConnectionWatcher` to avoid clock drifting Fixed - eval command executed on Redis cluster doesn't use key for master/slave selection Fixed - `MOVED` or `ASK` response from Redis causes `Unable to acquire connection!` error Fixed - Spring Redis Data PatternTopic listeners are invoked multiple times per message Fixed - don't add Redis Slave as active if connections can't be established (thanks to @yann9) Fixed - `RBatch` object throws Exception if not all slots are covered in Redis Cluster Fixed - stream and queue object may lost entry during execution of any blocking poll operation Fixed - Redis `BUSY` response handling (thanks to @wuqian0808) Fixed - InterruptedExceptions are hidden by RedisException Fixed - primitive class numbers aren't indexed correctly in LiveObject search engine Fixed - NPE is thrown if LiveObject index stored for the first time in Redis cluster Fixed - NPE is thrown if Redis node doesn't return "flags" parameter ### 22-Dec-2020 - 3.14.1 released Feature - added option `LocalCachedMapOptions.storeCacheMiss` to store cache miss in a local cache (thanks to @ipalbeniz) Feature - LFU eviction algorithm added to `trySetMaxSize` and `setMaxSize` methods of RMapCache interface Improvement - RedisNodes ping results check optimization (thanks to @blackstorm) Improvement - keySet().isEmpty() and values().isEmpty() methods of RMap object aren't efficient Fixed - connection leak if new discovered slaves in `LOADING Redis is loading the dataset in memory` state (thanks to @mikawudi) Fixed - `RMap.putIfAbsent()` method doesn't check value for null Fixed - Apache Tomcat Valve objects should be added in context pipeline instead of engine's pipeline Fixed - slaves synchronization timeout isn't respected during `RLock.lock()` method invocation Fixed - ConnectionWatchdog may cause connection leak (thanks to @mikawudi) Fixed - `Redisson.shutdown()` method throws RejectedExecutionException Fixed - `count()` and `addAll()` methods of `RScoredSortedSetReactive` and `RScoredSortedSetRx` interfaces throw ClassCastException Fixed - `GEORADIUS_RO` command should be used instead of `GEORADIUS` in Spring Redis Data module Fixed - Spring Data Redis `RedissonConnection.del()` method doesn't work in pipeline on Redis cluster Fixed - `RLocalCachedMap.putAll()` method updates in wrong way log used for Reconnection.LOAD strategy Fixed - `redisRepository.opsForSet().distinctRandomMembers()` method throws ClassCastException ### 21-Nov-2020 - 3.14.0 released Spring Session implementation is deprecated now. Please refer to [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks#147-spring-session) for more details Feature - __`RReliableTopic` object added__. Please refer to [documentation](https://github.com/redisson/redisson/wiki/6.-distributed-objects/#613-reliable-topic) for more details Feature - __`RIdGenerator` object added__. Please refer to [documentation](https://github.com/redisson/redisson/wiki/6.-distributed-objects/#614-id-generator) for more details Feature - Spring Data Redis 2.4.0 integration Feature - `StreamMessageId.AUTO_GENERATED` const added Feature - Rx API for `RMultimapCache` object (thanks to @mlkammer) Feature - cluster-safe implementation of `rename`, `renameNX` methods of `RedissonClusterConnection` object (thanks to @eager) Feature - `RxJava2` API replaced with `RxJava3` Feature - `tryAdd()` method added to `RSet` and `RSetCache` objects Improvement - preventing sending CLUSTER NODES to the same host (thanks to @serssp) Fixed - `RSetMultimap` could throw a class cast exception on its `get()` method because it actually contained a list based multimap instance (thanks to @mlkammer) Fixed - Spring Data Redis `redisTemplate.opsForGeo().radius()` method doesn't work Fixed - `RKeys.deleteByPattern()` method executed in batch should throw `UnsupportedOperationException` in cluster mode Fixed - `CACHE_REGION_PREFIX` setting isn't applied for hibernate 5.3+ Fixed - deprecation error log about JSON config even though it's not used Fixed - update new master record in DNS monitor only if it replaced old master successfully Fixed - `RQueue.removeIf()` method should throw `UnsupportedOperationException` Fixed - Lock watchdog won't renew after reconnection (thanks to @burgleaf) Fixed - `TimeSeries.iterator()` method doesn't respect the ordering Fixed - `RRateLimiter` throws "bad argument #2 to 'unpack' (string expected, got nil)." Fixed - `CROSSSLOT` error rised when clearing a redis-spring-data cache Fixed - `RLongAdder.sum()` and `RDoubleAdder.sum()` methods return wrong result Fixed - getting error while connecting to sentinel using password Fixed - result of `RStream.read()` method isn't sorted by key ### 13-Oct-2020 - 3.13.6 released Improvement - set pingConnectionInterval = 30000 by default Fixed - CROSSLOT error thrown during RLiveObject update Fixed - `RRateLimiter.delete()` method returns false Fixed - `RBitSet.set(long bitIndex, boolean value)` should return boolean Fixed - `RBatch` doesn't handle `MOVED`, `ASK` Redis errors in Redis Fixed - "response has been skipped due to timeout" warnings were removed Fixed - additional check for blocking command added in PingConnectionHandler Fixed - object's name should be checked for null Fixed - redisson-spring-boot-starter doesn't load config file Fixed - `RTransaction` should be executed in IN_MEMORY_ATOMIC mode Fixed - high contention during connection acquisition from connection pool ### 28-Sep-2020 - 3.13.5 released **breaking change** - `spring.redis.redisson.config` setting renamed to `spring.redis.redisson.file` Feature - `RClusteredTopic` object added Feature - `RRingBuffer.setCapacity()` method added Feature - `merge()`, `compute()`, `computeIfAbsent()`, `computeIfPresent()` methods implemented for RMap-based objects Feature - spring config server support (thanks @anjia0532) Improvement - expand config variables from system properties if not found as environment variables (thanks to @jribble) Fixed - `RKeys.keysByPattern()` method doesn't use pattern (thanks to @sh1nj1) Fixed - `RObjectLiveService.delete()` method throws `ClassCastException` Fixed - fail to insert key with TTL = 0 if the same key was previously set with non-zero TTL Fixed - Pubsub channel isn't reattached to a new master after slot migration Fixed - `PingConnectionHandler` throws `CancellationException` Fixed - shared session between several Tomcats expires earlier if `readMode=Redis` and `broadcastSessionEvents=false` Fixed - incorrect session attributes being returned in `UpdateMode=AFTER_REQUEST` and `ReadMode=REDIS` Fixed - Tomcat UpdateValve object throws NullPointerException if url context doesn't exist Fixed - old value of RLiveObject's field isn't removed from index Fixed - Spring Data Redis `RedissonSubscription.onPatternMessage()` method throws `ClassCastException` Fixed - `RSemaphore.addPermits()` method doesn't work Fixed - `RMultimap.sizeInMemory()` method doesn't take in account size of all associated objects ### 02-Sep-2020 - 3.13.4 released Feature - batch support for `revRank`, `getScore`, `addAndGetRevRank` methods added to RScoredSortedSet object (thanks to @johnou) Feature - `RRateLimiter.setRate` method added (thanks to @AbhishekChandrasekaran) Feature - `RObject.getIdleTime()` method added Feature - `RKeys.getKeysWithLimit()` method added Fixed - `RRateLimiter.availablePermits()` method throws exception (regression since 3.13.3) Fixed - compatibility with Spring Data Redis 2.3.3 Fixed - `UnsupportedOperationException` is thrown if Spring Data Redis connection executed in pipelined mode Fixed - multiple Tomcat requests share different instances stored in the same session in `readMode=REDIS` Fixed - Spring Data Redis can't be used with proxied RedissonClient instance Fixed - Classloading issues when `MarshallingCodec` used in Tomcat Fixed - Redis cluster slot calculation doesn't work properly if brace isn't closed (thanks to @dengliming) Fixed - `RBloomFilter` rename method doesn't rename config object (thanks to @dengliming) Fixed - `slf4j-simple` dependency excluded from redisson-all Fixed - `JCache.removeAsync` method throws NPE if operation fails Fixed - all cached Lua scripts are executed on Redis master nodes only Fixed - `XPENDING` command causes syntax error in redisson-spring-data-23 Fixed - `CommandPubSubDecoder` throws NPE Fixed - `MasterSlaveConnectionManager` allocates superfluous 113Kb of memory for non-cluster Redis setup ### 05-Aug-2020 - 3.13.3 released Feature - BITFIELD command support added to `RBitSet` object Improvement - reset ClassIntrospector instance after `RLiveObjectService.persist()` method invocation Improvement - amount of simultaneously created connections during pool initialization reduced to 10 Fixed - "SlaveConnectionPool no available Redis entries" error is thrown after failover Fixed - check RedisConnection status befor RedisConnection object join freeConnections (thanks to @mikawudi) Fixed - different topics subscribed to the same Redis node in Cluster Fixed - `RFairLock.tryLock()` method doesn't apply waitTimeout parameter Fixed - `RLiveObjectService.delete()` method works asynchronously Fixed - deserialization exception is thrown if `RMapCache.EntryRemovedListener` is set Fixed - incorrect registration of Sentinel node defined with hostname Fixed - OOM arise during `RLiveObjectService.persist()` method invocation Fixed - MarshallingCodec throws IllegalArgumentException: RIVER Fixed - `RLock.lock()` method throws java.util.NoSuchElementException Fixed - Spring Data Redis xReadGroup should use write operation Fixed - Spring Data Redis connection in multi mode may cause thread hang Fixed - Spring Data Redis connection in multi mode may cause connection leak Fixed - `RRateLimiter` rate interval might be exceeded ### 02-Jul-2020 - 3.13.2 released Feature - Partitioning (sharding) of Redis setup using [ShardedRedisson](https://github.com/redisson/redisson/wiki/5.-Data-partitioning-(sharding)#2-partitioning-sharding-of-redis-setup) object Feature - `CLUSTERDOWN` error handling Feature - `getConfig`, `setConfig` methods added to `RedisNode` interface Fixed - empty sentinels list handling Fixed - RMapCache.clear() method clears maxSize option Fixed - Redisson slowdowns access to hibernate in fallback mode Fixed - Sentinel hostname isn't used for ssl connection during Redisson startup Fixed - `RBloomFilter` methods throw NPE if RedisException thrown Fixed - `RAtomicDouble.getAndSet()` method throws NPE Fixed - `RAtomicLong.getAndSet()` method throws NPE Fixed - ClassCastException thrown in Tomcat environment Fixed - RSetMultimap.get().delete() and RListMultimap.get().delete() methods throw exception Fixed - blocking commands connected to Redis Cluster aren't resubscribed after Master node failover Fixed - connection leak if SSL connection got reconnected ### 09-Jun-2020 - 3.13.1 released Feature - Spring Data Redis 2.3.0 integration Feature - `setIfExists` method added to `RBucket`, `RBucketRx`, `RBucketReactive` interfaces Feature - RExpirable interface added to RRateLimiter Fixed - Topic channels connected to master node aren't resubscribed Fixed - RedissonCacheStatisticsAutoConfiguration conditions aren't match Fixed - `RTimeSeries.destroy()` method doesn't work Fixed - Redis Cluster topology scanning stopped if error occured while adding new master Fixed - StreamInfoDecoder to adapt to layout of XINFO response (thanks to @fawitte) Fixed - Redis Cluster manager throws error Slot hasn't been discovered yet after failover Fixed - Spring Data Redis `RedisConnection.set()` method returns null Fixed - `RQueueReactive.poll(int limit)` method should return `Mono>` Fixed - `RQueueRx.poll(int limit)` method should return `Single>` Fixed - `RedissonSetMultimap.removeAll` method removes reference to nested set Fixed - `WriteRedisConnectionException` is thrown after Redis Cluster failover Fixed - `RBatch` object doesn't wait ending of sync slaves process Fixed - ssl connection can't be established if Redis Sentinel was discovered by DNSMonitor Fixed - some tasks are not executed if RedissonNode shutdown Fixed - `NatMapper` is not applied to the first online Sentinel in list ### 25-May-2020 - 3.13.0 released Feature - __TimeSeries object added__. Please refer to [documentation](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#723-time-series) for more details Feature - `RLiveObjectService.findIds()` method implemented Feature - `RLiveObjectService.count()` method implemented Feature - `RLiveObjectService.delete()` method accepts multiple ids Improvement - __default codec changed to MarshallingCodec__ Fixed - Lock acquisition hangs if Redis failed (regression since 3.12.5) Fixed - `RLiveObjectService.merge()` method doesn't override collection state Fixed - `PingConnectionHandler` doesn't report errors if PING command can't be sent Fixed - `RObject.unlink()` method calls `deleteAsync()` inside instead of `unlinkAsync()` method (thanks to @AayushyaVajpayee) Fixed - NPE thrown after logout Tomcat application Fixed - Tomcat `UpdateValue` object throws NPE if getNext() returns null Fixed - `RedissonTransactionalMapCache.put()` method inserts entries with incorrect TTLs Fixed - connections to Redis master/slave are doubled after redis cluster failover Fixed - `RejectedExecutionException` thrown by `RedisClient.connectAsync()` method during shutdown process Fixed - cache isn't applied to hibernate collection, that is joined by non primary key field Fixed - hibernate 5.3 doesn't wrap cache exception into CacheException object Fixed - RedissonReactiveStringCommands.set using wrong SET RedisCommand (thanks to @xJoeWoo) Fixed - netty errors should be logged at ERROR level ### 16-Apr-2020 - 3.12.5 released Improvement - increased `RLock` reliability during failover. `RedLock` was deprecated Fixed - Map object is not updated after session change (thanks to @eager) Fixed - `RedissonSessionRepository` doesn't handle PTTL = -2 (thanks to @eager) Fixed - `RedissonSessionRepository` topic listener NPE race condition (thanks to @eager) Fixed - `RedissonReactiveSubscription.subscribe()` and `receive()` methods aren't synchronized Fixed - `RLiveObjectService` search with `Conditions.and()` returns wrong result Fixed - Redisson Tomcat Manager doesn't store principal and authType session attributes Fixed - Redisson is unable to start if first sentinel node in list is down Fixed - Spring Data `RedissonConnection.del()` method doesn't participate in pipeline Fixed - `RTopic.countListeners()` method returns wrong result Fixed - `RRateLimiter.delete()` method doesn't delete all allocated Redis objects Fixed - `RedissonBloomFilter` throws NPE (regression since 3.12.4) Fixed - CommandBatchService throws NPE (regression since 3.12.4) ### 30-Mar-2020 - 3.12.4 released Feature - cacheProvider setting added to `LocalCacheConfiguration`, `ClusteredLocalCachedMapOptions`, `LocalCacheConfiguration` and Hibernate Local Cache regions Feature - `NettyHook` object added Feature - `LocalCachedMapOptions.storeMode` setting added Feature - `nameMapper` setting added to `DropwizardMeterRegistryProvider` Feature - `username` parameter added Feature - `RedissonClient.getRedisNodes()` method added Feature - `Config.useThreadClassLoader` setting added Feature - `ListAddListener`, `ListInsertListener`, `ListRemoveListener`, `ListSetListener`, `ListTrimListener` added to `RList` object Improvement - `MarshallingCodec` performance improvements Fixed - RedissonSessionRepository doesn't use map's codec during changeSessionId method execution Fixed - use `FSTConfiguration#deriveConfiguration` to preserve ConfType (thanks to Chris Eager) Fixed - MGET executed on Spring Data connection should use SLAVE if readMode = SLAVE (thanks to Gil Milow) Fixed - `XREADGROUP` and `XCLAIM` commands should be executed on Redis master Fixed - `JsonJacksonCodec` unable to serialize removed attributes of Tomcat Session Fixed - "response has been skipped due to timeout" error if pingConnectionInterval setting set and blocking command executed Fixed - semaphore used during local cache clearing process isn't deleted Fixed - `RPatternTopicRx()`, `RPatternTopicReactive()`, `RPatternTopic.addListenerAsync()` methods are don't work Fixed - cache entry can't be updated if `JCache` instance created with `CreatedExpiryPolicy` Fixed - `LocalCachedJCache.get()` method throws NPE Fixed - RedisURI throws MalformedURLException for IPv6 hosts Fixed - `LocalCachedJCache.removeAll()` and `LocalCachedJCache.clear()` methods are don't work ### 28-Feb-2020 - 3.12.3 released LZ4Codec, SnappyCodec, SnappyCodecV2 codecs now use Kryo5Codec by default Feature - `SetObjectListener` added to `RBucket` object Feature - `RBinaryStream` should expose `SeekableByteChannel` and `AsynchronousByteChannel` interfaces Feature - added `RBucketsReactive` and `RBucketsRx` objects Feature - added Caffeine support as alternative local cache implementation Feature - added `RBinaryStreamReactive` and `RBinaryStreamRx` objects Feature - added `RKeys.swapdb` method Feature - added `addFirstIfExists` and `addLastIfExists` methods to `RDeque` object Feature - `RPriorityDeque` extends `RDeque` Improvement - type of `RedisExecutor.CODECS` field changed to `LRUCacheMap` Fixed - `CommandPubSubDecoder` throws NPE Fixed - `RLock.unlock()` results in ERR hash value if RedisLabs hosting is used Fixed - `RPriorityBlockingQueue.poll()` method with limit implemented Fixed - `redisson__map_cache__last_access__set*` objects continuously grow in size if RMapCache.maxSize defined Fixed - Eviction task is not stopped after `RMapCache.destroy()` method invocation ### 18-Feb-2020 - 3.12.2 released Feature - Hibernate `hibernate.cache.redisson.fallback` setting introduced Feature - added `RLocalCachedMap.preloadCache` method with batch size Improvement - `RLocalCachedMap.putAllOperation` method optimization Fixed - exception thrown by `org.redisson.jcache.JCacheEventCodec` Fixed - connection leak occured during `RBatch` object usage Fixed - Tomcat session should return the same object during the same request for `readMode = REDIS` and `updateMode = AFTER_REQUEST` settings Fixed - `RPriorityQueue` comparator is not deleted or expired after corresponding methods invocation Fixed - memory leak caused by `ClientConnectionsEntry.allConnections` field Fixed - `maxIdleTimeout = 1 hour` set to `RedisExecutor.CODECS` map Fixed - use `RBatch` for all types of Redis setup (thanks to @basiszwo) ### 31-Jan-2020 - 3.12.1 released Feature - `RTransferQueue` object added. Please refer to [documentation](https://github.com/redisson/redisson/wiki/7.-distributed-collections#722-transfer-queue) for more details Feature - `availablePermits`, `availablePermitsAsync` and `drainPermitsAsync` methods added to `RSemaphoreAsync` object Feature - `tryExecute`, `tryExecuteAsync` and `getPendingInvocationsAsync` methods added to `RRemoteService` object Feature - `natMap` setting deprecated in favor of `natMapper` Feature - `checkSentinelsList` setting added Feature - `cleanUpKeysAmount` setting added Improvement - perform Sentinel DNS check when all connections fail (thanks to @markusdlugi) Fixed - `zRemRangeByScore` and `zcount` methods of `ReactiveZSetCommands` interfaсe don't use `-inf` and `+inf` values Fixed - connections to disconnected Redis nodes aren't removed in sentinel and cluster mode Fixed - `MalformedURLException` thrown during Redis host parsing in cluster mode Fixed - extra square bracket added during IPV6 Redis host conversion Fixed - defined codec's classloader is overwritten with Thread.currentThread().getContextClassLoader() Fixed - `RPriorityQueue.add` method throws NPE Fixed - connecting to a password protected Redis Sentinel fails (thanks to @stikku) Fixed - java.lang.IllegalStateException thrown during `org.redisson.spring.cache.RedissonCacheStatisticsAutoConfiguration` introspection Fixed - `RLock` expiration renewal not working after connection problem (thanks to @edallagnol) Fixed - Spring Data `RedissonConnectionFactory` should call shutdown method on destroy on created Redisson instance ### 26-Dec-2019 - 3.12.0 released Feature - `RExecutorService` task id injection Feature - `submit()` methods with ttl parameter added to `RExecutorService` Feature - `schedule()` methods with timeToLive parameter added to `RScheduledExecutorService` Feature - `MyBatis` cache implementation added Feature - added implementation of `doSuspend` and `doResume` methods of Spring Transaction Manager Feature - `WorkerOptions.taskTimeout` setting added Feature - `RSemaphore.addPermits` method added Feature - ability to define `TaskFailureListener`, `TaskFinishedListener`, `TaskStartedListener` and `TaskSuccessListener` task listeners with WorkerOptions object Improvement - Default workers amount of `RExecutorService` set to 1 Fixed - CommandDecoder throws NPE Fixed - ReplicatedConnectionManager triggers reactivation of slaves with ip address instead of hostname (thanks to @f-sander) Fixed - Reactive/Rxjava2 transaction doesn't unlock lock on rollback or commit Fixed - Spring Transaction Manager doesn't handle Redisson `TransactionException` Fixed - `RBuckets.get` throws NPE for non-existed buckets (thanks to @d10n) Fixed - `RPermitExpirableSemaphore` does not expire Fixed - `RedissonCacheStatisticsAutoConfiguration` should be conditional on CacheMeterBinderProvider presence (thanks to @ehontoria) ### 28-Nov-2019 - 3.11.6 released Feature - `RExecutorServiceAsync.cancelTaskAsync()` method added Feature - `RExecutorService.hasTask()` method added Feature - `RExecutorService.getTaskCount()` method added Feature - `RMap` write-behind queue should be fault-tolerant Feature - added `poll()` methods with limit to `RQueue`, `RDeque`, `RDelayedQueue` objects Feature - `checkSlotsCoverage` setting added to cluster config Feature - `RExecutorService.getTaskIds()` method added Feature - `awaitAsync()` methods added to `RCountDownLatch` object Feature - `RCountDownLatchRx` and `RCountDownLatchReactive` objects added Fixed - channel subscription proccess in interruptible methods can't be interrupted Fixed - `RMap.get()` method invokes `MapWriter.write()` method during value loading Fixed - interruptible blocking methods couldn't be canceled Fixed - ClusterNodesDecoder ignore unknown flag and avoid throwing exception (thanks to ZhangJQ) Fixed - `AsyncSemaphore` counter field should be volatile Fixed - data encoding exception is not logged during remote call invocation Fixed - Spring Data ZRangeByScore method doesn't support Infinity Double value Fixed - spring metainfo files should be excluded in redisson-all artifact Fixed - `RKeysRx.getKeys()` and `RKeysReactive.getKeys()` methods throws Exception ### 26-Oct-2019 - 3.11.5 released Feature - Automatic-Module-Name entry added to manifest file Feature - `subscribeOnElements` method added to `RBlockingQueue` object Feature - `subscribeOnFirstElements` and `subscribeOnLastElements` methods added to `RBlockingDeque` object Feature - `subscribeOnFirstElements` and `subscribeOnLastElements` methods added to `RScoredSortedSet` object Feature - support of Spring Data Redis 2.2.x Feature - added batched persist method to `RLiveObjectService` object Feature - Kryo5Codec implemented Fixed - host details in Redis url cause extra bracket at the end Fixed - RBuckets.get() method doesn't work with custom codec Fixed - RLock.unlock() method hangs forever Fixed - `RStream.trim` method throws exception Fixed - Spring Data pubsub listeners executes multiple times Fixed - Redis commands processing handler consumes 100% of CPU resources ### 24-Sep-2019 - 3.11.4 released Feature - support search by numeric fields in LiveObject search engine. Follow conditions are supported: `greater than on equal`, `greater than`, `lower than`, `lower than or equal` Fixed - threads blocked waiting on CountDownLatch Fixed - `rename` and `renamenx` methods of `RMultimap` interface aren't working Fixed - memory leak caused by `FastThreadLocal` object used in `CodecDecoder` Fixed - blocking queue methods don't re-throw `InterruptedException` Fixed - `RExecutorService` tasks duplication after task retry event Fixed - `Redisson.shutdown` method blocks calling thread Fixed - Spring Boot default connection timeout is 0 seconds Fixed - IPv6 handling in Sentinel manager (thanks to [AndreevDm](https://github.com/AndreevDm)) Fixed - `RMapCache.remainTimeToLive` method returns negative remain time Fixed - `RBuckets.get` method doesn't work in Redis cluster mode Fixed - wrong error message if Sentinel server has misconfiguration ### 30-Aug-2019 - 3.11.3 released Feature - JBoss Marshalling codec implementation Feature - support for Spring's `@Autowired`, `@Value` and JSR-330 `@Inject` annotations in ExecutorService tasks Feature - SSL support for Sentinel mode Feature - `sizeInMemory()` method added to `RObjectReactive` and `RObjectRx` interfaces Feature - `getId()` method added to `RedissonClient`, `RedissonRxClient`, `RedissonReactiveClient` interfaces Improvement - `useCache` parameter added to `FstCodec` Improvement - URL object should be used for `sslKeystore` and `sslTruststore` settings Fixed - `RedisTimeoutException` thrown if retryAttempts set to 0 Fixed - `RStream.readGroup` method doesn't work properly with `TypedJsonJacksonCodec` Fixed - semaphore object is not deleted after `RLocalCachedMap.clearLocalCache` method invocation Fixed - Redisson couldn't be shutdown if one of RBatch commands was canceled ### 03-Aug-2019 - 3.11.2 released Improvement - `RLiveObject` interface should extend `RExpirable` Improvement - `RKeys.deleteByPattern` method performance improvements Fixed - `RBatch.execute` method throws `NoSuchElementException` Fixed - `RedisTimeoutException` is thrown if retryInterval set to 0 Fixed - `Set.intersection`, `union` and `diff` methods should return Integer Fixed - `FSTCodec` state is not fully copied Fixed - `CommandAsyncService.CODECS` map changed to Soft reference map Fixed - `RKeys.deleteByPatternAsync` method doesn't work in batch mode Fixed - subscribe timeouts after failover Fixed - a new attempt is not made if node with defined slot wasn't discovered Fixed - some methods of `RScript` object doesn't use defined codec Fixed - `RedissonConnection.set` method returns null if invoked with expiration parameter Fixed - `removeAll` method doesn't work on collections returned by Multimap based objects ### 25-Jun-2019 - 3.11.1 released Feature - `getPendingInvocations` method added to `RRemoteService` object Feature - `natMap` setting support for Sentinel mode (thanks to [fgiannetti](https://github.com/fgiannetti)) Feature - `listPending` method added to `RStream`, `RStreamAsync`, `RStreamRx`, `RStreamReactive` interfaces Feature - implementation of Spring Session `ReactiveSessionRepository` added Feature - allow usage of multiple env variables with default values in one config entry (thanks to [tristanlins](https://github.com/tristanlins)) Improvement - Use maven packaging for redisson project as jar instead of bundle (thanks to [jchobantonov](https://github.com/jchobantonov)) Improvement - add default entries in MANIFEST.MF file and extra Build-Time entry as well (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - RMap.replace method doesn't update idle timeout (thanks to [mcacker](https://github.com/mcacker)) Fixed - timeout drift in RedissonFairLock (thanks to [jncorpron](https://github.com/jncorpron)) Fixed - dead Sentinel appears in logs as node added and down Fixed - Publish/Subscribe connections are not resubscribed properly after failover process Fixed - `RedissonLocalCachedMap.clearLocalCache` method is not executed asynchronously Fixed - Tomcat `RedissonSession.setAttribute` method doesn't check the value for null (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - Tomcat Manager UpdateValve should be installed only once (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - remove MessageListener from topic when Tomcat Session Manager stopInternal is invoked (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - `RStream.getInfo` method throws `java.lang.ClassCastException` Fixed - `RedissonMultiLock` could be acquired by multiple threads if `waitTime` == -1 and `leaseTime` != -1 Fixed - `PRINCIPAL_NAME_INDEX_NAME` key is not created in redis Fixed - `SessionExpiredEvent` is not triggered in Spring Session implementation Fixed - host name containing underscore cause NPE Fixed - Illegal reflective access by org.redisson.misc.URIBuilder warning removed Fixed - `RedissonSessionRepository` doesn't trigger created event if `keyPrefix` setting is not null (thanks to [hs20xqy](https://github.com/hs20xqy)) Fixed - `RRemoteService.getFreeWorkers` method removes registered service Fixed - zero timeout isn't respected in `RRateLimiter.tryAcquire` method Fixed - `RedissonObjectBuilder.REFERENCES` map should be filled one time Fixed - RReadWriteLock.readLock doesn't take in account expiration date of the last acquired read lock. (thanks to [Aimwhipy](https://github.com/Aimwhipy)) Fixed - result object of RMapRx.iterator methods don't return `Flowable` object Fixed - Tomcat Session doesn't expire if `broadcastSessionEvents = true` Fixed - ClassNotFoundException thrown during `SerializationCodec.decode` method invocation (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - connections amount setting for mirrors is not applied in Proxy mode ### 28-May-2019 - 3.11.0 released Feature - `radiusStoreSortedTo` methods added to `RGeo`, `RGeoAsync`, `RGeoRx`, `RGeoReactive` interfaces Feature - Local cache for `JCache` added. Read the [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks#1442-jcache-api-local-cache) for more details Feature - `Async`, `Reactive`, `RxJava2` interfaces added to `JCache`. Read the [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks#1441-jcache-api-asynchronous-reactive-and-rxjava2-interfaces) for more details Feature - `RRingBuffer` object added. Read the [documentation](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#721-ring-buffer) for more details Improvement - reduced memory consumption by ClusterConnectionManager Improvement - UpdateValve needs to execute manager.store only once at the end of the request (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - `HttpSessionListener.sessionDestoyed` method isn't invoked if session wasn't loaded by Tomcat instance Fixed - redisson-spring-data `ReactiveSubscription.receive` method throws NPE Fixed - Redis response isn't fully consumed after decoding error Fixed - Spring Session PRINCIPAL_NAME_INDEX_NAME session attribute has incorrect name Fixed - internal `AsyncSemaphore` object doesn't notify sleeping threads with permits more than one Fixed - `RedisTemplate.radius` and `RedisConnection.geoRadius` methods throws `IllegalArgumentException` during response decoding Fixed - `RedissonNodeConfig.mapReduceWorkers` setting couldn't be set (thanks to xiaoxuan.bai) ### 29-Apr-2019 - 3.10.7 released Feature - Add support for [Reactive and RxJava2 interfaces](https://github.com/redisson/redisson/wiki/9.-distributed-services#913-remote-service-asynchronous-reactive-and-rxjava2-calls) to RemoteService object Feature - MILLISECONDS option added to RRateLimiter.RateIntervalUnit object Feature - range method added to RList, RListReactive and RListRx interfaces Improvement - `JCache.getAll` execution optimization for non-existing keys Improvement - 10X Performance boost for `JCache.putAll` method Fixed - disconnected sentinels shouldn't be used in sentinel list Fixed - Apache Tomcat `RedissonSessionManager` doesn't use classloader aware codec for session Map object (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - LiveObject field with Map type couldn't be persisted Fixed - `RRateLimiter` allows permits limit exceeding Fixed - `CompositeCodec.getMapValueDecoder` method uses `MapKeyDecoder` instead of `MapValueDecoder` Fixed - memory leak during blocking methods invocation of Queue objects Fixed - Apache Tomcat `RedissonSessionManager.findSession` shouldn't create a new one session (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - `JCache.removeAll` method doesn't notify Cache listeners Fixed - `UpdateValve` sould be removed from pipeline in Apache Tomcat `RedissonSessionManager.stopInternal` method (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - Redis Sentinel prior 5.0.1 version doesn't require password. Regression since 3.10.5 version Fixed - Redisson tries to renewed Lock expiration even if lock doesn't exist. Regression since 3.10.5 version Fixed - FstCodec can't deserialize ConcurrentHashMap based object with package visibility ### 05-Apr-2019 - 3.10.6 released Feature - `broadcastSessionEvents` setting added to Tomcat Session Manager Feature - `remainTimeToLive` method added to `RLock`, `RLockAsync`, `RLockRx` and `RLockReactive` interfaces Feature - NAT mapping support for cluster mode Feature - `isLock` method added to `RLockAsync`, `RLockRx`, `RLockReactive` interfaces Feature - `writeBehindDelay` and `writeBehindBatchSize` settings added to `MapOptions` object Improvement - Eviction task logging added Improvement - `MapWriter` interface retains only two methods for handling batch updates Improvement - `MapOptions.writeBehindThreads` parameter removed Fixed - `RBitSet.asBitSet` methods throws NPE if RBitSet object doesn't exist Fixed - `JCache.getAll` method throws `RedisException: too many results to unpack` Fixed - `RLock.lock` method can be interrupted with `Thread.interrupt` method Fixed - Tomcat Session parameters aren't updated completely in `readMode=MEMORY` Fixed - `RLock.unlock` method returns true if lock doesn't exist Fixed - Tomcat Session Manager doesn't remove session attributes in `updateMode=AFTER_REQUEST` Fixed - Pattern topic listeners fail to re-attach on cluster failover (thanks to [shailender-bathula](https://github.com/shailender-bathula)) Fixed - `CommandPubSubDecoder.decodeResult` throws `IllegalStateException` in JBOSS environment Fixed - NullValue object shouldn't be stored if `RedissonSpringCacheManager.allowNullValues = false` Fixed - `removeListener` method of `RTopicReactive` and `RTopicRx` interfaces throws NoSuchMethodException ### 20-Mar-2019 - 3.10.5 released Feature - `getMultiLock`, `getRedLock` methods added to `RedissonClient`, `RedissonRxClient` and `RedissonReactiveClient` interfaces Feature - `getInfo`, `listGroups`, `listConsumers` methods added to `RStream`, `RStreamRx`, `RStreamReactive` interfaces Feature - `RPatternTopic.removeListenerAsync` method added Feature - `getAndSet` method with TTL support added `RBucket`, `RBucketAsync`, `RBucketReactive`, `RBucketRx` interfaces Feature - `addListener` and `removeListener` methods added to `RObject`, `RObjectAsync`, `RObjectReactive`, `RObjectRx` objects. It allows to add and remove listeners for Deleted and Expired keyspace events published by Redis Improvement - shuffle list of sentinels to distribute load (thanks to [hrakaroo](https://github.com/hrakaroo)) Improvement - methods of RxJava2 interfaces should use full set of result objects: `Single`, `Maybe` or `Completable` Fixed - compatibility with hibernate 5.2.0 - 5.2.4 versions Fixed - ClassCastException during `RBatchReactive` and `RBatchRx` execution in `exectionMode` = `REDIS_WRITE_ATOMIC` or `REDIS_READ_ATOMIC` Fixed - sentinel mode doesn't support AUTH command Fixed - response shouldn't be printed in case of response timeout error Fixed - HP NONSTOP OS is not supported by `MapCacheEventCodec` Fixed - RStream.readGroup method doesn't handle empty result properly with Redis 5.0.3 Fixed - AUTH password included in exceptions Fixed - locked lock isn't unlocked after disconnect to Redis ### 08-Mar-2019 - version 3.10.4 released Feature - `getCountDownLatch`, `getPermitExpirableSemaphore`, `getSemaphore`, `getFairLock` methods added to `RMultimap` object Feature - `maxCleanUpDelay` and `minCleanUpDelay` settings added to `Config` object Fixed - `RLocalCachedMap.destroy` method doesn't clear local cache Fixed - HP NONSTOP OS is not supported by MapCacheEventCodec Fixed - `RedissonLocalCachedMap.readAll*` methods throw NPE if `evictionPolicy = WEAK` used Fixed - codec provided in Redisson configuration isn't used for attribute messages serialization Fixed - ClassNotFoundException is thrown by Tomcat Session Manager in `readMode = MEMORY` Fixed - fresh Tomcat instance unable to load session stored in Redis Fixed - negative delay shouldn't be allowed to define for `RDelayedQueue.offer` method Fixed - eviction delay for `RMapCache` object is not decreased Fixed - `RMultiLock.tryLockAsync` and `RMultiLock.lockAsync` methods may hang during invcation ### 26-Feb-2019 - 3.10.3 released Feature - `RTransaction.getBuckets` method added Feature - ability to redefine `CacheKeysFactory` in Hibernate Cache Factory Feautre - ability to specify default values for environment variable (thanks to [aaabramov](https://github.com/aaabramov)) Feature - `RRateLimiter.getConfig` method added Feature - `ping` and `pingAll` methods with timeout added to `Node` object Improvement - create Redis stream group if it doesn't exist Improvement - response decoding optimization Fixed - `RStream.listPending` throws `IndexOutOfBoundsException` Fixed - `LocalCacheView.toCacheKey` method throws `StackOverflowError` Fixed - `RedissonSessionManager` doesn't support async servlets (thanks to [dnouls](https://github.com/dnouls)) Fixed - FSTCodec memory leak Fixed - rename and renamenx methods don't change name of current object Fixed - performance regression of RBatch result decoding (since 2.12.2 / 3.7.2 version) Fixed - Transactional RBucket object doesn't respect transaction timeout ### 07-Feb-2019 - versions 2.15.2 and 3.10.2 released Feature - `StreamMessageId.NEVER_DELIVERED` added Feature - [decodeInExecutor](https://github.com/redisson/redisson/wiki/2.-Configuration#decodeinexecutor) setting added Feature - `lockAsync` and `tryLockAsync` methods with threadId param added to RedissonMultiLock object Improvement - default values of `nettyThreads` and `threads` settings set to `32` and `16` respectively Improvement - Redis nodes with empty names in cluster config should be skipped Fixed - `RFuture.cause()` method should return CancellationException and not throw it Fixed - continues handling of RedisLoadingException leads to excessive load Fixed - slave's connection pools are not initialized when it back from failover Fixed - Buffer leak during failover and RBatch object execution Fixed - NumberFormatException error appears in log during RStream.readGroup invocation Fixed - already wrapped IPv6 addresses shouldn't be wrapped in square brackets (thanks to [antimony](https://github.com/antimony)) Fixed - NPE arise during Tomcat Session getAttribute/delete methods invocation (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - huge messages logged in case of decoding error Fixed - Redis password shouldn't be included in exceptions Fixed - Redis Password visible in log Fixed - infinite loop in RedLock or MultiLock (thanks to [zhaixiaoxiang](https://github.com/zhaixiaoxiang)) Fixed - `RBatch` object in `REDIS_READ_ATOMIC` execution mode is not executed on Redis salve Fixed - MOVED loop redirect error while "CLUSTER FAILOVER" (thanks to [sKabYY](https://github.com/sKabYY)) Fixed - redisson configuration in yaml format, located in classpath, couldn't be loaded by hibernate factory Fixed - class files should be excluded from META-INF folder Fixed - `JndiRedissonSessionManager` shouldn't shutdown Redisson instance (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - `RDestroyable` interface should be implemented by RMapCache and RSetCache rx/reactive objects ### 21-Jan-2019 - versions 2.15.1 and 3.10.1 released Feature - `cachedKeySet`, `cachedValues`, `cachedEntrySet` and `getCachedMap` methods added to `RLocalCachedMap` object Feature - __Hibernate 5.4__ support Feature - [search LiveObjects](https://github.com/redisson/redisson/wiki/9.-Distributed-services#rindex) by field Feature - allow checking if lock is held by a thread (thanks to [hackworks](https://github.com/hackworks)) Improvement - return `null` if Tomcat session attribute couldn't be parsed Improvement - Tomcat Session key codec changed to StringCodec Improvement - Spring Session key codec changed to StringCodec Improvement - Tomcat Session recycle method implementation (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - RRateLimiter RateType checking (thanks to [shengjie8329](https://github.com/shengjie8329)) Fixed - implementation of workaround for DNS name resolver bug Fixed - running scheduleWithFixedDelay Job couldn't be canceled Fixed - master can't be changed anymore if new master wasn't added the first time Fixed - don't send PING command for blocking queues Fixed - getting `java.lang.ClassNotFoundException` if same Redisson instance used in tomcat and application (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - Tomcat Session manager throws `java.lang.ClassNotFoundException` if `readMode=MEMORY` (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - ReplicatedConnectionManager doesn't recover Master node as Slave after failover Fixed - Spring Session manager process changes of unnecessary keys Fixed - Tomcat Session expires in Redis earlier than scheduled by Tomcat (thanks to [jchobantonov](https://github.com/jchobantonov)) Fixed - Tomcat Session `getAttribute` method throws NPE Fixed - `BlockingQueue.drainTo` doesn't work when queue contains only one element Fixed - `RTopic.removeListener` method throws `RejectedExecutionException` Fixed - connection is not reconnected if init command failed to send Fixed - `keepAlive` setting is not set for single server connection mode Fixed - NPE in CommandPubSubDecoder Fixed - `pollFromAny` doesn't support Redis cluster Fixed - `RGeo.pos` throws `ClassCastException` Fixed - `LRUCacheMap` throws `ArrayIndexOutOfBoundsException` Fixed - IPv6 hosts support (thanks to [antimony](https://github.com/antimony)) ### 27-Dec-2018 - versions 2.15.0 and 3.10.0 released Feature - new __[Hibernate cache](https://github.com/redisson/redisson/tree/master/redisson-hibernate) implementation__ Feature - __Hibernate 5.3__ support Feature - [TypedJsonJacksonCodec](https://github.com/redisson/redisson/blob/master/redisson/src/main/java/org/redisson/codec/TypedJsonJacksonCodec.java) added Feature - `getCountDownLatch`, `getSemaphore`, `getPermitExpirableSemaphore`, `getFairLock` methods added to `RMap` object Feature - `getCountDownLatch`, `getSemaphore`, `getPermitExpirableSemaphore`, `getFairLock` methods added to `RSet` object Feature - `RTopic.countSubscribers` method added Feature - `JndiRedissonFactory` and Tomcat `JndiRedissonSessionManager` added Feature - Hibernate Region Factories with JNDI support Feature - ability to use Environmental Variables in config files Feature - Spring Data Redis 2.1.x support added Feature - Spring Boot Starter 2.1.x support added Feature - Spring Data Redis 2.0.x and 2.1.x integrations support `ReactiveRedisTemplate` Feature - Support of [Different monitoring systems](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks#1410-statistics-monitoring-jmx-and-other-systems) Improvement - RGeo.radius methods use GEORADIUS_RO and GEORADIUSBYMEMBER_RO commands Improvement - restored implementation of DnsAddressResolverGroupFactory Improvement - RedisConnectionClosedException removed Improvement - __default codec changed to FSTCodec__ Fixed - `RMap.getAll` throws `ClassCastException` during transaction execution Fixed - `pingConnectionInterval` and `lock-watchdog-timeout` parameters added to `redisson.xsd` Fixed - zRevRangeWithScores does not work properly in Spring RedisTemplate Fixed - `CommandDecoder` throws `IndexOutOfBoundsException` if `pingConnectionInterval` param is used Fixed - NPE in `CommandDecoder` Fixed - error during channel initialization is not logged Fixed - `RBitSet` object couldn't be used as nested object Fixed - use `keyPrefix` for topic object used in Tomcat Session Manager Fixed - unable connect to Redis on Android Fixed - `RMapCache` element expiration doesn't work with map size = 1 Fixed - MOVED handling Fixed - Pooled connection closed after MOVED redirection Fixed - Master node shouldn't be shutdown on slave down event in Sentinel mode Fixed - `RoundRobinLoadBalancer` doesn't distribute load equally if one of slave nodes failed Fixed - Spring Session `keyPrefix` setting isn't used in session name Fixed - failed Redis Master node is not shutdown properly Fixed - Redisson shouldn't be shutdown in Spring Data RedissonConnectionFactory Fixed - Redisson Spring Boot doesn't start properly without lettuce or jedis in classpath Fixed - validation of filled out Redis node address in Config ### 21-Nov-2018 - versions 2.14.1 and 3.9.1 released Feature - `takeFirstElements` and `takeLastElements` streaming methods added to `RBlockingDequeRx` Feature - `RBlockingQueueRx.takeElements` streaming method added Feature - `RTopicRx.getMessages` streaming method added Feature - async methods for listener removal added to `RTopic` object Feature - RxJava2 method call cancellation support added Feature - `RObject.getSizeInMemory` method added Feature - `RTopic.countListeners` method added Feature - `takeFirstElements` and `takeLastElements` added to `RScoredSortedSetReactive` and `RScoredSortedSetRx` objects Feature - `takeFirst` and `takeLast` methods added to `RScoredSortedSet` object Feature - `readGroup` method variations added to `RStream` object Feature - `remove`, `trim`, `fastClaim`, `removeGroup`, `removeConsumer`, `updateGroupMessageId` methods added to `RStream` object Improvement - JCache performance optimization up to 2x times Improvement - Redis url validation Fixed - Exception serialization by Jackson codec Fixed - DNS channels aren't pooled Fixed - RStream commands don't work with Redis 5.0.1 version Fixed - task scheduled with cron pattern isn't executed with single worker Fixed - Spring Boot Starter doesn't convert properly list of sentinel addresses Fixed - `RTopic` and all objects based on it stop work properly if Subscribe timeout occured Fixed - JDK 1.6 compatibility for 2.x version Fixed - IPv6 addresses format support for Sentinel mode (thanks to Mikhail Surin) Fixed - null value handling for Spring Boot Starter's `timeoutValue` setting (Thanks to junwu215177) Fixed - OOM during `RLocalCachedMap.fastPut` method invocation and Reference based EvictionPolicy is used Fixed - exception in CommandDecoder while using PubSub with ping Fixed - `RTopic.removeAllListeners` invocation leads to PubSub connections leak Fixed - all methods of `RSemaphoreRx` and `RAtomicDoubleRx` objects should return `Flowable` object Fixed - `Redisson.createRx` method should return RedissonRxClient ### 31-Oct-2018 - versions 2.14.0 and 3.9.0 released Feature - `RMap.putAll` with ttl param (thanks to [Tobias Wichtrey](https://github.com/wtobi)) Feature - RxJava 2 support. Please refer to [documentation](https://github.com/redisson/redisson/wiki/3.-Operations-execution#32-reactive-way) for more details Feature - Lambda task definition for `RExecutorService`. Please refer to [documentation](https://github.com/redisson/redisson/wiki/9.-Distributed-services#932-distributed-executor-service-tasks) for more details Feature - multi-type listeners support for `RTopic` and `RPatternTopic` objects. Please refer to [documentation](https://github.com/redisson/redisson/wiki/6.-Distributed-objects#67-topic) for more details Feature - `useScriptCache` setting added. Manages by Lua-script caching on Redis side. Please refer to [documentation](https://github.com/redisson/redisson/wiki/2.-Configuration#usescriptcache) for more details Feature - added `RMap.putAllAsync` method with batch size Feature - added `RSet.random` method limited by count Improvement - memory allocation optimization during ExecutorService task execution Fixed - `keepAlive` is not being set Fixed - Redisson can't resolve short DNS name Fixed - Redisson shuts down executor it doesn't own Fixed - "spring.redis.cluster.nodes" param parsing for spring-boot Fixed - `Node.ping` throws Exception if node is unreachable Fixed - NPE in `CommandDecoder` Fixed - `DecoderException` thrown when `pingConnectionInterval` setting being set Fixed - `BlockingQueue.take` method doesn't survey failover Fixed - `SnappyCodecV2` codec doesn't decode properly underlying data encoded by FST codec Fixed - `UnsupportedOperationException` thrown when using Spring Actuator with redisson-spring-data lib ### 06-Oct-2018 - versions 2.13.2 and 3.8.2 released Feature - `RPermitExpirableSemaphore.updateLeaseTime` method added Improvements - cluster state check Fixed - DNS resolver fails to find valid DNS record Fixed - MultiLock should attempt to release locks if request was sent successfully Fixed - `RRateLimiter.tryAcquire` with timeout blocks forever Fixed - CommandAsyncService blocks indefinitely if MapLoader's methods throw exception Fixed - RedisConnection is not closed if QUIT command wasn't sent successfully Fixed - Spring Boot resource encoding Fixed - failed Redis slaves handling Fixed - read locks aren't acquire lock at the same moment when write released Fixed - empty RBoundedBlockingQueue's capacity increases when using poll method Fixed - tomcat session replication in IN_MEMORY mode (thanks to Yasin Koyuncu) ### 18-Sep-2018 - versions 2.13.1 and 3.8.1 released Feature - __RStream__ object added. Please refer to [documentation](https://github.com/redisson/redisson/wiki/7.-Distributed-collections#720-stream) for more details Fixed - `failedSlaveCheckInterval` setting is not applied under some conditions Fixed - `spring.factories` and `spring.provides` files added to Spring Boot module Fixed - `pingConnectionInterval` setting affects re-connection process with password enabled setting Fixed - Lock watchdog does not monitor read locks Fixed - Lock expiration renewal should be canceled if unlock method failed to execute Fixed - `BlockingQueue.take` method doesn't work properly after failover Fixed - Avoid to create connection per `RRemoteService/RScheduledExecutorService` worker Fixed - backward JDK 8 compatibility ### 03-Sep-2018 - versions 2.13.0 and 3.8.0 released Feature - __Spring Data Redis__ integration. Please refer to [documentation](https://github.com/redisson/redisson/tree/master/redisson-spring-data#spring-data-redis-integration) for more details Feature - __Spring Boot Starter__ implementation. Please refer to [documentation](https://github.com/redisson/redisson/tree/master/redisson-spring-boot-starter#spring-boot-starter) for more details Feature - `RBlockingDequeReactive` object added Feature - `sharedSession` setting for Tomcat Session Manager. Appropriate solution for migration of EAR based application with multiple WARs hosted previously on WebLogic or other servers. Please refer to [documentation](https://github.com/redisson/redisson/tree/master/redisson-tomcat) for more details Improvement - Redis request/response handling performance improvement Improvement - CompositeIterator decoupled from CompositeIterable (thanks to [Pepe-Lu](https://github.com/Pepe-Lu)) Fixed - task scheduled with time more than 1 hour is not executed Fixed - RScheduledExecutorService doesn't handle delayed tasks correctly Fixed - `RMapCache` and `RSetCache` objects should implement `RDestroyable` Fixed - `RBucket.set` method with ttl throws NPE if value is null Fixed - false HashedWheelTimer resource leak message Fixed - `RExecutorService` task execution performance regression Fixed - locking in multiple parallel transactions created with the same thread Fixed - `JCache.removeAll` doesn't work Fixed - Batch in `ExecutionMode.REDIS_WRITE_ATOMIC` and `ExecutionMode.REDIS_READ_ATOMIC` returns `QUEUED` instead of real result Fixed - tasks scheduled with cron expression don't work in different timezones (thanks to [Arpit Agrawal](https://github.com/arpit728)) Fixed - global config codec is not registered in codec cache for reference objects (thanks to [Rui Gu](https://github.com/jackygurui)) ### 19-Jul-2018 - versions 2.12.5 and 3.7.5 released Feature - `RScoredSortedSetReactive`, `RSetReactive`, `RListReactive` objects implement `RSortableReactive` interface Feature - `RGeoReactive` object added Feature - reactive version of FairLock added Feature - `RRateLimiterReactive` object added Improvement - RObjectReactive and RScoredSortedSetReactive interfaces synced with `RObjectAsync` and `RScoredSortedSetAsync` Fixed - readonly command shouldn't be executed on master node used as slave Fixed - connection is closed per command execution for master node used as slave in `readMode=MASTER_SLAVE` Fixed - `RLiveObjectService` should use entityClass's classloader ### 16-Jul-2018 - versions 2.12.4 and 3.7.4 released Feature - dump and restore methods added to `RObject` interface Fixed - Redis response hangs if `RLiveObject` stored as nested object Fixed - slow Redisson initialization in Sentinel Fixed - missing PubSub messages when pingConnectionInterval setting is specified Fixed - `RBatch` in `ExecutionMode.REDIS_WRITE_ATOMIC` and `ExecutionMode.REDIS_READ_ATOMIC` modes throws NumberFormatException exception Fixed - `RRedissonRateLimiter.acquire` blocks forever Fixed - lot of connections remain in TIME_WAIT state after Redisson shutdown Fixed - `ClassNotFoundException` arise in Tomcat session manager Fixed - `RHyperLogLog.addAll` method doesn't add all elements ### 27-Jun-2018 - versions 2.12.3 and 3.7.3 released Feature - added `RKeys.getKeys` method with batch size Feature - added `SnappyCodecV2` codec Fixed - `SerializationCodec` doesn't support proxied classes Fixed - NPE if `RScheduledExecutorService`'s task scheduled with cron expression for finite number of execution Fixed - validation of cron expression parameter of `RScheduledExecutorService.schedule` method Feature - Iterator with batch size param for all `RSet`, `RMap`, `RMapCached` objects Fixed - missing PubSub messages when `pingConnectionInterval` setting is specified Fixed - excessive memory consumption if batched commands queued on Redis side Fixed - `RRateLimiter.acquire` method throws NPE ### 14-Jun-2018 - versions 2.12.2 and 3.7.2 released Feature - `RBatchOptions.executionMode` setting added. Please refer to [documentation](https://github.com/redisson/redisson/wiki/10.-additional-features#103-execution-batches-of-commands) for more details Fixed - NPE in JCacheManager.close method Fixed - ExecutorService tasks aren't reloaded properly Fixed - removed unnecessary creation of HashMap instances in cluster mode Fixed - `RedisNode.info` doesn't work Fixed - NullPointerException when using setPingConnectionInterval in Pub/Sub mode Fixed - LocalCachedMapDisable should implement Serializable Fixed - `ConcurrentModificationException` in `RTransaction.execute` method Fixed - exception handling in Fst and Json codec Fixed - `RedissonScoredSortedSet.contains` and `RedissonScoredSortedSet.getScoreAsync` methods use wrong codec Fixed - NPE if `RedissonLocalCachedMap` init with `ReconnectionStrategy.LOAD` param Fixed - transactional object methods get blocked at high concurrency ### 02-Jun-2018 - versions 2.12.1 and 3.7.1 released Feature - `RRateLimiter` object moved to open-source version Feature - ExecutorService task failover. Default failover interval is 60 seconds Feature - `RScoredSortedSet.pollFirst` and `pollLast` methods with count parameter added Feature - `RScoredSortedSet.pollFirst` and `pollLast` methods with timeout added Feature - `RScoredSortedSet.pollFirstFromAny` and `pollLastFromAny` methods added Improvement - `Node.time()` method returns `Time` object Improvement - RListReactive, RMapCacheReactive, RSetCacheReactive and RSetReactive are up-to-date to Async interfaces Fixed - setPingConnectionInterval is not propagated for single server configuration Fixed - ClusterConnectionManager should use shared resolverGroup Fixed - value can't be added to BloomFilter Fixed - Redis nodes with noaddr flag should be parsed correctly Fixed - methods belongs to transactional objects get blocked at high concurrency Fixed - Collection iterator doesn't use the same Redis node Fixed - ExecuteService response queue expiration time set to one hour Fixed - Executed remote tasks are not removed from Redis Fixed - `reconnectionTimeout` and `failedAttempts` renamed in xsd schema ### 14-May-2018 - versions 2.12.0 and 3.7.0 released Feature - __Proxy mode__ Please refer to [documentation](https://github.com/redisson/redisson/wiki/2.-Configuration#29-proxy-mode) for more details Feature - __Transaction API implementation__ Please refer to [documentation](https://github.com/redisson/redisson/wiki/10.-additional-features/#104-transactions) for more details Feature - __Spring Transaction API implementation__ Please refer to [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks/#147-spring-transaction-manager) for more details Feature - __XA Transaction API implementation__ Please refer to [documentation](https://github.com/redisson/redisson/wiki/10.-additional-features/#105-xa-transactions) for more details Feature - `RPermitExpirableSemaphoreReactive` object added Feature - `RMap.fastReplace` method added Feature - PING support for Pub/Sub connections Improvement - `RBatch` object settings extracted as BatchOptions object Improvement - `RBitSet.set` method should return boolean Fixed - New IP discovery through DNS doesn't work for cluster mode Fixed - replication for Tomcat Session Manager with `readMode=INMEMORY` Fixed - `pingConnectionInterval` is not applied Fixed - JDK10 compatibility Fixed - `RLiveObjectService.delete` throws NPE if entity doesn't exist Fixed - `RSemaphore` object doesn't work with zero permit Fixed - `RExecutorService.countActiveWorkers` hangs if there are no registered workers Fixed - Iterator loop and incorrect result returning Fixed - SSL connection to Azure redis is failed Fixed - NPE in SentinelConnectionManager Fixed - RemoteService synchronous invocations aren't thread safe (regression since 2.10.5 / 3.5.5 versions) Fixed - `bad argument #1 to 'len' (string expected, got boolean)` error arise for `RMapCache` object Fixed - `RedisTimeoutException` arise during blocking command execution on RBlockingQueue and RBlockingDeque objects ### 09-Apr-2018 - versions 2.11.5 and 3.6.5 released Feature - `RKeys.copy` method added Feature - `RObject.copy` method added Feature - `RSetCache.getLock` method added Fixed - `ClusterConnectionManager` throws `IllegalArgumentException` Fixed - `CommandDecoder` doesn't remove command from commands queue when response was decoded with error Fixed - `RSetMultimap.get()` doesn't create multimap entry in case of absence Fixed - an error shouldn't appear if Redisson successfully got the information at least from one sentinel/cluster Redis node Fixed - `RObject.migrate` method Fixed - hdel comand wasn't used during remote service task removal ### 27-Mar-2018 - versions 2.11.4 and 3.6.4 released Feature - `RSet.getLock` method added Fixed - race condition with load balancer node selection Fixed - `READONLY can't write against a read only slave` error during failover Fixed - NPE during failover in Sentinel mode Fixed - `JCache.getAll` causes io.netty.util.IllegalReferenceCountException Fixed - NPE in CommandDecoder handler while using RBatch object Fixed - `RSortedSet` object tries to compare wrong types Fixed - `ClassCastException` in `RListMultimapCache.removeAll` method ### 14-Mar-2018 - versions 2.11.3 and 3.6.3 released Feature - DNS monitoring for Sentinel nodes Fixed - Old/stale nodes not removed from NodesGroup Fixed - CertificateException while connecting over SSL to Azure or AWS Elasticache config endpoint Fixed - publish subscribe connections couldn't be resubscribed during failover Fixed - RedissonRedLock.tryLock doesn't work for some values of wait time parameter Fixed - NPE in JCache.getAndRemoveValue Fixed - memory leak in publish subscribe Fixed - codec classLoader wasn't used in `ExecutorService` and `RemoteService` objects Fixed - warning for disconnected slaves in sentinel mode ### 05-Mar-2018 - versions 2.11.2 and 3.6.2 released [Redisson PRO](https://redisson.pro) performance improvements for follow `performanceMode` values: `HIGHER_THROUGHPUT` - up to **25%** performance growth `LOWER_LATENCY_AUTO` - up to **100%** performance growth `LOWER_LATENCY_MODE_2` - up to **100%** performance growth `LOWER_LATENCY_MODE_1` - up to **100%** performance growth Feature - new values added to `performanceMode` setting Feature - `lockAsync` and `unlockAsync` methods added to `RedissonMultiLock` Feature - `RMapCache.remainTimeToLive` method added Feature - `Config.addressResolverGroupFactory` setting added (thanks @Hai Saadon) Improvement - `UpdateMode.AFTER_REQUEST` update mode optimization in tomcat session manager Improvement - removed ByteBuf object usage during collection iteration Fixed - `Unable to send command` error under heavy load using Redisson PRO Fixed - `expire`, `expireAt` and `clearExpire` commands aren't implemented properly for `RBloomFilter`, `RDelayedQueue`, `RFairLock`, `RLocalCachedMap` and `RPermitExpirableSemaphore` object Fixed - Redis clients duplication during discovering ip change of hostname Fixed - tomcat session renewal in tomcat session manager Fixed - `failedAttempts` setting should be applied to Slave nodes only ### 15-Feb-2018 - versions 2.11.1 and 3.6.1 released Feature - `RedissonClusteredSpringLocalCachedCacheManager` added. Please read [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks/#1421-spring-cache-local-cache-and-data-partitioning) for more details Feature - `rangeTailReversed`, `rangeHeadReversed` and `rangeReversed` methods added to `RLexSortedSet` object Feature - `RBucketsAsync` interface added Feature - `scanInterval` setting added for Sentinel mode Feature - `RLocalCachedMap.clearLocalCache` method added Fixed - remove `hset` command invocation during `RMapCache` entry loading Fixed - buffer leak in `replace` and `remove` methods of `RLocalCachedMap` object Fixed - `RRemoteService` object throws NPE Fixed - Multimap cluster compatibility Fixed - Enum support for Live Objects Fixed - Jackson 2.9 compatibility Fixed - `RTopic.removeAllListeners` got blocked on invocation Fixed - possible pubsub listeners leak Fixed - `RBatch` throws NPE with big pipeline in atomic mode Fixed - Warning about `CommandDecoder.decode()` method ### 29-Jan-2018 - versions 2.11.0 and 3.6.0 released Feature - __`atomic` setting added to RBatch object__ Please read [documentation](https://github.com/redisson/redisson/wiki/10.-additional-features#103-execution-batches-of-commands) for more details Feature - __`updateMode` setting added to Tomcat Redis Session Manager__ Please read [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks#145-tomcat-redis-session-manager) for more details Feature - __`RateLimiter` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/6.-distributed-objects/#612-ratelimiter) for more details Feature - __`RClusteredBloomFilter` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/6.-Distributed-objects#681-bloom-filter-data-partitioning) for more details Feature - __`KQueue` support added__ Please read [documentation](https://github.com/redisson/redisson/wiki/2.-Configuration#eventloopgroup) for more details Feature - __`Tomcat 9` support added__ Please read [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks#145-tomcat-redis-session-manager) for more details Feature - __`RPriorityBlockingQueue` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#718-priority-blocking-queue) for more details Feature - __`RPriorityBlockingDeque` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#719-priority-blocking-deque) for more details Feature - __`RLongAdder` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/6.-distributed-objects/#610-longadder) for more details Feature - __`DoubleAdder` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/6.-distributed-objects/#611-doubleadder) for more details Feature - `RBucket.getAndDelete`, `RAtomicLong.getAndDelete` and `RAtomicDouble.getAndDelete` methods added Feature - __`RAtomicDoubleReactive` object added__ Feature - `RPriorityQueue.pollLastAndOfferFirstTo` method added Improvement - support single config endpoint node for cluster mode Improvement - hash functions replaced with https://github.com/google/highwayhash Fixed - JDK 1.6+ compatibility for RemoteService Fixed - `setDnsMonitoringInterval(-1)` doesn't disable DNS monitoring Fixed - `RLocalCachedMap.putAll` gets stuck if map passed as parameter contains > 10000 elements Fixed - `RLocalCachedMap.put` value encoding Fixed - `RKeys.countExists` and `RKeys.touch` return wrong result in cluster mode Fixed - Wrong parsing of RScript.ReturnType.MULTI result Fixed - RedissonReadLock by name with colon couldn't be unlocked properly Fixed - `rg.springframework.cache.Cache$ValueRetrievalException`shouldn't be wrapped by IllegalStateException Fixed - `RMapCache` listeners are not working on cross-platform environment Fixed - JsonJacksonCoded shouldn't override provided objectMapper settings (thanks to @gzeskas) ### 25-Dec-2017 - versions 2.10.7 and 3.5.7 released Feature - __`RClusteredBitSet` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/6.-Distributed-objects/#641-bitset-data-partitioning) for more details Improvement - Memory consumption optimization. `RExecutorFuture` and `RScheduledFuture` shouldn't be tracked if they weren't stored Improvement - Config settings `codecProvider` and `redissonReferenceEnabled` renamed to `referenceCodecProvider` and `referenceEnabled` Fixed - `RedissonRedLock` couldn't be locked in some cases Fixed - `RRemoteService` can't ack when running redis in cluster mode Fixed - DNSMonitor fails on bootstrap with custom event loop Fixed - Redis domain name IP address renew process ### 08-Dec-2017 - versions 2.10.6 and 3.5.6 released Feature - `RSetMultimapReactive` object added Feature - `RListMultimapReactive` object added Feature - `ReconnectionStrategy` and `SyncStrategy` added to `LocalCachedMapOptions` Feature - `pingConnectionInterval` setting added Improvement - added sync on key for `JCache.invoke` method Fixed - arguments encoding for `RScript` Fixed - `MapLoader` hangs if loaded value is null Fixed - OutOfMemory during `RExecutorService` usage Fixed - NPE in `RedissonSession.save` method Fixed - NPE during `RExecutorService` usage Fixed - `SnappyCodec` can't handle data more than 32Kb Fixed - failed to continue poll remote responses if current waiting for response has been canceled Fixed - SSL support for cluster mode Fixed - task with longer start time shouldn't overlap current task with shorter start time Fixed - DNS monitor caches host name binding Fixed - ReadMode.MASTER_SLAVE should be taken in account Fixed - slave nodes should be added without freeze state Fixed - master node should be disabled if any slave up Fixed - handling connection to Redis nodes returned to online state ### 31-Oct-2017 - versions 2.10.5 and 3.5.5 released `ProjectReactor` dependency for `3.5.5` version was updated to `3.1.1` version Feature - Added pingConnection, keepAlive, tcpNoDelay settings Feature - Slaves synchronization support for `RBatch`/`RBatchReactive` objects Improvement - Data encoding should be executed on client thread only Improvement - Handling Redis redirect optimization Improvement - Better collection handling for RedissonReference (thanks to Rui Gu) Fixed - `RedisLoadingException` handling during re-connection process Fixed - `RedisClient` can't be shutdown properly Fixed - timeout drift for `RFairLock` Fixed - expiration handling of reentrant write lock Fixed - `RReadWriteLock` doesn't work in cluster Fixed - Blocking queues are't rethrow exceptions Fixed - out of connections problem on high load during `RemoteExecutorService`/`ExecutorService` usage Fixed - NPE during `RemoteService` object usage Fixed - Getting memory leak warnings when gracefully shutting down tomcat Fixed - `RMapCache.getAll` doesn't support large keySet ### 28-Sep-2017 - versions 2.10.4 and 3.5.4 released Feature - added `maxSize` setting for `SpringCacheManager` Feature - allow `LiveObjectService` to work with classes that inherit from REntities (thanks to @sdjacobs) Improvement - `RMapCache` entires eviction process optimized Improvement - handling of slave down process Fixed - operation on slave coldn't be executed after its restart (thanks to @xavierfacq) Fixed - `ArrayIndexOutOfBoundsException` in RedissonSessionRepository Fixed - storing Live Objects in Redisson's collection objects (thanks to Rui Gu) Fixed - cancel write operation for commands belong to disconnected connection Fixed - possible race-condition during cancellation of write operation to Redis connection Fixed - accessor methods in Live Objects break if they start with 'is' (thanks to @sdjacobs) Fixed - MapReduce `Collator` couldn't be executed if timeout was defined Fixed - RedissonKeys.delete throws `NullPointerException` in some cases Fixed - `CancellationException` handling during RemotePromise cancellation Fixed - `RedisNodeNotFoundException` should be supplied to Failed Promise ### 13-Sep-2017 - versions 2.10.3 and 3.5.3 released Fixed - ByteBufs are not released properly in SnappyCodec and LZ4Codec (regression since 2.10.2 and 3.5.2) ### 12-Sep-2017 - versions 2.10.2 and 3.5.2 released Feature - added `addScoreAndGetRank` and `addScoreAndGetRevRank` methods to `RScoredSortedSet` object Feature - added `addAndGetRank` and `addAndGetRevRank` methods to `RScoredSortedSet` object (thanks to @zuanoc) Feature - added support for bounded `RMapCache` object using `trySetMaxSize` `setMaxSize` methods (thanks to @johnou) Feature - added search by pattern using `iterator` method of `RSet` objects Feature - added search by pattern using `keySet`, `values` and `entrySet` methods of `RMap` objects Feature - `addScoreAndGetRank` and `addScoreAndGetRevRank` methods were added to `RScoredSortedSet` object Improvement - memory allocation optimization during encoding process Fixed - fixed NPE in LoadBalancerManager (regression since 2.10.1 and 3.5.1) Fixed - `RAtomicDouble.decrementAndGet` Fixed - connection could be in closed state during reconnection process for blocking queue ### 29-Aug-2017 - versions 2.10.1 and 3.5.1 released Feature - DNS monitoring support for Sentinel, Master/Slave and Replicated mode Feature - `org.redisson.codec.CompositeCodec` added Feature - added `readMode` property for Tomcat RedissonSessionManager Fixed - `RMapCache.putAll` couldn't handle map with entries amount larger than 5000 Fixed - master entry should be shutdown in slaveConnectionPool during master change process Fixed - Redisson's Tomcat Session attributes should be read first to avoid invalidated session exception ### 28-Jul-2017 - versions 2.10.0 and 3.5.0 released Feature - __Local Cache support for Hibernate Cache__ Please read [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks/#1431-hibernate-cache-local-cache) for more details Feature - __Local Cache support for Spring Cache__ Please read [documentation](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks/#1421-spring-cache-local-cache) for more details Feature - __`RedissonLocalCachedMapCache` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#713-map-local-cache-for-expiring-entries) for more details Feature - __`BlockingFairDeque` object added__ Please read [documentation](https://github.com/redisson/redisson/wiki/7.-distributed-collections#714-blocking-fair-deque) for more details Feature - __`RLockReactive` object added__ Feature - __`RReadWriteLockReactive` object added__ Feature - __`RSemaphoreReactive` object added__ Feature - `unlink`, `flushdbParallel`, `flushallParallel` methods added Fixed - ContextClassLoader should be used by Redisson Codec for Tomcat session's object serialization Fixed - Spring Cache `NullValue` does not implement Serializable Fixed - `RLocalCachedMap` doesn't work with non-json and non-binary codecs Fixed - Tomcat RedissonSessionManager doesn't remove session on invalidation/expiration Fixed - `RedissonBatch` shouldn't require `reactor.fn.Supplier` dependency Fixed - Spring Session 1.3.x compatibility (thanks to Vcgoyo) Fixed - priority queues should acquire lock before polling the element ### 12-Jul-2017 - versions 2.9.4 and 3.4.4 released Feature - [Config.performanceMode](https://github.com/redisson/redisson/wiki/2.-Configuration/_edit#performancemode) setting added Feature - JsonJacksonMapCodec codec added Feature - [Amazon Ion](https://amzn.github.io/ion-docs/) codec added Feature - [read-through, write-through and write-behind](https://github.com/redisson/redisson/wiki/7.-Distributed-collections/#714-map-persistence) support for RMap objects Feature - `RExecutorService` should return RExecutorFuture object with taskId Feature - added `RList.get` method to load elements in a batch Feature - ability to submit few tasks atomically (in batch) through `RExecutorService` interface Feature - [Config.keepPubSubOrder](https://github.com/redisson/redisson/wiki/2.-Configuration#keeppubsuborder) setting added Improvement - make `RMapReactive` and `RMapCacheReactive` interfaces match with `RMap` and `RMapCache` Improvement - `RLexSortedSet` should extend `RSortedSet` Fixed - connection listener is not invoked in some cases Fixed - `RMapCache` `remove`, `put`, `putIfAbsent` and `replace` methods aren't respect entry expiration Fixed - `SCAN` command should be used in `RKeys.deleteByPattern` method Fixed - `RBinaryStream` doesn't work in Redis cluster environment Fixed - `SELECT` command shouldn't be executed on Sentinel servers Fixed - Stackoverflow error arise during decoding of large amount of PubSub messages Fixed - `LocalCachedMapInvalidate` object can't be serialized by Kryo codec Fixed - `XMLGregorianCalendar` type handling in JSON codec Fixed - Reactive Stream methods shouldn't be executed immediately after `Publisher` object creation ### 10-Jun-2017 - versions 2.9.3 and 3.4.3 released Since this version, if you use programmatic config definition you should define full url with schema. ```java config.setAddress("redis://127.0.0.1:6739"); // or for SSL support config.setAddress("rediss://127.0.0.1:6739"); ``` Feature - __SSL support__ Feature - __[RedisLabs](http://redislabs.com) hosting support__ Feature - `RBlockingQueue.takeLastAndOfferFirstTo` method added Feature - `RScoredSortedSet.firstScore, lastScore` methods added Feature - `RedissonCacheManager.setAllowNullValues` method added Feature - `RedissonSpringCacheManager.setCacheNames` method added Feature - Map Entry listeners support added for `RMapCache` object Feature - `Config.lockWatchdogTimeout` parameter added Improvement - NPE checking for key and value added for RedissonMapCache Improvement - `RKeys.deleteByPatternAsync` uses scan command Fixed - `RBoundedBlockingQueue.pollAsync` blocks if timeout is less than 1 second Fixed - unlocking of nested `RReadWriteLock.readLock` deletes current acquired `RReadWriteLock.writeLock` Fixed - wrong null values checking in RDelayedQueue methods Fixed - probability of infinite scan for all iterators Fixed - `Node.InfoSection` should be public Fixed - JSR107 cache implementation should throw `javax.cache.CacheException` in case of any error ### 10-May-2017 - versions 2.9.2 and 3.4.2 released Feature - __Dropwizard metrics integration__ More details [here](https://github.com/redisson/redisson/wiki/14.-Integration-with-frameworks#147-dropwizard-metrics) Feature - `RLocalCachedMap.preloadCache` method added (thanks to Steve Draper) Feature - `RGeo.radiusStoreTo` methods added (thanks to Cory Sherman) Fixed - NoClassDefFoundError exception during using `redisson-all` module ### 27-Apr-2017 - versions 2.9.1 and 3.4.1 released Fixed - `RLocalCachedMap.getAll` didn't use cache (thanks to Steve Draper) Fixed - reference to avro module has been removed ### 26-Apr-2017 - versions 2.9.0 and 3.4.0 released Feature - __`MapReduceService` added__ More details [here](https://github.com/redisson/redisson/wiki/9.-distributed-services/#95-distributed-mapreduce-service) Feature - `readAllMap` and `readAllMapAsync` methods added to `RMap` Feature - `readAllKeySet` and `getReadWriteLock` methods added to `RMultimap` Feature - `RKeys.delete` by objects method added Feature - `RRemoteService.deregister` method added Feature - `retryAttempts`, `retryInterval` and `timeout` methods added to `RBatch` object Feature - `RMapCache.fastPutIfAbsent` with ttl added (thanks to Dobi) Feature - `EvictionPolicy.WEAK` added for `RLocalCachedMap` Feature - `LocalCachedMapOptions.invalidationPolicy` introduced for `RLocalCachedMap` Feature - `expire`, `expireAt`, `move`, `migrate`, `clearExpire`, `renamenx`, `rename`, `remainTimeToLive` methods added to RKey Improvement - `EvictionPolicy.LRU` optimization for `RLocalCachedMap` Fixed - `RTopic.onSubscribe` should be invoked after failover process Fixed - Spring boot with redisson 3.3.2 fails without optional actuator dependency (thanks to Rick Perkowski) Fixed - `RedissonCacheMap.putIfAbsentAsync` doesn't take in account ttl and minIdleTime params (thanks to Dobi) Fixed - Spring cache should put NullValue object instead of null Fixed - Fixed error - No field factory in class Ljava/net/URL Fixed - Spring cache's method with `@Cacheable(sync=true)` annotation never expires (thanks to Dobi) Fixed - spring schema file corrected (thanks to Rui Gu) Fixed - Prevent to set URL.factory to null in case of concurrent URL creation in the URLBuilder (thanks to Björn-Ole Ebers) Fixed - `RMap.addAndGet` causes bad argument (thanks to Rui Gu) Fixed - `RedissonSpringCacheManager` creates new cache on each `getCache` call Fixed - wrong value codec encoder usage for `RedissonLocalCachedMap.fastPutAsync` method ### 21-Mar-2017 - versions 2.8.2 and 3.3.2 released Feature - Redisson's Spring custom namespace support (thanks to Rui Gu) Feature - ability to set custom connection manager (thanks to Saikiran Daripelli) Feature - autoconfigured Spring Boot CacheStatisticsProvider implementation (thanks to Craig Andrews) Feature - `RKeys.touch` and `RObject.touch` methods added Feature - `RedissonCompletionService` implementation added Feature - `RMap.getReadWriteLock` method added Fixed - NPE during `RLocalCachedMap.fastRemove` invocation Fixed - `redisson-tomcat-8` module is not compatible with Tomcat 8.5 Fixed - URLBuilder methods should be synchronized Fixed - use PSETEX in `RBucket.set` method Fixed - `DelayedQueue.remove()` and `DelayedQueue.removeAll()` Fixed - unable to define Type and AvroSchema for AvroJacksonCodec Fixed - ReadWriteLock leaseTimeout calculation Fixed - `Config.fromJson(file)` method, throws StackOverflowError ### 04-Mar-2017 - versions 2.8.1 and 3.3.1 released Feature - Cache with SoftReference support added for `RLocalCachedMap` Feature - `Config.subscriptionMode` setting added Improvement - errors handling during RBatch execution Fixed - StackOverflowException in URLBuilder Fixed - TomcatSessionManager can't be used in Tomcat if Redisson has been deployed in web application Fixed - skip cluster nodes with the "handshake" flag (thanks to @dcheckoway) ### 19-Feb-2017 - versions 2.8.0 and 3.3.0 released Feature - __`RClusteredLocalCachedMap` object added__ More details [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections#713-map-data-partitioning) Feature - __`RClusteredMapCache` object added__ More details [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections#713-map-data-partitioning) Feature - __`RClusteredSetCache` object added__ More details [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#732-set-data-partitioning) Feature - __`RPriorityQueue` object added__ More details [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#715-priority-queue) Feature - __`RPriorityDeque` object added__ More details [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#716-priority-deque) Feature - `removeAllListeners` and `removeListener` by instance methods added for `RTopic` and `RPatternTopic` Feature - `RLockAsync` interface added Improvement - `RRemoteService` is now able to support method overload Fixed - `RLocalCachedMap` is not Redis cluster compatible Fixed - cascade slaves are not supported in cluster mode Fixed - shutdown checking during master change state check added Fixed - master isn't checked during new slave discovery in Sentinel mode ### 02-Feb-2017 - versions 2.7.4 and 3.2.4 released Feature - Allow to specify Redisson instance/config during JCache cache creation Fixed - `ByteBuf.release` method invocation is missed in `LZ4Codec` and `SnappyCodec` Fixed - AssertionError during Redisson shutdown Fixed - `RReadWriteLock.readLock` couldn't be acquired by same thread which has already acquired `writeLock` Fixed - failed `RFairLock.tryLock` attempt retains caller thread in fairLock queue Fixed - `factory already defined` error Fixed - `JCache` expiration listener doesn't work Fixed - `RLocalCachedMap` doesn't work with `SerializationCodec` Fixed - `Can't find entry` error during operation execution on slave nodes ### 19-Jan-2017 - versions 2.7.3 and 3.2.3 released Redisson Team is pleased to announce __ULTRA-FAST__ Redisson PRO edition. Performance measure results available in [Benchmark whitepaper](https://redisson.pro/Redisson%20PRO%20benchmark%20whitepaper.pdf) Feature - `RMap.getLock(key)` and `RMultimap.getLock(key)` methods added Improvement - `RedissonSpringCacheManager` constructor with Redisson instance only added Improvement - `CronSchedule` moved to `org.redisson.api` package Fixed - RedissonBaseIterator.hasNext() doesn't return false in some cases Fixed - NoSuchFieldError exception in `redisson-tomcat` modules Fixed - ConnectionPool size not respected during redirect of cluster request Fixed - `RSortedSet.removeAsync` and `RSortedSet.addAsync` Fixed - `RBloomFilter.tryInit` were not validated properly Fixed - CommandDecoder should print all replay body on error ### 19-Dec-2016 - versions 2.7.2 and 3.2.2 released Feature - `RList`, `RSet` and `RScoredSortedSet` implements `RSortable` interface with SORT command support Feature - `NodeAsync` interface Feature - `Node.info`, `Node.getNode` methods added Fixed - elements distribution of `RBlockingFairQueue` across consumers Fixed - `factory already defined` error during Redisson initialization under Apache Tomcat ### 14-Dec-2016 - versions 2.7.1 and 3.2.1 released Url format used in config files __has changed__. For example: "//127.0.0.1:6739" now should be written as "redis://127.0.0.1:6739" Feature - `RSet.removeRandom` allows to remove several members at once Fixed - exceptions during shutdown Fixed - redis url couldn't contain underscore in host name Fixed - IndexOutOfBoundsException during response decoding Fixed - command timeout didn't respect during topic subscription Fixed - possible PublishSubscribe race-condition Fixed - blocking queue/deque poll method blocks infinitely if delay less than 1 second ### 26-Nov-2016 - versions 2.7.0 and 3.2.0 released Feature - __Spring Session implementation__. More details [here](https://github.com/redisson/redisson/wiki/14.-Integration%20with%20frameworks/#145-spring-session) Feature - __Tomcat Session Manager implementation__. More details [here](https://github.com/redisson/redisson/wiki/14.-Integration%20with%20frameworks/#144-tomcat-redis-session-manager) Feature - __RDelayedQueue object added__. More details [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#714-delayed-queue) Feature - __RBlockingFairQueue object added__. More details [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections/#713-blocking-fair-queue) Feature - `RSortedSet.readAll` and `RQueue.readAll` methods added Fixed - `RMap.getAll` doesn't not preserve the order of elements Fixed - Wrong nodes parsing in result of cluster info command Fixed - NullPointerException in CommandDecoder.handleResult Fixed - Redisson shutdown status should be checked during async command invocation ### 07-Nov-2016 - versions 2.6.0 and 3.1.0 released Feature - __new object added__ `RBinaryStream`. More info about it [here](https://github.com/redisson/redisson/wiki/6.-distributed-objects/#62-binary-stream-holder) Improvement - limit Payload String on RedisTimeoutException Improvement - Elasticache master node change detection process optimization ### 27-Oct-2016 - versions 2.5.1 and 3.0.1 released Include all code changes from __2.2.27__ version Fixed - RMapCache.fastPutIfAbsentAsync doesn't take in account expiration Fixed - timer field of RedisClient hasn't been initialized properly in some cases ### 27-Oct-2016 - version 2.2.27 released This version fixes old and annonying problem with `ConnectionPool exhusted` error. From this moment connection pool waits for free connection instead of throwing pool exhausted error. This leads to more effective Redis connection utilization. Improvement - remove `Connection pool exhausted` exception ### 17-Oct-2016 - version 3.0.0 released Fully compatible with JDK 8. Includes all code changes from __2.5.0__ version Feature - `RFeature` extends `CompletionStage` ### 17-Oct-2016 - version 2.5.0 released This version brings greatly improved version of `RLiveObjectService` and adds cascade handling, cyclic dependency resolving, simplified object creation. Read more in this [article](https://dzone.com/articles/java-distributed-in-memory-data-model-powered-by-r) Includes all code changes from __2.2.26__ version Feautre - COUNT and ASC/DESC support for `RGeo` radius methods Feature - `RGeo` extends `RScoredSortedSet` Feature - `RCascade` annotation support LiveObjectService Improvement - `RId` generator should be empty by default Improvement - support setter/getter with protected visibility scope for LiveObject Fixed - `RMapCache` doesn't keep entries insertion order during iteration Fixed - `@RId` is returned/overwritten by similarly named methods (thanks to Rui Gu) Fixed - typo `getRemoteSerivce` -> `getRemoteService` (thanks to Slava Rosin) Fixed - `RPermitExpirableSemaphore.availablePermits` doesn't return actual permits account under certain conditions Fixed - `readAllValues` and `readAllEntrySet` methods of `RLocalCacheMap` return wrong values Fixed - setter for collection field of LiveObject entity should rewrite collection content Fixed - `RSetCache` TTL not updated if element already present Fixed - `RLiveObjectService` swallow exceptions during `merge` or `persist` operation Fixed - `RLiveObjectService` doesn't support protected constructors Fixed - object with cyclic dependencies lead to stackoverflow during `RLiveObjectService.detach` process Fixed - not persisted `REntity` object allowed to store automatically Fixed - `RLexSortedSet.addAll` doesn't work Fixed - `RLiveObjectService` can't detach content of List object Fixed - `RLiveObjectService` doesn't create objects mapped to Redisson objects in runtime during getter accesss Fixed - `RLiveObjectService` can't recognize id field of object without setter ### 17-Oct-2016 - version 2.2.26 released Fixed - NPE in CommandDecoder Fixed - PubSub connection re-subscription doesn't work in case when there is only one slave available ### 27-Sep-2016 - version 2.4.0 released Includes all code changes from __2.2.25__ version Feature - __new object added__ `RPermitExpirableSemaphore`. More info about it [here](https://github.com/redisson/redisson/wiki/8.-distributed-locks-and-synchronizers#87-permitexpirablesemaphore) Feature - __new object added__ `RLocalCachedMap`. More info about it [here](https://github.com/redisson/redisson/wiki/7.-distributed-collections#712-map-local-cache) Feature - __references support__ (thanks to Rui Gu) More info about it [here](https://github.com/redisson/redisson/wiki/10.-Additional-features#102-references-to-redisson-objects) Feature - __Docker support__ More info about it [here](https://github.com/redisson/redisson/wiki/12.-Standalone-node#126-how-to-run-using-docker) Feature - `RSemaphore.reducePermits` method added Feature - `nettyThreads` and `executor` settings added Feature - `valueRangeReversed`, `entryRangeReversed`, `union` and `intersection` methods added to `RScoredSortedSet` object Feature - `Node.time` method added Feature - `RMap.valueSize` method added Feature - `RBucket.size` method added Feature - `RBatch.executeSkipResult` method added Improvement - Redisson Node could be created with existing Redisson instance Improvement - `RMultimap.get` should return `RSet` or `RList` interface instead of `Set` and `List` Fixed - `RExecutorService` should reject non-static inner task class Fixed - wrong object encoding in `RScoredSortedSet.addScore` method ### 27-Sep-2016 - version 2.2.25 released Improvement - log unexpected errors in netty handlers Improvement - `Not all slots are covered` error should be more informative Improvement - implement random wait time in `lock` method of `RedissonRedLock` and `RedissonMultiLock` objects Fixed - `ClassCastException` error when there are no slaves in sentinel mode Fixed - keep RMap insertion ordering while iteration Fixed - thread stuck at `lock` method of `RedissonRedLock` and `RedissonMultiLock` objects Fixed - incorrect `tryLock` behaviour of `RedissonRedLock` and `RedissonMultiLock` objects Fixed - connection shouldn't be closed on exceptionCaught Fixed - Jackson 2.8.x compatibility Fixed - TRYAGAIN error handling in cluster mode Fixed - sync commands in connectionListener leads to connection timeout exception Fixed - can't find slave error in cluster mode if failed slave hasn't been added before ### 24-Aug-2016 - version 2.3.0 released Starting from this version Redisson could be run as standalone node to execute distributed tasks. More features will be added to it in future. Read docs about it [here](https://github.com/mrniko/redisson/wiki/12.-Standalone-node) Feature - __new service added__ `RExecutorService`. More info about it [here](https://github.com/mrniko/redisson/wiki/9.-distributed-services/#93-distributed-executor-service) Feature - __new service added__ `RScheduledExecutorService`. More info about it [here](https://github.com/mrniko/redisson/wiki/9.-distributed-services#94-distributed-scheduled-executor-service) Feature - __new service added__ `RLiveObjectService`. More info about it [here](https://github.com/mrniko/redisson/wiki/9.-distributed-services/#92-live-object-service) (big thanks to Rui Gu for this amazing feature) Feature - __new object added__ `RBoundedBlockingQueue`. More info about it [here](https://github.com/mrniko/redisson/wiki/7.-distributed-collections/#711-bounded-blocking-queue) Feature - __Redis deployment tool__. More info about it [here](https://github.com/mrniko/redisson/wiki/13.-Tools#131-redis-deployment-tool) Feature - __Cluster management tool__. More info about it [here](https://github.com/mrniko/redisson/wiki/13.-Tools#132-cluster-management-tool) Feature - Avro and Smile codecs added __Breaking api change__ - all config classes moved to `org.redisson.config` package __Breaking api change__ - all classes moved from `org.redisson.core` to `org.redisson.api` package __Breaking api change__ - switched from `io.netty.util.concurrent.Future` to `org.redisson.api.RFuture` interface Fixed - division by zero in WeightedRoundRobinBalancer (thanks to Shailender R Bathula) ### 08-Aug-2016 - version 2.2.24 released Fixed - PubSub connection in cluster mode should be connected to node according slot derived from channel name Fixed - `RLock.tryLock` could block forever under some conditions ### 04-Aug-2016 - version 2.2.23 released Improvement - `Future.cancel` method handling for RemoteService async call Fixed - unable to redefine RedisClient command execution timeout Fixed - exception occured in CommandEncoder leads to reponse timeout exception Fixed - exception occured in CommandDecoder leads to reponse timeout exception Fixed - BLPOP timeout calculation fixed Fixed - object used in RemoteService to prevent race-condition during ack receiving should be created per request ### 26-Jul-2016 - version 2.2.22 released Fixed - java.lang.UnsupportedOperationException during command batch usage with netty 4.0.38 and higher ### 15-Jul-2016 - version 2.2.21 released Fixed - `RLock`, `RReadWriteLock`, `RSemaphore` and `RCountDownLatch` can blocks forever under some conditions ### 14-Jul-2016 - version 2.2.20 released Fixed - NPE during pubsub re-subscription (regression since 2.2.18) Fixed - `RSortedSet` doesn't work in cluster mode (regression since 2.2.16) Fixed - PubSub connection pool initialization in cluster mode Fixed - NPE during pubsub usage in cluster mode (regression since 2.2.18) ### 13-Jul-2016 - version 2.2.19 released Feature - `RSetReactive.readIntersection`, `RSetReactive.diff` and `RSetReactive.intersection` added Fixed - cluster commands handling regression (regression since 2.2.18) ### 13-Jul-2016 - version 2.2.18 released Feature - `RSet.randomAsync` and `RSet.random` commands added (thanks to dcheckoway) Feature - commandTimeout param added to RedisClient Feature - `JsonJacksonMapValueCodec` basic typed map value codec added (thanks to andrejserafim) Improvement - PubSub management has been reimplemented this resolves some issues with RLock, RSemaphore objects Fixed - disconnected pubsub connection leads to missed response for unsubscribe/punsubscribe operations Fixed - cluster slot changes discovery Fixed - execute all lock, semaphore and countdownlatch commands on master node Fixed - shutdown listeners added during blocking operations usage weren't removing in some cases Fixed - response parsing of cluster nodes command Fixed - Connections weren't closing during `RedisClient` shutdown Fixed - `RedissonRedLock.unlock` ### 30-Jun-2016 - version 2.2.17 released Feature - `RMultimap.keySize` method added Feature - `RKeys.getType` method added Feature - `RKeys.getKeysByPattern` method with count param added Improvement - `RedissonMultiLock.lock` method optimization Feature - `RedissonRedLock` implemented Fixed - `RMapCache.delete` doesn't delete redisson__idle__set__ Fixed - integer comparison in EvictionScheduler Fixed - ByteBuf leak (thanks to jackygurui) Fixed - `RTopic.addListener` method worked asynchronous sometimes Fixed - ClastCastException occurred if multi-type PubSub channels were used with single connection Fixed - PubSub status message decoding Fixed - RLock.lock can hang in some cases Fixed - PubSub subscription may stuck in some cases Fixed - return value of `RedissonMultimap.keySet.size` method ### 12-Jun-2016 - version 2.2.16 released Feature - `RGeo`, `RMultimapCache` added to `RBatch` Feature - `fastRemove` and `fastRemoveAsync` methods were added to `RList` Improvement - added Spring 4.3.0 support to RedissonSpringCacheManager Improvement - `RSortedSet` performance boost up to __x4__ Improvement - `RList.remove` optimization Improvement - ability to define `Codec` for `RRemoteService` Fixed - cluster state managing with redis masters only Fixed - dead lock during `RLock`, `RSemaphore`, `RReadWriteLock`, `RCountDownLatch` usage under heavy load ### 08-Jun-2016 - version 2.2.15 released Improvement - Performance boost up to 30% for `RSortedSet.add` method Fixed - auth during reconnection (thanks to fransiskusx) Fixed - Infinity loop with iterator Fixed - NPE in `RSortedSet` Fixed - `RSortedSet.remove` and `iterator.remove` methods can break elements ordering ### 27-May-2016 - version 2.2.14 released Redisson Team is pleased to announce [Redisson PRO](http://redisson.pro) edition. This version is based on open-source edition and has 24x7 support and some features. Feature - __data sharding for `RMap`, `RSet` structures in cluster mode__ available only in [Redisson PRO](http://redisson.pro) edition Feature - __new object added__ `RLock` with fair mode support Feature - Ability to execute interface methods used for RemoteService in asynchronous way Feature - `RSemaphoreAsync` interface implemented Feature - `addBefore`, `addBeforeAsync`, `addAfter`, `addAfterAsync` methods added to `RList` object Feature - `readAll`, `pollFirst`, `pollLast`, `first`, `last`, `revRankAsync`, `readAllAsync`, `pollFirstAsync`, `pollLastAsync`, `firstAsync`, `lastAsync` and `revRankAsync` methods added to `RLexSortedSet` object Feature - `count`, `countAsync`, `readAll`, `readAllAsync` methods added to `RScoredSortedSet` object Feature - `entryValueReversed`, `entryValueReversedAsync` methods added to`RScoredSortedSet` (thanks to weiqiyiji) Feature - Ability to specify the name prefix for `RRemoteService` (thanks to pierredavidbelanger) Feature - Ability to make remote call in fire-and-forget and ack-response modes only (thanks to pierredavidbelanger) Improvement - optimized cluster redirect handling during `RBatch` execution Fixed - `RScoredSortedSet.retainAll` method works incorrectly in some cases Fixed - `getBlockingQueue` throws `IndexOutOfBoundsException` (thanks to jackygurui) Fixed - `GEODIST` command handling in `RGeo` object (thanks to jackygurui) Fixed - `RObject.expireAt` method uses second instead of ms Fixed - don't make a remote call when toString, equals and hashCode are called via remote interface (thanks to pierredavidbelanger) Fixed - `RRemoteService` doesn't work correctly with serialzation codecs (thanks to pierredavidbelanger) Fixed - executors amount is not enforced (thanks to pierredavidbelanger) Fixed - FSTObjectOutput shouldn't be closed after write Fixed - possible race-condition during ack waiting in `RRemoteService` object Fixed - timeWait checking fixed in `RLock.tryLockAsync` ### 30-Apr-2016 - version 2.2.13 released Feature - `RSet.diff` and `RSet.intersection` methods added Imporovement - `RScoredSortedSet`.`containsAll`, `removeAll` and `retainAll` methods speed optimization Imporovement - `RSetCache` memory and speed optimization Imporovement - `RSet`.`retainAll`, `containsAll`, `removeAll` methods speed optimized up to 100x Fixed - possible infinity `RLock` expiration renewal process Fixed - error during `RSetCache.readAll` invocation. Fixed - expiration override wasn't work in `RSetCache.add` ### 22-Apr-2016 - version 2.2.12 released Imporovement - Replaying phase handling in CommandDecoder Fixed - cluster state update manager can't try next node if current node has failed to response Fixed - cluster initialization Fixed - items removing during `RMap` iteration Fixed - `RGeo.addAsync` codec definition Fixed - `RMapCache` iterator and readAll methods Fixed - unnecessary slots migration in cluster mode Fixed - Command batches redirect in cluster mode Fixed - cluster mode compatibility for `RedissonMultimap.fastRemove` method Fixed - `RedissonMultiLock` deadlock Fixed - MultiDecoder empty result handling Fixed - array start index in LUA scripts Fixed - RMap iterator Fixed - probably thread blocking issues ### 04-Apr-2016 - version 2.2.11 released Since this version Redisson has __perfomance boost up to 43%__ Feature - __new object added__ `RGeo` Feature - __new object added__ `RBuckets` Feature - travis-ci integration (thanks to jackygurui) Improvement - `RScoredSortedSet.removeAllAsync` & `removeAll` methods optimization Improvement - `RemoteService` reliability tuned up Improvement - Reattaching RBlockingQueue\Deque blocking commands (poll, take ...) after Redis failover process or channel reconnection Fixed - iterator objects may skip results in some cases Fixed - RTopic listeners hangs during synchronous commands execution inside it Fixed - Redisson hangs during shutdown if `RBlockingQueue\Deque.take` or `RBlockingQueue\Deque.poll` methods were invoked ### 23-Mar-2016 - version 2.2.10 released Feature - __new object added__ `RRemoteService` Feature - __new object added__ `RSetMultimapCache` Feature - __new object added__ `RListMultimapCache` Improvement - ability to cancel BRPOP and BLPOP async command execution Improvement - Config params validation Improvement - test RedisRunner improvements (thanks to jackygurui) Improvement - `Double.NEGATIVE_INFINITY` and `Double.POSITIVE_INFINITY` handling for ScoredSortedSet (thanks to jackygurui) Fixed - MOVED, ASK handling in cluster mode using RBatch Fixed - delete and expire logic for Multimap objects Fixed - `RLock.tryLockAsync` NPE Fixed - possible NPE during Redisson version logging Fixed - Netty threads shutdown after connection error ### 04-Mar-2016 - version 2.2.9 released Feature - __new object added__ `RSetMultimap` Feature - __new object added__ `RListMultimap` Feature - `valueRangeReversed` and `valueRangeReversedAsync` methods were added to `RScoredSortedSet` object Improvement - Throw `RedisOutOfMemoryException` when OOM error from Redis server has occured Improvement - Node type added to optimization in Cluster mode Improvement - Add DynamicImport-Package to OSGi headers Fixed - `RedissonSpringCacheManager` Sentinel compatibility Fixed - `RAtomicLong.compareAndSet` doesn't work when expected value is 0 and it wasn't initialized ### 12-Feb-2016 - version 2.2.8 released Feature - `union`, `unionAsync`, `readUnion` and `readUnionAsync` methods were added to `RSet` object Feature - `readAll` and `readAllAsync` methods were added to `RSetCache` object Improvement - `RKeys.delete` optimization in Cluster mode Fixed - Script error during `RSetCache.toArray` and `RSetCache.readAll` methods invocation Fixed - Sentinel doesn't support AUTH command Fixed - RMap iterator ### 03-Feb-2016 - version 2.2.7 released Feature - `readAllKeySet`, `readAllValues`, `readAllEntry`, `readAllKeySetAsync`, `readAllValuesAsync`, `readAllEntryAsync` methods were added to `RMap` object Improvement - `RKeys.delete` optimization in Cluster mode Fixed - minimal connections amount initialization Fixed - `RKeys.deleteByPattern` throws an error in cluster mode Fixed - `RKeys.deleteAsync` throws error in Cluster mode Fixed - Redisson failed to start when one of sentinel servers is down Fixed - Redisson failed to start when there are no slaves in Sentinel mode Fixed - slave nodes up/down state discovery in Cluster mode Fixed - slave can stay freezed when it has been just added in Sentinel mode Fixed - offline slaves handling during Redisson start in Sentinel mode Fixed - `SELECT` command can't be executed in Sentinel mode Fixed - `database` setting removed from cluster config ### 28-Jan-2016 - version 2.2.6 released Feature - __new object added__ `RedissonMultiLock` Feature - `move` method added to `RSet`, `RSetReactive` objects (thanks to thrau) Feature - `put` methods with `maxIdleTime` param added to `RMapCache` object Feature - `RList.subList` returns `live` view object Feature - `readAll` method added to `RList` and `RSet` objects Feature - `trim` method added to `RList` object Feature - ability to read/write Redisson config object from/to `JSON` or `YAML` format Feature - [Spring cache](http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.html) integration Feature - `readMode` setting added Improvement - `RSetCache` object entry eviction optimization Improvement - `RList` object optimization Improvement - `RedissonCountDownLatchAsync` interface added Improvement - cluster restrictions removed from `loadBucketValues` and `saveBuckets` methods Fixed - wrong ByteBuf read position in all codecs based on `StringCodec` Fixed - can't connect with password to Sentinel and Elasticache servers Fixed - Cluster slave discovery (regression since 2.1.5) Fixed - Sentinel slave discovery (regression since 2.1.5) ### 09-Jan-2015 - version 2.2.5 released Feature - __new object added__ `RBloomFilter` Feature - __new object added__ `RAtomicDouble` Feature - `tryAdd`, `tryAddAsync`, `addAll` and `addAllAsync` methods added to `RScoredSortedSet` Feature - `RKeys.count` and `RKeys.countAsync` methods added Feature - `RedissonClient.saveBuckets` method added Feature - `trySet`, `trySetAsync`, `compareAndSet` and `getAndSet` methods added to `RBucket` Feature - `fastPutIfAbsent` and `fastPutIfAbsentAsync` methods added to `RMap` Improvement - `RMap.putIfAbsent` optimization Improvement - `RBitSet` index range extended to Integer.MAX_VALUE*2 Improvement - `RAtomicLong.getAndAdd` optimization Fixed - infinity loop during `RMap` iteration Fixed - wrong timeout value used during `RBatch` execution Fixed - connection handling when `isReadFromSlaves = false` Fixed - `RMap.addAndGetAsync` key encoding Fixed - `RBatch` errors handling Fixed - `RBlockingQueue.pollLastAndOfferFirstToAsync` does not block properly ### 25-Dec-2015 - version 2.2.4 released Please update to this version ASAP due to connection leak discovered in previous versions since Redisson 2.1.4. Feature - __new object added__ `RBlockingDeque` Feature - __new object added__ `RSemaphore` Feature - `RMapCache.fastPut` method with TTL support added Feature - `WeightedRoundRobinBalancer` slaves balancer added Improvement - Memory consumption optimization Improvement - storing value with ttl = 0 in `RSetCache` or `RMapCache` saves it infinitely Fixed - reconnection handling when Sentinel servers are restarted Fixed - RedisConnectionException should be throw if Redisson can't connect to servers at startup Fixed - Connection leak (regression bug since 2.1.4) Fixed - ConnectionWatchdog throws exception when eventloop in shutdown state Fixed - `RReadWriteLock.forceUnlock` works only for current thread Fixed - MapKeyDecoder and MapValueDecoder are called in wrong order Fixed - `RReadWriteLock` doesn't work in cluster mode ### 15-Dec-2015 - version 2.2.3 released Feature - ability to set connection listener via `Config.connectionListener` setting Fixed - `RLock` expiration bug fixed (regression bug since 2.2.2) Fixed - NPE in `RedissonSortedSet` constructor ### 14-Dec-2015 - version 2.2.2 released Feature - `isShuttingDown` and `isShutdown` methods were added to RedissonClient and RedissonReactiveClient Feature - __new object added__ `RSetCacheReactive` Fixed - RLock expiration renewal task scheduling fixed (regression bug since 2.2.1) Fixed - RExpirable.expireAsync timeUnit precision fixed (regression bug since 2.2.1) ### 11-Dec-2015 - version 2.2.1 released Feature - __new object added__ `RReadWriteLock` with reentrant read/write locking Feature - __new object added__ `RMapCache` map-based cache with TTL support for each entry Feature - __new object added__ `RSetCache` set-based cache with TTL support for each value Feature - `RBatchReactive.getKeys` method added Feature - `RMap.values()`, `RMap.keySet()`, `RMap.entrySet()` reimplemented with live-view objects Feature - `RObjectReactive.isExists`, `RObject.isExists` and `RObject.isExistsAsync` added Fixed - `RLock.unlock` not thrown IllegalMonitorStateException ### 04-Dec-2015 - version 2.2.0 released Since 2.2.0 version Redisson supports [Reactive Streams](http://www.reactive-streams.org). Use `Redisson.createReactive` method to access Reactive objects. Feature - [Reactive Streams](http://www.reactive-streams.org) support Feature - `RList.addAllAsync` and `RMap.getAllAsync` methods added Feature - `RList.equals` and `RList.hashCode` methods implemented Feature - `pollFirst`, `pollFirstAsync`, `pollLast`, `pollLastAsync` methods added to `RScoredSortedSet` Improvement - `RLock` and `RCountDownLatch` switched to `LongCodec` __Breaking api change__ - `RExpirable` methods now uses milliseconds instead of seconds Fixed - `RLock.delete` didn't check lock existence `Config.useMasterSlaveConnection` and `Config.useSentinelConnection` methods renamed to `Config.useSentinelServers` and `Config.useMasterSlaveServers` respectively Deprecated methods are dropped ### 30-Nov-2015 - version 2.1.6 released Fixed - connection pool regression bug Fixed - connection init during `Node.ping` and `ClusterNode.info` invocation ### 24-Nov-2015 - version 2.1.5 released Feature - new methods with `limit` option support were added to `RLexSortedSet`: `lexRange`, `lexRangeHead`, `lexRangeHeadAsync`, `lexRangeTail`, `lexRangeTailAsync`, `lexRangeAsync` (thanks to jackygurui) Feature - new methods with `limit` option support were added to `RScoredSortedSet`: `valueRange`, `valueRangeAsync`, `entryRange`, `entryRangeAsync`, `valueRange`, `valueRangeAsync` (thanks to jackygurui) Feature - `LOADING` Redis server response handling Feature - `RKeys.getSlot` method added Feature - new config options `reconnectionTimeout`, `failedAttempts`, `connectTimeout`, `slaveSubscriptionConnectionMinimumIdleSize`, `masterConnectionMinimumIdleSize`, `'slaveConnectionMinimumIdleSize`, `idleConnectionTimeout` Feature - `RBitSet` object added Feature - `RBlockingQueue.pollFromAny` and `RBlockingQueue.pollFromAnyAsync` methods added Improvements - `LoadBalancer` interface refactored Fixed - RedisTimeoutException message Fixed - command execution timeout handling Fixed - `RList.addAllAsync` Fixed - `RSet.iterator` Fixed - `RBatch.execute` and `RBatch.executeAsync` errors handling ### 11-Nov-2015 - version 2.1.4 released Cluster support improvements. New codecs. Stability improvements. Feature - [LZ4](https://github.com/jpountz/lz4-java) compression codec support Feature - [CBOR](http://cbor.io/) binary json codec support (thanks to lefay) Feature - [MsgPack](http://msgpack.org/) binary json codec support Feature - [Fst](https://github.com/RuedigerMoeller/fast-serialization) serialization codec support Feature - [Snappy](https://github.com/xerial/snappy-java) compression codec support Feature - cluster slave nodes change monitoring Feature - `Config.slaveFailedAttempts` and `Config.slaveReconnectionTimeout` config params added Feature - `ClusterServersConfig.readFromSlaves` config param added Improvement - async channel reconnection Improvement - connection acquisition in async way Improvement - cluster slot change/migration handling Improvement - get cluster info from new cluster nodes not defined in initial config __Deprecated__ - `refreshConnectionAfterFails` config param Fixed - `RList.add(pos, element)` fixed Fixed - Publish/Subscribe message decoding under heavy load Fixed - cluster ASK response handling Fixed - `RMap.putAll` fixed Fixed - parsing cluster nodes info Fixed - NPE during Publish/Subscribe event handling Fixed - Redisson shutdown handling Fixed - EOFException during RLock usage with SerializationCodec (thanks to Oleg Ternovoi) ### 17-Sep-2015 - version 2.1.3 released Feature - Ability to define `Codec` for each object Feature - `refreshConnectionAfterFails` setting added Feature - [AWS Elasticache](https://aws.amazon.com/elasticache/) support via `Config.useElasticacheServers` method (thanks to Steve Ungerer) Feature - `RScoredSortedSet` and `RLexSortedSet` added. Both uses native Redis Sorted Set commands. `RLexSortedSet`s stores only String objects and work with ZLEX-commands Fixed - missed AUTH during channel reconnection Fixed - resubscribe to subscribed topics during channel reconnection ### 05-Sep-2015 - version 2.1.2 released Fixed - possible NPE during channel reconnection Fixed - executeAsync freezes in cluster mode Fixed - use same node for SCAN/SSCAN/HSCAN during iteration Fixed - possible race-condition during master change Fixed - `BlockingQueue.peek` race-condition Fixed - NPE with empty sentinel servers Fixed - unable to read `clientName` config param in Master\Slave and Sentinel modes Fixed - "Too many open files" error in cluster mode ### 15-Aug-2015 - version 2.1.1 released Feature - all keys operations extracted to `RKeys` interface Feature - `RKeys.getKeys`, `RKeys.getKeysByPattern` and `RKeys.randomKey`methods added Feature - `RBlockingQueueAsync.drainToAsync` method added Feature - Redis nodes info and ping operations via `Redisson.getNodesGroup` or `Redisson.getClusterNodesGroup` now available Improvement - added sentinel nodes discovery Fixed - command encoding errors handling Fixed - cluster empty slot handling Fixed - connection hangs when there are no slaves in sentinel mode Fixed - activate master as slave when there are no more available slaves in sentinel mode Fixed - skip disconnected sentinels during startup Fixed - slave node discovery in sentinel mode which has been disconnected since start __Deprecated__ - Redisson methods `deleteAsync`, `delete`, `deleteByPatternAsync`, `deleteByPattern`, `findKeysByPatternAsync`, `findKeysByPattern`. Use same methods with `RKeys` interface ### 03-Aug-2015 - version 2.1.0 released Feature - `RTopic` subscribtion/unsubscription status listener added Feature - `RSet`: `removeRandom` and `removeRandomAsync` methods added Improvement - `RList`: `retainAll`,`containsAll`, `indexOf`, `lastIndexOf` optimization __Breaking api change__ - `findKeysByPattern` response interface changed to `Collection` __Breaking api change__ - `RTopic` message listener interface changed Fixed - NPE during cluster mode start Fixed - timeout timer interval calculation Fixed - `RBatch` NPE's with very big commands list Fixed - `RBucket.set` with timeout ### 26-Jul-2015 - version 2.0.0 released Starting from 2.0.0 version Redisson has a new own async and lock-free Redis client under the hood. Thanks to the new architecture pipline (command batches) support has been implemented and a lot of code has gone. Feature - new `RObject` methods: `move`, `moveAsync`, `migrate`, `migrateAsync` Feature - new async interfaces: `RAsyncMap`, `RAtomicLongAsync`, `RBlockingQueueAsync`, `RCollectionAsync`, `RDequeAsync`, `RExpirableAsync`, `RHyperLogLogAsync`, `RListAsync`, `RObjectAsync`, `RQueueAsync`, `RScriptAsync`, `RSetAsync`, `RTopicAsync` Feature - multiple commands batch (Redis pipelining) support via `Redisson.createBatch` method Feature - new methods `flushall`, `deleteAsync`, `delete`, `deleteByPatternAsync`, `deleteByPattern`, `findKeysByPatternAsync`, `findKeysByPattern` added to `RedissonClient` interface Improvement - closed channel detection speedup ### 22-Jul-2015 - version 1.3.1 released Fixed - requests state sync during shutdown Fixed - netty-transport-native-epoll is now has a provided scope Fixed - NPE during `BlockingQueue.poll` invocation ### 04-Jul-2015 - version 1.3.0 released Feature - `RQueue.pollLastAndOfferFirstTo` method added Feature - `RObject.rename`, `RObject.renameAsync`, `RObject.renamenx`, `RObject.renamenxAsync` methods added Feature - `RList.getAsync`, `RList.addAsync`, `RList.addAllAsync` methods added Feature - `RObject.deleteAsync` method added Feature - unix sockets support via `Configuration.useLinuxNativeEpoll` setting Feature - `Redisson.getTopicPattern` method added (thanks to alex-sherwin) Improvement - `RLock` auto-unlock then client lock-owner is gone (thanks to AndrewKolpakov) Improvement - lua scripts used instead of multi/exec commands to avoid connection errors during execution (thanks to AndrewKolpakov) Improvement - `RObject.delete` method now returns `boolean` status Improvement - propagate Command processing exceptions to ConnectionManager (thanks to marko-stankovic) Improvement - KryoCodec classes registration ability added Fixed - slave status handling in Sentinel mode Fixed - String codec Fixed - Cluster ASKING command support Fixed - `RedissonBlockingQueue#drainTo` method (thanks to Sergey Poletaev) Fixed - Cluster.STATE.HANDSHAKE enum added Fixed - `RedissonClient.getScript` method added Fixed - `BlockingQueue.poll` method Fixed - Incorrect map key encoding makes hmget return no fields when string keys are used (thanks to sammiq) ### 02-Apr-2015 - version 1.2.1 released Feature - all redis-script commands via 'RScript' object Feature - implementation of `java.util.concurrent.BlockingQueue` (thanks to pdeschen) Feature - buckets load by pattern (thanks to mathieucarbou) Improvement - IPv6 support Improvement - `isEmpty` checks for added collections Fixed - KryoCodec keys decoding (thanks to mathieucarbou) Fixed - `RMap.addAndGet()` data format Fixed - timeout support in cluster, sentinel and single connections configurations Fixed - ClassCastException in `RedissonCountDownLatch.trySetCount` Fixed - `RMap.replace` concurrency issue (thanks to AndrewKolpakov) Fixed - `RLock` subscription timeout units fixed (thanks to AndrewKolpakov) Fixed - Re-throw async exceptions (thanks to AndrewKolpakov) ### 09-Jan-2015 - version 1.2.0 released Feature - cluster mode support Fixed - `RList` iterator race conditions Fixed - `RDeque.addFirst` `RDeque.addLast` methods Fixed - OSGi support ### 16-Dec-2014 - version 1.1.7 released Improvement - `RAtomicLong` optimization Fixed - `RMap.fastRemove` and `RMap.getAll` methods Fixed - `RTopic` listeners re-subscribing in sentinel mode Fixed - `RSet.toArray` and `RSet.iterator` values order Fixed - keys iteration in `RMap.getAll` Fixed - `RSet` iteration Fixed - `RAtomicLong` NPE Fixed - infinity loop during master/slave connection acquiring Fixed - `RedissonList.addAll` result ### 18-Nov-2014 - version 1.1.6 released Feature - `RBucket.exists` and `RBucket.existsAsync` methods added Feature - `RMap.addAndGet` method added Feature - database index via `database` and operation timeout via `timeout` config params added Improvement - `RLock` optimization __Breaking api change__ - Redisson now uses `RedissonClient` interface Fixed - NPE in `CommandOutput` Fixed - unsubscribing during `RTopic.removeListener` Fixed - all object names encoding, no more quotes Fixed - HashedWheelTimer shutdown Fixed - `RLock` race conditions (thanks to jsotuyod and AndrewKolpakov) Fixed - `RCountDownLatch` race conditions ### 23-Jul-2014 - version 1.1.5 released Feature - operations auto-retry. `retryAttempts` and `retryInterval` params added for each connection type Feature - `RMap.filterEntries`, `RMap.getAll`, `RMap.filterKeys`, `RMap.filterValues` methods added Feature - `RMap.fastRemove`, `RMap.fastRemoveAsync`, `RMap.fastPut` & `RMap.fastPutAsync` methods added Fixed - async operations timeout handling Fixed - sorting algorithm used in `RSortedSet`. ### 15-Jul-2014 - version 1.1.4 released Feature - new `RLock.lockInterruptibly`, `RLock.tryLock`, `RLock.lock` methods with TTL support Fixed - pub/sub connections reattach then slave/master down Fixed - turn off connection watchdog then slave/master down Fixed - sentinel master switch Fixed - slave down connection closing ### 13-Jul-2014 - version 1.1.3 released Improvement - RedissonCountDownLatch optimization Improvement - RedissonLock optimization Fixed - RedissonLock thread-safety Fixed - master/slave auth using Sentinel servers Fixed - slave down handling using Sentinel servers ### 03-Jul-2014 - version 1.1.2 released Improvement - RedissonSet.iterator implemented with sscan Improvement - RedissonSortedSet.iterator optimization Feature - `RSortedSet.removeAsync`, `RSortedSet.addAsync`, `RSet.removeAsync`, RSet.addAsync methods added Feature - slave up/down detection in Sentinel servers connection mode Feature - new-slave automatic discovery in Sentinel servers connection mode ### 17-June-2014 - version 1.1.1 released Feature - sentinel servers support Fixed - connection leak in `RTopic` Fixed - setted password not used in single server connection ### 07-June-2014 - version 1.1.0 released Feature - master/slave connection management Feature - simple set/get object support via `org.redisson.core.RBucket` Feature - hyperloglog support via `org.redisson.core.RHyperLogLog` Feature - new methods `getAsync`, `putAsync` and `removeAsync` added to `org.redisson.core.RMap` Feature - new method `publishAsync` added to `org.redisson.core.RTopic` Feature - [Kryo](https://github.com/EsotericSoftware/kryo) codec added (thanks to mathieucarbou) __Breaking api change__ - `org.redisson.Config` model changed Fixed - score calucaltion algorithm used in `RSortedSet`. Fixed - `RMap.put` & `RMap.remove` result consistency fixed. Fixed - `RTopic.publish` now returns the number of clients that received the message Fixed - reconnection handling (thanks to renzihui) Improvement - `org.redisson.core.RTopic` now use lazy apporach for subscribe/unsubscribe ### 04-May-2014 - version 1.0.4 released Feature - distributed implementation of `java.util.Deque` Feature - some objects implements `org.redisson.core.RExpirable` Fixed - JsonJacksonCodec lazy init ### 26-Mar-2014 - version 1.0.3 released Fixed - RedissonAtomicLong state format Fixed - Long serialization in JsonJacksonCodec ### 05-Feb-2014 - version 1.0.2 released Feature - distributed implementation of `java.util.SortedSet` Fixed - OSGi compability ### 17-Jan-2014 - version 1.0.1 released Improvement - forceUnlock, isLocked, isHeldByCurrentThread and getHoldCount methods added to RLock Feature - connection load balancer to use multiple Redis servers Feature - published in maven central repo ### 11-Jan-2014 - version 1.0.0 released First stable release.