dreamsofa

Redis --- Redission客户端

Redis --- Redission客户端

以下内容来自：https://github.com/mrniko/redisson/wiki

Redisson supports follow Redis configurations:

Cluster
Sentinel servers
Master/Slave servers
Single server

Config examples

Single server connection:

// connects to default Redis server 127.0.0.1:6379

Redisson redisson = Redisson.create();

// connects to single Redis server via Config

Config config = new Config();

config.useSingleServer().setAddress("127.0.0.1:6379");

//or with database select num = 1

config.useSingleServer().setAddress("127.0.0.1:6379").setDatabse(1);

Redisson redisson = Redisson.create(config);

Master/Slave servers connection:

Config config = new Config();

config.useMasterSlaveConnection()

.setMasterAddress("127.0.0.1:6379")

.setLoadBalancer(new RandomLoadBalancer()) // RoundRobinLoadBalancerused by default

.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);

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);

Cluster nodes connections:

Config config = new Config();

config.useClusterServers()

.setScanInterval(2000) // sets cluster state scan interval

.addNodeAddress("127.0.0.1:7000", "127.0.0.1:7001")

.addNodeAddress("127.0.0.1:7002");

Redisson redisson = Redisson.create(config);

Usage examples

Jon Chambers edited this page 8 days ago · 32revisions

Object storage
Map
SortedSet
Set
List
Queue
Deque
Blocking Queue
Lock
AtomicLong
CountDownLatch
Publish subscribe
Publish subscribe by pattern
Multiple commands batch (commands pipelining)
Scripting
Low level Redis client
Misc operations

Object storage

Implements RBucketand RBucketAsyncinterfaces

Redisson redisson = Redisson.create();

RBucket bucket = redisson.getBucket("anyObject");

bucket.set(new AnyObject());

bucket.setAsync(new AnyObject());

AnyObject obj = bucket.get();

redisson.shutdown();

Map

Implements RMap,RMapAsyncand ConcurrentMapinterfaces

Redisson redisson = Redisson.create();

RMap map = redisson.getMap("anyMap");

SomeObject prevObject = map.put("123", new SomeObject());

SomeObject currentObject = map.putIfAbsent("323", new SomeObject());

SomeObject obj = map.remove("123");

map.fastPut("321", new SomeObject());

map.fastRemove("321");

Future putAsyncFuture = map.putAsync("321");

Future fastPutAsyncFuture = map.fastPutAsync("321");

map.fastPutAsync("321", new SomeObject());

map.fastRemoveAsync("321");

redisson.shutdown();

SortedSet

Implements RSortedSetand SortedSetinterfaces

Redisson redisson = Redisson.create();

RSortedSet set = redisson.getSortedSet("anySet");

set.add(3);

set.add(1);

set.add(2);

set.addAsync(5);

redisson.shutdown();

Set

Implements RSet,RSetAsyncand Setinterfaces

Redisson redisson = Redisson.create();

RSet set = redisson.getSet("anySet");

set.add(new SomeObject());

set.remove(new SomeObject());

set.addAsync(new SomeObject());

redisson.shutdown();

List

Implements RList,RListAsyncand Listinterfaces

Redisson redisson = Redisson.create();

RList list = redisson.getList("anyList");

list.add(new SomeObject());

list.get(0);

list.remove(new SomeObject());

redisson.shutdown();

Queue

Implements RQueue,RQueueAsyncand Queueinterfaces

Redisson redisson = Redisson.create();

RQueue queue = redisson.getQueue("anyQueue");

queue.add(new SomeObject());

SomeObject obj = queue.peek();

SomeObject someObj = queue.poll();

redisson.shutdown();

Deque

Implements RDeque,RDequeAsyncand Dequeinterfaces

Redisson redisson = Redisson.create();

RDeque queue = redisson.getDeque("anyDeque");

queue.addFirst(new SomeObject());

queue.addLast(new SomeObject());

SomeObject obj = queue.removeFirst();

SomeObject someObj = queue.removeLast();

redisson.shutdown();

Blocking Queue

Implements RBlockingQueue,RBlockingQueueAsyncand BlockingQueueinterfaces

Redisson redisson = Redisson.create();

RBlockingQueue queue = redisson.getBlockingQueue("anyQueue");

queue.offer(new SomeObject(), 12, TimeUnit.SECONDS);

SomeObject obj = queue.peek();

SomeObject someObj = queue.poll();

redisson.shutdown();

Lock

Implements RLockand Lockinterfaces

Redisson redisson = Redisson.create();

RLock lock = redisson.getLock("anyLock");

lock.lock();

...

lock.unlock();

// Lock time-to-live support

// releases lock automatically after 10 seconds

// if unlock method not invoked

lock.lock(10, TimeUnit.SECONDS);

...

lock.unlock();

redisson.shutdown();

AtomicLong

Implements RAtomicLongand RAtomicLongAsyncinterfaces

Redisson redisson = Redisson.create();

RAtomicLong atomicLong = redisson.getAtomicLong("anyAtomicLong");

atomicLong.set(3);

atomicLong.incrementAndGet();

atomicLong.get();

redisson.shutdown();

CountDownLatch

Implements RCountDownLatchinterface

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();

Publish subscribe

Implements RTopicand RTopicAsyncinterfaces

Redisson redisson = Redisson.create();

RTopic topic = redisson.getTopic("anyTopic");

topic.addListener(new MessageListener() {

    public void onMessage(String channel, SomeObject message) {

...

});

// in other thread or other JVM

RTopic topic = redisson.getTopic("anyTopic");

long clientsReceivedMessage = topic.publish(new SomeObject());

redisson.shutdown();

Publish subscribe by pattern

Implements RPatternTopicand RPatternTopicAsyncinterfaces

// subscribe to all topics by `topic1.*` pattern

RPatternTopicAsync topic1 = redisson.getTopicPattern("topic1.*");

int listenerId = topic1.addListener(new PatternMessageListener() {

    @Override

    public void onMessage(String pattern, String channel, Message msg) {

         Assert.fail();

});

Multiple commands batch (commands pipelining)

Send multiple commands to the server without waiting forthe replies at all, and finally read the replies in a single step. Implements RBatchinterface

RBatch batch = redisson.createBatch();

batch.getMap("test").fastPutAsync("1", "2");

batch.getMap("test").fastPutAsync("2", "3");

batch.getMap("test").putAsync("2", "5");

batch.getAtomicLongAsync("counter").incrementAndGetAsync();

batch.getAtomicLongAsync("counter").incrementAndGetAsync();

List res = batch.execute();

Scripting

Lua scripts could be executed. More details.
Implements RScriptand RScriptAsyncinterfaces

redisson.getBucket("foo").set("bar");

String r = redisson.getScript().eval(Mode.READ_ONLY,

   "return redis.call('get', 'foo')", RScript.ReturnType.VALUE);

// do the same using cache

RScript s = redisson.getScript();

// load script into cache to all redis master instances

String res = s.scriptLoad("return redis.call('get', 'foo')");

// res == 282297a0228f48cd3fc6a55de6316f31422f5d17

// call script by sha digest

Future