Сonsider Redisson PRO version for advanced features and support by SLA.
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
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)
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
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
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
Feature - getPendingInvocations method added to RRemoteService object
Feature - natMap setting support for Sentinel mode (thanks to 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)
Improvement - Use maven packaging for redisson project as jar instead of bundle (thanks to jchobantonov)
Improvement - add default entries in MANIFEST.MF file and extra Build-Time entry as well (thanks to jchobantonov)
Fixed - RMap.replace method doesn't update idle timeout (thanks to mcacker)
Fixed - timeout drift in RedissonFairLock (thanks to 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)
Fixed - Tomcat Manager UpdateValve should be installed only once (thanks to jchobantonov)
Fixed - remove MessageListener from topic when Tomcat Session Manager stopInternal is invoked (thanks to 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)
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)
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)
Fixed - connections amount setting for mirrors is not applied in Proxy mode
Feature - radiusStoreSortedTo methods added to RGeo, RGeoAsync, RGeoRx, RGeoReactive interfaces
Feature - Local cache for JCache added. Read the documentation for more details
Feature - Async, Reactive, RxJava2 interfaces added to JCache. Read the documentation for more details
Feature - RRingBuffer object added. Read the documentation 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)
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)
Feature - Add support for Reactive and RxJava2 interfaces 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)
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)
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)
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
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)
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
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)
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
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
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)
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)
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
Feature - StreamMessageId.NEVER_DELIVERED added
Feature - 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)
Fixed - NPE arise during Tomcat Session getAttribute/delete methods invocation (thanks to 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)
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)
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)
Fixed - RDestroyable interface should be implemented by RMapCache and RSetCache rx/reactive objects
Feature - cachedKeySet, cachedValues, cachedEntrySet and getCachedMap methods added to RLocalCachedMap object
Feature - Hibernate 5.4 support
Feature - search LiveObjects by field
Feature - allow checking if lock is held by a thread (thanks to 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)
Fixed - RRateLimiter RateType checking (thanks to 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)
Fixed - Tomcat Session manager throws java.lang.ClassNotFoundException if readMode=MEMORY (thanks to 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)
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)
Feature - new Hibernate cache implementation
Feature - Hibernate 5.3 support
Feature - TypedJsonJacksonCodec 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
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
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
Feature - RMap.putAll with ttl param (thanks to Tobias Wichtrey)
Feature - RxJava 2 support. Please refer to documentation for more details
Feature - Lambda task definition for RExecutorService. Please refer to documentation for more details
Feature - multi-type listeners support for RTopic and RPatternTopic objects. Please refer to documentation for more details
Feature - useScriptCache setting added. Manages by Lua-script caching on Redis side. Please refer to documentation 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
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)
Feature - RStream object added. Please refer to documentation 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
Feature - Spring Data Redis integration. Please refer to documentation for more details
Feature - Spring Boot Starter implementation. Please refer to documentation 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 for more details
Improvement - Redis request/response handling performance improvement
Improvement - CompositeIterator decoupled from CompositeIterable (thanks to 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)
Fixed - global config codec is not registered in codec cache for reference objects (thanks to Rui Gu)
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
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
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
Feature - RBatchOptions.executionMode setting added. Please refer to documentation 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
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
Feature - Proxy mode Please refer to documentation for more details
Feature - Transaction API implementation Please refer to documentation for more details
Feature - Spring Transaction API implementation Please refer to documentation for more details
Feature - XA Transaction API implementation Please refer to documentation 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
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
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
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
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
Feature - RedissonClusteredSpringLocalCachedCacheManager added. Please read documentation 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
Feature - atomic setting added to RBatch object Please read documentation for more details
Feature - updateMode setting added to Tomcat Redis Session Manager Please read documentation for more details
Feature - RateLimiter object added Please read documentation for more details
Feature - RClusteredBloomFilter object added Please read documentation for more details
Feature - KQueue support added Please read documentation for more details
Feature - Tomcat 9 support added Please read documentation for more details
Feature - RPriorityBlockingQueue object added Please read documentation for more details
Feature - RPriorityBlockingDeque object added Please read documentation for more details
Feature - RLongAdder object added Please read documentation for more details
Feature - DoubleAdder object added Please read documentation 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$ValueRetrievalExceptionshouldn'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)
Feature - RClusteredBitSet object added Please read documentation 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
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
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
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
Fixed - ByteBufs are not released properly in SnappyCodec and LZ4Codec (regression since 2.10.2 and 3.5.2)
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
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
Feature - Local Cache support for Hibernate Cache Please read documentation for more details
Feature - Local Cache support for Spring Cache Please read documentation for more details
Feature - RedissonLocalCachedMapCache object added Please read documentation for more details
Feature - BlockingFairDeque object added Please read documentation 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
Feature - Config.performanceMode setting added
Feature - JsonJacksonMapCodec codec added
Feature - Amazon Ion codec added
Feature - read-through, write-through and write-behind 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 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
Since this version, if you use programmatic config definition you should define full url with schema.
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 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
Feature - Dropwizard metrics integration More details here
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
Fixed - RLocalCachedMap.getAll didn't use cache (thanks to Steve Draper)
Fixed - reference to avro module has been removed
Feature - MapReduceService added More details here
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
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
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)
Feature - RClusteredLocalCachedMap object added More details here
Feature - RClusteredMapCache object added More details here
Feature - RClusteredSetCache object added More details here
Feature - RPriorityQueue object added More details here
Feature - RPriorityDeque object added More details here
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
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
Redisson Team is pleased to announce ULTRA-FAST Redisson PRO edition.
Performance measure results available in Benchmark whitepaper
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
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
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
Feature - Spring Session implementation. More details here
Feature - Tomcat Session Manager implementation. More details here
Feature - RDelayedQueue object added. More details here
Feature - RBlockingFairQueue object added. More details here
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
Feature - new object added RBinaryStream. More info about it here
Improvement - limit Payload String on RedisTimeoutException
Improvement - Elasticache master node change detection process optimization
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
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
Fully compatible with JDK 8. Includes all code changes from 2.5.0 version
Feature - RFeature extends CompletionStage
This version brings greatly improved version of RLiveObjectService and adds cascade handling, cyclic dependency resolving, simplified object creation. Read more in this article
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
Fixed - NPE in CommandDecoder
Fixed - PubSub connection re-subscription doesn't work in case when there is only one slave available
Includes all code changes from 2.2.25 version
Feature - new object added RPermitExpirableSemaphore. More info about it here
Feature - new object added RLocalCachedMap. More info about it here
Feature - references support (thanks to Rui Gu) More info about it here
Feature - Docker support More info about it here
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
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
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
Feature - new service added RExecutorService. More info about it here
Feature - new service added RScheduledExecutorService. More info about it
here
Feature - new service added RLiveObjectService. More info about it
here (big thanks to Rui Gu for this amazing feature)
Feature - new object added RBoundedBlockingQueue. More info about it here
Feature - Redis deployment tool. More info about it
here
Feature - Cluster management tool. More info about it here
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)
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
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
Fixed - java.lang.UnsupportedOperationException during command batch usage with netty 4.0.38 and higher
Fixed - RLock, RReadWriteLock, RSemaphore and RCountDownLatch can blocks forever under some conditions
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)
Feature - RSetReactive.readIntersection, RSetReactive.diff and RSetReactive.intersection added
Fixed - cluster commands handling regression (regression since 2.2.18)
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
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
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
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
Redisson Team is pleased to announce 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 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 toRScoredSortedSet (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
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
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
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
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
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
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
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
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 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)
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
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
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
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)
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
Since 2.2.0 version Redisson supports Reactive Streams. Use Redisson.createReactive method to access Reactive objects.
Feature - Reactive Streams 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
Fixed - connection pool regression bug
Fixed - connection init during Node.ping and ClusterNode.info invocation
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
Cluster support improvements. New codecs. Stability improvements.
Feature - LZ4 compression codec support
Feature - CBOR binary json codec support (thanks to lefay)
Feature - MsgPack binary json codec support
Feature - Fst serialization codec support
Feature - Snappy 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)
Feature - Ability to define Codec for each object
Feature - refreshConnectionAfterFails setting added
Feature - AWS Elasticache support via Config.useElasticacheServers method (thanks to Steve Ungerer)
Feature - RScoredSortedSet and RLexSortedSet added. Both uses native Redis Sorted Set commands. RLexSortedSets stores only String objects and work with ZLEX-commands
Fixed - missed AUTH during channel reconnection
Fixed - resubscribe to subscribed topics during channel reconnection
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
Feature - all keys operations extracted to RKeys interface
Feature - RKeys.getKeys, RKeys.getKeysByPattern and RKeys.randomKeymethods 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
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
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
Fixed - requests state sync during shutdown
Fixed - netty-transport-native-epoll is now has a provided scope
Fixed - NPE during BlockingQueue.poll invocation
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)
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)
Feature - cluster mode support
Fixed - RList iterator race conditions
Fixed - RDeque.addFirst RDeque.addLast methods
Fixed - OSGi support
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
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
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.
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
Improvement - RedissonCountDownLatch optimization
Improvement - RedissonLock optimization
Fixed - RedissonLock thread-safety
Fixed - master/slave auth using Sentinel servers
Fixed - slave down handling using Sentinel servers
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
Feature - sentinel servers support
Fixed - connection leak in RTopic
Fixed - setted password not used in single server connection
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 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
Feature - distributed implementation of java.util.Deque
Feature - some objects implements org.redisson.core.RExpirable
Fixed - JsonJacksonCodec lazy init
Fixed - RedissonAtomicLong state format
Fixed - Long serialization in JsonJacksonCodec
Feature - distributed implementation of java.util.SortedSet
Fixed - OSGi compability
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
First stable release.