Question

每个 Redisson 对象实例都会有一个与之对应的 Redis 数据实例，可以通过调用 getName 方法来取得 Redis 数据实例的名称（key）。

RMap map = redisson.getMap("mymap");
map.getName(); // = mymap

所有与 Redis key 相关的操作都归纳在 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();

6.1. 通用对象桶（Object Bucket）

Redisson 的分布式 RBucket Java 对象是一种通用对象桶可以用来存放任类型的对象。 除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

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

还可以通过 RBuckets 接口实现批量操作多个 RBucket 对象：

RBuckets buckets = redisson.getBuckets();
List<RBucket<V>> foundBuckets = buckets.find("myBucket*");
Map<String, V> loadedBuckets = buckets.get("myBucket1", "myBucket2", "myBucket3");

Map<String, Object> map = new HashMap<>();
map.put("myBucket1", new MyObject());
map.put("myBucket2", new MyObject());

// 利用 Redis 的事务特性，同时保存所有的通用对象桶，如果任意一个通用对象桶已经存在则放弃保存其他所有数据。
buckets.trySet(map);
// 同时保存全部通用对象桶。
buckets.set(map);

6.2. 二进制流（Binary Stream）

Redisson 的分布式 RBinaryStream Java 对象同时提供了 InputStream 接口和 OutputStream 接口的实现。流的最大容量受 Redis 主节点的内存大小限制。

RBinaryStream stream = redisson.getBinaryStream("anyStream");
byte[] content = ...
stream.set(content);

InputStream is = stream.getInputStream();
byte[] readBuffer = new byte[512];
is.read(readBuffer);

OutputStream os = stream.getOuputStream();
byte[] contentToWrite = ...
os.write(contentToWrite);

6.3. 地理空间对象桶（Geospatial Bucket）

Redisson 的分布式 RGeo Java 对象是一种专门用来储存与地理位置有关的对象桶。除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

RGeo<String> geo = redisson.getGeo("test");
geo.add(new GeoEntry(13.361389, 38.115556, "Palermo"),
        new GeoEntry(15.087269, 37.502669, "Catania"));
geo.addAsync(37.618423, 55.751244, "Moscow");

Double distance = geo.dist("Palermo", "Catania", GeoUnit.METERS);
geo.hashAsync("Palermo", "Catania");
Map<String, GeoPosition> positions = geo.pos("test2", "Palermo", "test3", "Catania", "test1");
List<String> cities = geo.radius(15, 37, 200, GeoUnit.KILOMETERS);
Map<String, GeoPosition> citiesWithPositions = geo.radiusWithPosition(15, 37, 200, GeoUnit.KILOMETERS);

6.4. BitSet

Redisson 的分布式 RBitSet Java 对象采用了与 java.util.BiteSet 类似结构的设计风格。可以理解为它是一个分布式的可伸缩式位向量。需要注意的是 RBitSet 的大小受 Redis 限制，最大长度为 4 294 967 295 。除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

RBitSet set = redisson.getBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);
set.addAsync("e");
set.xor("anotherBitset");

6.4.1. BitSet 数据分片（Sharding）（分布式 RoaringBitMap）

基于 Redis 的 Redisson 集群分布式 BitSet 通过 RClusteredBitSet 接口，为集群状态下的 Redis 环境提供了 BitSet 数据分片的功能。通过优化后更加有效的分布式 RoaringBitMap 算法，突破了原有的 BitSet 大小限制，达到了集群物理内存容量大小。在 这里 可以获取更多的内部信息。

RClusteredBitSet set = redisson.getClusteredBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);
set.addAsync("e");
set.xor("anotherBitset");

该功能仅限于 Redisson PRO 版本。

6.5. 原子整长形（AtomicLong）

Redisson 的分布式整长形 RAtomicLong 对象和 Java 中的 java.util.concurrent.atomic.AtomicLong 对象类似。除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

RAtomicLong atomicLong = redisson.getAtomicLong("myAtomicLong");
atomicLong.set(3);
atomicLong.incrementAndGet();
atomicLong.get();

6.6. 原子双精度浮点（AtomicDouble）

Redisson 还提供了分布式原子双精度浮点 RAtomicDouble ，弥补了 Java 自身的不足。除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

RAtomicDouble atomicDouble = redisson.getAtomicDouble("myAtomicDouble");
atomicDouble.set(2.81);
atomicDouble.addAndGet(4.11);
atomicDouble.get();

6.7. 话题（订阅分发）

Redisson 的分布式话题 RTopic ）、反射式（ Reactive ）和 RxJava2 标准的接口。

RTopic topic = redisson.getTopic("anyTopic");
topic.addListener(SomeObject.class, new MessageListener<SomeObject>() {
    @Override
    public void onMessage(String channel, SomeObject message) {
        //...
    }
});

// 在其他线程或 JVM 节点
RTopic topic = redisson.getTopic("anyTopic");
long clientsReceivedMessage = topic.publish(new SomeObject());

在 Redis 节点故障转移（主从切换）或断线重连以后，所有的话题监听器将自动完成话题的重新订阅。

