##Redisson - distributed and scalable Java data structures on top of Redis server. Advanced Redis client
Use familiar Java data structures with power of [Redis](http://redis.io).
Based on patched version of [lettuce](https://github.com/wg/lettuce) [Redis](http://redis.io) client and [Netty 4](http://netty.io) framework.
Redis 2.6+ and JDK 1.6+ compatible
Licensed under the Apache License 2.0.
Features
================================
* Sentinel servers mode:
1. automatic master and slave servers discovery
2. automatic new master server discovery
3. automatic new slave servers discovery
4. automatic slave servers offline/online discovery
5. read data using slave servers, write data using master server
* Master with Slave servers mode: read data using slave servers, write data using master server
* Single server mode: read and write data using single server
* Distributed implementation of `java.util.List`
* Distributed implementation of `java.util.Set`
* Distributed implementation of `java.util.SortedSet`
* Distributed implementation of `java.util.Queue`
* Distributed implementation of `java.util.Deque`
* Distributed implementation of `java.util.Map`
* Distributed implementation of `java.util.concurrent.ConcurrentMap`
* Distributed implementation of reentrant `java.util.concurrent.locks.Lock` with TTL support
* Distributed alternative to the `java.util.concurrent.atomic.AtomicLong`
* Distributed alternative to the `java.util.concurrent.CountDownLatch`
* Distributed publish/subscribe messaging via `org.redisson.core.RTopic`
* Distributed HyperLogLog via `org.redisson.core.RHyperLogLog`
* Thread-safe implementation
* Supports OSGi
* With over 110 unit tests
Recent Releases
================================
####Please Note: trunk is current development branch.
####??-Jul-2014 - version 1.1.5
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.
### Maven
Include the following to your dependency list:
org.redisson
redisson
1.1.1
Usage examples
================================
####Simple config example
// connects to Redis server 127.0.0.1:6379 by default
Redisson redisson = Redisson.create();
...
redisson.shutdown();
or with initialization by Config object for single server connection
Config config = new Config();
config.useSingleServer()
.setAddress("127.0.0.1:6379")
.setConnectionPoolSize(10);
Redisson redisson = Redisson.create(config);
or master/slave servers connection
Config config = new Config();
config.useMasterSlaveConnection()
.setMasterAddress("127.0.0.1:6379")
.addSlaveAddress("127.0.0.1:6389", "127.0.0.1:6332", "127.0.0.1:6419")
.addSlaveAddress("127.0.0.1:6399");
Redisson redisson = Redisson.create(config);
for sentinel servers connection
Config config = new Config();
config.useSentinelConnection()
.setMasterName("mymaster")
.addSentinelAddress("127.0.0.1:26389", "127.0.0.1:26379")
.addSentinelAddress("127.0.0.1:26319";
Redisson redisson = Redisson.create(config);
####Distributed Map example
Redisson redisson = Redisson.create();
ConcurrentMap map = redisson.getMap("anyMap");
map.put("123", new SomeObject());
map.putIfAbsent("323", new SomeObject());
map.remove("123");
...
redisson.shutdown();
####Distributed Set example
Redisson redisson = Redisson.create();
Set set = redisson.getSet("anySet");
set.add(new SomeObject());
set.remove(new SomeObject());
...
redisson.shutdown();
####Distributed List example
Redisson redisson = Redisson.create();
List list = redisson.getList("anyList");
list.add(new SomeObject());
list.get(0);
list.remove(new SomeObject());
...
redisson.shutdown();
####Distributed Queue example
Redisson redisson = Redisson.create();
Queue queue = redisson.getQueue("anyQueue");
queue.add(new SomeObject());
queue.peek();
queue.pool();
...
redisson.shutdown();
####Distributed Lock example
Redisson redisson = Redisson.create();
Lock lock = redisson.getLock("anyLock");
lock.lock();
lock.unlock();
// same as
redisson.getLock("anyLock").lock();
...
redisson.getLock("anyLock").unlock();
...
redisson.shutdown();
####Distributed AtomicLong example
Redisson redisson = Redisson.create();
RAtomicLong atomicLong = redisson.getAtomicLong("anyAtomicLong");
atomicLong.set(3);
atomicLong.incrementAndGet();
atomicLong.get();
...
redisson.shutdown();
####Distributed CountDownLatch example
Redisson redisson = Redisson.create();
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();
// in other thread or other JVM
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();
...
redisson.shutdown();
####Distributed Topic example
Redisson redisson = Redisson.create();
RTopic topic = redisson.getTopic("anyTopic");
topic.addListener(new MessageListener() {
public void onMessage(SomeObject message) {
...
}
});
// in other thread or other JVM
RTopic topic = redisson.getTopic("anyTopic");
topic.publish(new SomeObject());
...
redisson.shutdown();