Redisson-分布式对象、分布式集合

最新推荐文章于 2024-03-23 21:53:38 发布

dreamsofa

最新推荐文章于 2024-03-23 21:53:38 发布

阅读量350

点赞数

文章标签： java redis redisson

本文链接：https://blog.csdn.net/dreamsofa/article/details/134404924

版权

Redisson-分布式对象、分布式集合

Redisson 提供可以像单JVM内存对象使用方式一样的形式使用的分布式对象，使用者无需关心分布式对象的具体分布式存储细节。

分布式对象

通用对象桶RBucket/RBuckets

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

二进制流RBinaryStream

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

地理空间对象桶RGeo

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

RBitSet

RBitSet set = redisson.getBitSet("simpleBitset");

set.set(0, true);

set.set(1812, false);

set.clear(0);

set.addAsync("e");

set.xor("anotherBitset");

BitSet数据分片

基于Redis集群提供扩展的、分片的BitSet.

RClusteredBitSet set = redisson.getClusteredBitSet("simpleBitset");

set.set(0, true);

set.set(1812, false);

set.clear(0);

set.addAsync("e");

set.xor("anotherBitset");

原子整长形AtomicLong

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

atomicLong.set(3);

atomicLong.incrementAndGet();

atomicLong.get();

原子双精度浮点（AtomicDouble）

RAtomicDouble atomicDouble = redisson.getAtomicDouble("myAtomicDouble");

atomicDouble.set(2.81);

atomicDouble.addAndGet(4.11);

atomicDouble.get();

话题（订阅分发）

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

模糊话题

// 订阅所有满足`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();

}

});

布隆过滤器（Bloom Filter）

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

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

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

基数估计算法（HyperLogLog）

RHyperLogLog<Integer> log = redisson.getHyperLogLog("log");

log.add(1);

log.add(2);

log.add(3);

log.count();

整长型累加器（LongAdder）

RLongAdder atomicLong = redisson.getLongAdder("myLongAdder");

atomicLong.add(12);

atomicLong.increment();

atomicLong.decrement();

atomicLong.sum();

双精度浮点累加器（DoubleAddr）

RLongDouble atomicDouble = redisson.getLongDouble("myLongDouble");

atomicDouble.add(12);

atomicDouble.increment();

atomicDouble.decrement();

atomicDouble.sum();

限流器（RateLimiter）

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

// ...

});

Footer

分布式集合

映射

RMap保持了元素的插入顺序。该对象的最大容量受Redis限制，最大元素数量是4 294 967 295个

RMap<String, SomeObject> 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");

RFuture<SomeObject> putAsyncFuture = map.putAsync("321");

RFuture<Void> fastPutAsyncFuture = map.fastPutAsync("321");

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

map.fastRemoveAsync("321");

Map元素淘汰(Eviction), 本地缓存(LocalCache)和数据分片(Sharding)

元素淘汰（Eviction）类: 带有元素淘汰（Eviction）机制的映射类允许针对一个映射中每个元素单独设定有效时间和最长闲置时间。

所有过期元素都是通过org.redisson.EvictionScheduler实例来实现定期清理的。为了保证资源的有效利用，每次运行最多清理100个过期元素。任务的启动时间将根据上次实际清理数量自动调整，间隔时间趋于1秒到2小时之间。比如该次清理时删除了100条元素，那么下次执行清理的时间将在1秒以后（最小间隔时间）。一旦该次清理数量少于上次清理数量，时间间隔将增加1.5倍。集合元素中新增元素时指定过期时间。（其他多值映射、Set过期都类似）

本地缓存（LocalCache）类:本地缓存（Local Cache）也叫就近缓存（Near Cache）。这类映射的使用主要用于在特定的场景下，映射缓存（MapCache）上的高度频繁的读取操作，使网络通信都被视为瓶颈的情况。Redisson与Redis通信的同时，还将部分数据保存在本地内存里。这样的设计的好处是它能将读取速度提高最多 45倍。所有同名的本地缓存共用一个订阅发布话题，所有更新和过期消息都将通过该话题共享。

数据分片（Sharding）类:数据分片（Sharding）类仅适用于Redis集群环境下，因此带有数据分片（Sharding）功能的映射也叫集群分布式映射。它利用分库的原理，将单一一个映射结构切分为若干个小的映射，并均匀的分布在集群中的各个槽里。这样的设计能使一个单一映射结构突破Redis自身的容量限制，让其容量随集群的扩大而增长。在扩容的同时，还能够使读写性能和元素淘汰处理能力随之成线性增长。

