分布式对象
每一个Redisson对象绑定在以对象名为key的Redis中，能够通过 getName 方法获取。
RMap map = redisson.getMap("mymap");
map.getName(); // = mymap
所有对Redis keys的操作都包含在RKeys 接口中。
RKeys keys = redisson.getKeys();
Iterable<String> allKeys = keys.getKeys();
Iterable<String> foundedKeys = keys.getKeysByPattern('key*');
long numOfDeletedKeys = keys.delete("obj1", "obj2", "obj3");
long deletedKeysAmount = keys.deleteByPattern("test?");
String randomKey = keys.randomKey();
long keysAmount = keys.count();
5.1. 对象
Redisson 分布式 RBucket 对象是持有对所有任何对象的引用。
RBucket<AnyObject> bucket = redisson.getBucket("anyObject");
bucket.set(new AnyObject(1));
AnyObject obj = bucket.get();
bucket.trySet(new AnyObject(3));
bucket.compareAndSet(new AnyObject(4), new AnyObject(5));
bucket.getAndSet(new AnyObject(6));
5.2. 二级制集合
Redisson 分布式二进制集合是一个可伸缩的bits向量。二进制集合的大小受Redis最大数限制为4 294 967 295。
RBitSet set = redisson.getBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);
set.addAsync("e");
set.xor("anotherBitset");
5.3. 锁
Redisson 分布式可重入排他锁实现了 java.util.concurrent.locks.Lock 接口，同时支持TTL。
Redisson redisson = Redisson.create();
RLock lock = redisson.getLock("anyLock");
// Most familiar locking method
lock.lock();
// Lock time-to-live support
// releases lock automatically after 10 seconds
// if unlock method not invoked
lock.lock(10, TimeUnit.SECONDS);
// Wait for 100 seconds and automatically unlock it after 10 seconds
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();
5.4. 多个锁
Redisson 多个锁对象组将多个RLock对象合并，将他们作为一个锁进行处理。每一个RLock对象可能属于不同的Redisson实例。
RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");
RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
lock.lock();
5.5. 读写锁
Redisson 分布式可重入读写锁实现了java.util.concurrent.locks.ReadWriteLock 接口，同时支持TTL。可以包含多个读锁的拥有者，但只能包含一个写锁。
RReadWriteLock rwlock = redisson.getLock("anyRWLock");
// Most familiar locking method
rwlock.readLock().lock();
// or
rwlock.writeLock().lock();
// Lock time-to-live support
// releases lock automatically after 10 seconds
// if unlock method not invoked
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// or
rwlock.writeLock().lock(10, TimeUnit.SECONDS);
// Wait for 100 seconds and automatically unlock it after 10 seconds
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// or
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();
5.6. 信号量
Redisson 分布式信号量对象和java.util.concurrent.Semaphore 实例拥有相同的结构。
RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();
semaphore.acquire(23);
semaphore.tryAcquire();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
5.7. 原子性长整形
Redisson 分布式长整形对象与 java.util.concurrent.atomic.AtomicLong 实例拥有相同的结构。
RAtomicLong atomicLong = redisson.getAtomicLong("myAtomicLong");
atomicLong.set(3);
atomicLong.incrementAndGet();
atomicLong.get();
5.8. 原子性浮点数
Redisson 分布式原子性浮点数对象。
RAtomicDouble atomicDouble = redisson.getAtomicDouble("myAtomicDouble");
atomicDouble.set(2.81);
atomicDouble.addAndGet(4.11);
atomicDouble.get();
5.9. 倒计时锁存
Redisson 分布式倒计时锁存对象拥有与java.util.concurrent.CountDownLatch 实例相同的结构。
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();
// in other thread or other JVM
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();
5.10. 话题
Redisson 分布式话题对象实现了发布 / 订阅的机制。
RTopic<SomeObject> topic = redisson.getTopic("anyTopic");
topic.addListener(new MessageListener<SomeObject>() {
@Override
public void onMessage(String channel, SomeObject message) {
//...
}
});
// in other thread or JVM
RTopic<SomeObject> topic = redisson.getTopic("anyTopic");
long clientsReceivedMessage = topic.publish(new SomeObject());
话题监听器会重新订阅，当任何的redis连接重连或者是redis服务故障恢复之后。
5.10.1. 话题模式
Redisson 话题模式对象订阅与多个话题通过指定的模式。
// subscribe to all topics by `topic1.*` pattern
RPatternTopic<Message> topic1 = redisson.getPatternTopic("topic1.*");
int listenerId = topic1.addListener(new PatternMessageListener<Message>() {
@Override
public void onMessage(String pattern, String channel, Message msg) {
Assert.fail();
}
});
话题模式监听器会重新订阅，当任何的redis连接重连或者是redis服务故障恢复之后。
5.11. 布隆过滤器
Redisson 分布式布隆过滤器。
RBloomFilter<SomeObject> bloomFilter = redisson.getBloomFilter("sample");
// initialize bloom filter with
// expectedInsertions = 55000000
// falseProbability = 0.03
bloomFilter.tryInit(55000000L, 0.03);
bloomFilter.add(new SomeObject("field1Value", "field2Value"));
bloomFilter.add(new SomeObject("field5Value", "field8Value"));
bloomFilter.contains(new SomeObject("field1Value", "field8Value"));
5.12. 超级日志
Redisson 分布式超级日志。
RHyperLogLog<Integer> log = redisson.getHyperLogLog("log");
log.add(1);
log.add(2);
log.add(3);
log.count();
5.13. 远程服务
Redisson 分布式远程服务允许执行对象的方法通过在不同Redisson对象上的远程接口。可以正确处理使用POJO的对象，方法参数和结果对象。
远程服务提供了两种不同类型的RRemoteService实例:
- 服务端实例执行远程的方法 (工作者接口)。 示例: ```java RRemoteService remoteService = redisson.getRemoteService(); SomeServiceImpl someServiceImpl = new SomeServiceImpl();
// register remote service before any remote invocation // can handle only 1 invocation concurrently remoteService.register(SomeServiceInterface.class, someServiceImpl);
// register remote service able to handle up to 12 invocations concurrently remoteService.register(SomeServiceInterface.class, someServiceImpl, 12);
* 客户端实例，调用远程对象。 示例:
```java
RRemoteService remoteService = redisson.getRemoteService();
SomeServiceInterface service = remoteService.get(SomeServiceInterface.class);
String result = service.doSomeStuff(1L, "secondParam", new AnyParam());
客户端和服务器两端的实例应该包含相同的远程接口，同时需要使用相同的服务器连接配置进行redisson实例的备份。对客户端或者是远程的实例数目没有上线约束。 (注意: 然后redisson不强制任何的限制, redis的约束仍然适用.)
远程的调用能够被以并行的方式执行。并行执行的总数目是通过如下的计算方法得出的:(可以使用执行器的总和) = (服务端的实例数目)*(在服务注册时定义的执行器数目)
命令超过这个数目将会排队进行下一个可用的执行器。