6.7.1. 模糊话题

Redisson 的模糊话题 RPatternTopic 对象可以通过正式表达式来订阅多个话题。除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

// 订阅所有满足`topic1.*`表达式的话题
RPatternTopic topic1 = redisson.getPatternTopic("topic1.*");
int listenerId = topic1.addListener(Message.class, new PatternMessageListener<Message>() {
    @Override
    public void onMessage(String pattern, String channel, Message msg) {
         Assert.fail();
    }
});

在 Redis 节点故障转移（主从切换）或断线重连以后，所有的模糊话题监听器将自动完成话题的重新订阅。

6.8. 布隆过滤器（Bloom Filter）

Redisson 利用 Redis 实现了 Java 分布式 布隆过滤器（Bloom Filter） 。所含最大比特数量为 2^32 。

RBloomFilter<SomeObject> bloomFilter = redisson.getBloomFilter("sample");
// 初始化布隆过滤器，预计统计元素数量为 55000000，期望误差率为 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"));

6.8.1. 布隆过滤器数据分片（Sharding）

基于 Redis 的 Redisson 集群分布式布隆过滤器通过 RClusteredBloomFilter 接口，为集群状态下的 Redis 环境提供了布隆过滤器数据分片的功能。 通过优化后更加有效的算法，通过压缩未使用的比特位来释放集群内存空间。每个对象的状态都将被分布在整个集群中。所含最大比特数量为 2^64 。在 这里 可以获取更多的内部信息。

RClusteredBloomFilter<SomeObject> bloomFilter = redisson.getClusteredBloomFilter("sample");
// 采用以下参数创建布隆过滤器
// expectedInsertions = 255000000
// falseProbability = 0.03
bloomFilter.tryInit(255000000L, 0.03);
bloomFilter.add(new SomeObject("field1Value", "field2Value"));
bloomFilter.add(new SomeObject("field5Value", "field8Value"));
bloomFilter.contains(new SomeObject("field1Value", "field8Value"));

该功能仅限于 Redisson PRO 版本。

6.9. 基数估计算法（HyperLogLog）

Redisson 利用 Redis 实现了 Java 分布式 基数估计算法（HyperLogLog） 对象。该对象可以在有限的空间内通过概率算法统计大量的数据。除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

RHyperLogLog<Integer> log = redisson.getHyperLogLog("log");
log.add(1);
log.add(2);
log.add(3);

log.count();

6.10. 整长型累加器（LongAdder）

基于 Redis 的 Redisson 分布式 整长型累加器（LongAdder） 采用了与 java.util.concurrent.atomic.LongAdder 类似的接口。通过利用客户端内置的 LongAdder 对象，为分布式环境下递增和递减操作提供了很高得性能。据统计其性能最高比分布式 AtomicLong 对象快 12000 倍。完美适用于分布式统计计量场景。

RLongAdder atomicLong = redisson.getLongAdder("myLongAdder");
atomicLong.add(12);
atomicLong.increment();
atomicLong.decrement();
atomicLong.sum();

当不再使用整长型累加器对象的时候应该自行手动销毁，如果 Redisson 对象被关闭（shutdown）了，则不用手动销毁。

RLongAdder atomicLong = ...
atomicLong.destroy();

6.11. 双精度浮点累加器（DoubleAdder）

基于 Redis 的 Redisson 分布式 双精度浮点累加器（DoubleAdder） 采用了与 java.util.concurrent.atomic.DoubleAdder 类似的接口。通过利用客户端内置的 DoubleAdder 对象，为分布式环境下递增和递减操作提供了很高得性能。据统计其性能最高比分布式 AtomicDouble 对象快 12000 倍。完美适用于分布式统计计量场景。

RLongDouble atomicDouble = redisson.getLongDouble("myLongDouble");
atomicDouble.add(12);
atomicDouble.increment();
atomicDouble.decrement();
atomicDouble.sum();

当不再使用双精度浮点累加器对象的时候应该自行手动销毁，如果 Redisson 对象被关闭（shutdown）了，则不用手动销毁。

RLongDouble atomicDouble = ...

_b6d2063_
atomicDouble.destroy();

6.12. 限流器（RateLimiter）

基于 Redis 的分布式 限流器（RateLimiter） 可以用来在分布式环境下现在请求方的调用频率。既适用于不同 Redisson 实例下的多线程限流，也适用于相同 Redisson 实例下的多线程限流。该算法不保证公平性。除了同步接口外，还提供了异步（ Async ）、反射式（ Reactive ）和 RxJava2 标准的接口。

```java RRateLimiter rateLimiter = redisson.getRateLimiter("myRateLimiter"); // 初始化 // 最大流速 = 每 1 秒钟产生 10 个令牌 rateLimiter.trySetRate(RateType.OVERALL, 10, 1, RateIntervalUnit.SECONDS);

CountDownLatch latch = new CountDownLatch(2); limiter.acquire(3); // ...

Thread t = new Thread(() -> { limiter.acquire(2); // ...
});