Eviction

RMapCache<String, SomeObject> map = redisson.getMapCache("anyMap");

// 有效时间 ttl = 10分钟

map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES);

// 有效时间 ttl = 10分钟, 最长闲置时间 maxIdleTime = 10秒钟

map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES, 10, TimeUnit.SECONDS);

// 有效时间 = 3 秒钟

map.putIfAbsent("key2", new SomeObject(), 3, TimeUnit.SECONDS);

// 有效时间 ttl = 40秒钟, 最长闲置时间 maxIdleTime = 10秒钟

map.putIfAbsent("key2", new SomeObject(), 40, TimeUnit.SECONDS, 10, TimeUnit.SECONDS);

本地缓存功能

LocalCachedMapOptions options = LocalCachedMapOptions.defaults()

// 用于淘汰清除本地缓存内的元素

// 共有以下几种选择:

// LFU - 统计元素的使用频率，淘汰用得最少（最不常用）的。

// LRU - 按元素使用时间排序比较，淘汰最早（最久远）的。

// SOFT - 元素用Java的WeakReference来保存，缓存元素通过GC过程清除。

// WEAK - 元素用Java的SoftReference来保存, 缓存元素通过GC过程清除。

// NONE - 永不淘汰清除缓存元素。

.evictionPolicy(EvictionPolicy.NONE)

// 如果缓存容量值为0表示不限制本地缓存容量大小

.cacheSize(1000)

// 以下选项适用于断线原因造成了未收到本地缓存更新消息的情况。

// 断线重连的策略有以下几种：

// CLEAR - 如果断线一段时间以后则在重新建立连接以后清空本地缓存

// LOAD - 在服务端保存一份10分钟的作废日志

// 如果10分钟内重新建立连接，则按照作废日志内的记录清空本地缓存的元素

// 如果断线时间超过了这个时间，则将清空本地缓存中所有的内容

// NONE - 默认值。断线重连时不做处理。

.reconnectionStrategy(ReconnectionStrategy.NONE)

// 以下选项适用于不同本地缓存之间相互保持同步的情况

// 缓存同步策略有以下几种：

// INVALIDATE - 默认值。当本地缓存映射的某条元素发生变动时，同时驱逐所有相同本地缓存映射内的该元素

// UPDATE - 当本地缓存映射的某条元素发生变动时，同时更新所有相同本地缓存映射内的该元素

// NONE - 不做任何同步处理

.syncStrategy(SyncStrategy.INVALIDATE)

// 每个Map本地缓存里元素的有效时间，默认毫秒为单位

.timeToLive(10000)

// 或者

.timeToLive(10, TimeUnit.SECONDS)

// 每个Map本地缓存里元素的最长闲置时间，默认毫秒为单位

.maxIdle(10000)

// 或者

.maxIdle(10, TimeUnit.SECONDS);

RLocalCachedMap<String, Integer> map = redisson.getLocalCachedMap("test", options);

String prevObject = map.put("123", 1);

String currentObject = map.putIfAbsent("323", 2);

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

// 在不需要旧值的情况下可以使用fast为前缀的类似方法

map.fastPut("a", 1);

map.fastPutIfAbsent("d", 32);

map.fastRemove("b");

RFuture<String> putAsyncFuture = map.putAsync("321");

RFuture<Void> fastPutAsyncFuture = map.fastPutAsync("321");

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

map.fastRemoveAsync("321");

当不再使用Map本地缓存对象的时候应该手动销毁，如果Redisson对象被关闭（shutdown）了，则不用手动销毁。

RLocalCachedMap<String, Integer> map = ...

map.destroy();

数据分片

RClusteredMap<String, SomeObject> map = redisson.getClusteredMap("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");

Map持久化

Read-through策略：如果一个被请求的数据不存在于Redisson的映射中的时候，Redisson将通过预先配置好的MapLoader对象加载数据。

Write-through（数据同步写入）策略：在遇到映射中某条数据被更改时，Redisson会首先通过预先配置好的MapWriter对象写入到外部储存系统，然后再更新Redis内的数据。

Write-behind（数据异步写入）策略：对映射的数据的更改会首先写入到Redis，然后再使用异步的方式，通过MapWriter对象写入到外部储存系统。在并发环境下可以通过writeBehindThreads参数来控制写入线程的数量，已达到对外部储存系统写入并发量的控制。

以上策略适用于所有实现了RMap、RMapCache、RLocalCachedMap和RLocalCachedMapCache接口的对象。

MapOptions<K, V> options = MapOptions.<K, V>defaults()

.writer(myWriter)

.loader(myLoader);

RMap<K, V> map = redisson.getMap("test", options);

// 或

RMapCache<K, V> map = redisson.getMapCache("test", options);

// 或

RLocalCachedMap<K, V> map = redisson.getLocalCachedMap("test", options);

// 或

RLocalCachedMapCache<K, V> map = redisson.getLocalCachedMapCache("test", options);

映射监听器

Redisson为所有实现了RMapCache或RLocalCachedMapCache接口的对象提供了监听以下事件的监听器：

事件 | 监听器

元素添加事件 | org.redisson.api.map.event.EntryCreatedListener

元素过期事件 | org.redisson.api.map.event.EntryExpiredListener

元素删除事件 | org.redisson.api.map.event.EntryRemovedListener

元素更新事件 | org.redisson.api.map.event.EntryUpdatedListener

RMapCache<String, Integer> map = redisson.getMapCache("myMap");

// 或

RLocalCachedMapCache<String, Integer> map = redisson.getLocalCachedMapCache("myMap", options);

int updateListener = map.addListener(new EntryUpdatedListener<Integer, Integer>() {

@Override

public void onUpdated(EntryEvent<Integer, Integer> event) {

event.getKey(); // 字段名

event.getValue() // 新值

event.getOldValue() // 旧值

// ...

}

});

LRU有界映射

分布式LRU有界映射允许通过对其中元素按使用时间排序处理的方式，主动移除超过规定容量限制的元素。

RMapCache<String, String> map = redisson.getMapCache("map");

// 尝试将该映射的最大容量限制设定为10

map.trySetMaxSize(10);

// 将该映射的最大容量限制设定或更改为10

map.setMaxSize(10);

map.put("1", "2");

map.put("3", "3", 1, TimeUnit.SECONDS);

多值映射Multimap

基于Set的多值映射， RSetMultimap

RSetMultimap<SimpleKey, SimpleValue> map = redisson.getSetMultimap("myMultimap");

map.put(new SimpleKey("0"), new SimpleValue("1"));

map.put(new SimpleKey("0"), new SimpleValue("2"));

map.put(new SimpleKey("3"), new SimpleValue("4"));

Set<SimpleValue> allValues = map.get(new SimpleKey("0"));

List<SimpleValue> newValues = Arrays.asList(new SimpleValue("7"), new SimpleValue("6"), new SimpleValue("5"));

Set<SimpleValue> oldValues = map.replaceValues(new SimpleKey("0"), newValues);

Set<SimpleValue> removedValues = map.removeAll(new SimpleKey("0"));

RListMultimap: 基于List的多值映射。

Set

RSet<SomeObject> set = redisson.getSet("anySet");

set.add(new SomeObject());

set.remove(new SomeObject());

RClusteredSet：数据分片Set

有序集SortedSet

RSortedSet<Integer> set = redisson.getSortedSet("anySet");

计分有序集ScoredSortedSet

RScoredSortedSet<SomeObject> set = redisson.getScoredSortedSet("simple");

字典排序集

RLexSortedSet set = redisson.getLexSortedSet("simple");

set.add("d");

set.addAsync("e");

set.add("f");

set.lexRangeTail("d", false);

set.lexCountHead("e");

set.lexRange("d", true, "z", false);

其他

列表： RList

队列：RQueue

双端队列： RDeque

有界阻塞队列：RBoundedBlockingQueue

阻塞双端队列：RBlockingDeque

阻塞公平队列：RBlockingFairQueue

阻塞公平双端队列： RBlockingFairDeque

延迟队列：RDelayedQueue

优先队列：RPriorityQueue

优先双端队列：RPriorityDeque

优先阻塞队列：RPriorityBlockingQueue

优先阻塞双端队列：RPriorityBlockingDeque

dreamsofa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redisson-分布式对象、分布式集合

这类映射的使用主要用于在特定的场景下，映射缓存（MapCache）上的高度频繁的读取操作，使网络通信都被视为瓶颈的情况。Write-behind（数据异步写入）策略：对映射的数据的更改会首先写入到Redis，然后再使用异步的方式，通过MapWriter对象写入到外部储存系统。Read-through策略：如果一个被请求的数据不存在于Redisson的映射中的时候，Redisson将通过预先配置好的MapLoader对象加载数据。当本地缓存映射的某条元素发生变动时，同时驱逐所有相同本地缓存映射内的该元素。
复制链接

扫一扫