玩转Redis!非常强大的Redisson分布式集合,少写60%代码

简介: Redisson是Java的Redis客户端,提供实时数据平台服务,简化了分布式环境下的数据管理。它包含RList、RSet、RMap等分布式集合,支持ConcurrentMap和Set接口,确保线程安全和数据一致性。例如,RMap实现了本地缓存和监听器功能,允许数据监听和本地加速读取。此外,还提供了RSet的排序和去重功能,以及RQueue和RBlockingQueue等队列实现,支持阻塞操作。通过Redisson,开发者能轻松处理分布式系统的数据同步和操作。
  1. 简介
    Redisson 是 Redis Java 客户端和实时数据平台。它为使用 Redis 提供了更方便、更简单的方法。Redisson 对象提供了关注点分离功能,可让你专注于数据建模和应用逻辑。

在Java中,为我们提供了丰富的集合类,如List、Set、Map等,这些集合类在单机应用或单个JVM进程中是非常强大和有效的工具。然而,在分布式系统下,数据需要在多个JVM进程或节点之间共享和同步。为实现这一目标Redisson提供了许多分布式集合实现,如RList、RSet、RMap等,这些集合类能够在多个Redis节点之间无缝地共享数据。通过使用Redisson,开发者可以像使用传统Java集合类一样,在分布式系统中进行数据的增删改查操作,而无需担心数据在不同节点之间的同步和一致性问题。

  1. 实战案例
    2.1 Map集合
    基于 Redis 的 Java 分布式 Map 对象实现了 ConcurrentMap 接口。该对象是完全线程安全的。

RMap类关系
public interface RMap extends ConcurrentMap, ...{}
接下来所有操作都是基于RedissonClient对象

@Resource
private RedissonClient redisson ;
同步存数据
RMap map = redisson.getMap("user-list");
User preValue = map.put("1", new User(2L, "张三2", 22)) ;
User value = map.putIfAbsent("2", new User(2L, "李四", 33));
快速存数据
如果你不需要返回上一个值(旧值)建议使用相应fast*方法

RMap map = redisson.getMap("user-list");
map.fastPut("1", new User(2L, "张三2", 22));
map.fastPutIfAbsent("2", new User(2L, "李四", 33));
map.fastRemove("1") ;
以上操作不会返回对应key之前的旧值。

异步存数据
RFuture f1 = map.putAsync("1", new User(2L, "张三2", 22)) ;
RFuture f2 = map.fastPutAsync("2", new User(2L, "李四", 33)) ;
RFuture f3 = map.fastRemoveAsync("2") ;
以上操作对应Redis数据结构。

HASH数据结构

Map集合中key绑定Lock
上面得知,Map保存的数据是hash数据结构,我们可以将每一个key绑定到对应的Lock/ReadWriteLock/Semaphore/CountDownLatch。

RMap map = redisson.getMap("user-list") ;
RLock lock = map.getLock(key) ;
lock.lock() ;
try {
System.out.printf("当前线程: %s, 当前时间: %d%n", Thread.currentThread().getName(), System.currentTimeMillis()) ;
TimeUnit.SECONDS.sleep(3) ;
} finally {
lock.unlock() ;
}
本地缓存
用于加快读取操作速度,避免网络往返。它在 Redisson 端缓存地图条目,执行读取操作的速度是普通实现的 45 倍。支持本地缓存的地图对象实现了RLocalCachedMap,它扩展了 java.util.concurrent.ConcurrentMap 接口。该对象是完全线程安全的。

// 配置缓存策略
final LocalCachedMapOptions LOCAL_CACHE = LocalCachedMapOptions.defaults()
// 缓存大小
.cacheSize(200)
// 缓存模式
.storeMode(StoreMode.LOCALCACHE_REDIS)
// 删除策略
.evictionPolicy(EvictionPolicy.LRU) ;
// 获取指定key本地缓存
RLocalCachedMap localCachedMap = redisson.getLocalCachedMap("user-list", LOCAL_CACHE) ;
User user = localCachedMap.get("1") ;
本地缓存实例对象同样支持fast*及异步方式,这里不再赘述。

事件监听
Redisson 允许为每个 RMap 对象绑定监听器,RMap 对象允许跟踪数据上的跟踪事件。如下表,监听类及事件

如下示例:

RMap map = redisson.getMap("user-list");
int deletedListener = map.addListener(new DeletedObjectListener() {
@Override
public void onDeleted(String name) {
// ...
}
});
int expredListener = map.addListener(new ExpiredObjectListener() {
@Override
public void onExpired(String name) {
// ...
}
});
int putListener = map.addListener(new MapPutListener() {
@Override
public void onPut(String name) {
// ...
}
});
int removeListener = map.addListener(new MapRemoveListener() {
@Override
public void onRemove(String name) {
// ...
}
});
// 删除监听器
map.removeListener(listenerId) ; // removeListener, putListener ...

以上是关于Map集合的常用操作。

2.2 Set集合
基于 Redis 的 Java Set 对象实现了 java.util.Set 接口。该对象完全线程安全。通过元素状态比较保持元素的唯一性。Redis 将集合大小限制为 4 294 967 295 个元素。Redis 使用序列化状态检查值的唯一性,而不是值的 hashCode()/equals() 方法。

RSet类关系
public interface RSet extends Set,...{}
基本操作
RSet set = redisson.getSet("user-set");
set.add(new User(1L, "张三", 33)) ;
set.add(new User(2L, "李四", 55)) ;
Redis中存储使用的数据结构:

RSet使用Set集合。与RMap一样,RSet也支持同步异步方式操作数据。

RFuture f1 = set.addAsync(new User(1L, "张三", 33)) ;
RFuture f2 = set.addAsync(new User(2L, "李四", 55)) ;
绑定Lock操作
RSet set = redisson.getSet("user-set") ;
RLock lock = set.getLock(new User(1L, "张三", 33)) ;
lock.lock() ;
try {
// ...
} finally {
lock.unlock() ;
}
删除策略
当前的Redis实现没有设置值删除功能。因此,过期的数据会被org.redisson.eviction.EvictionScheduler清除。它一次性删除300个过期条目。如果clean task每次删除300项,它将每秒执行一次(最小执行延迟)。但如果当前的过期值小于前一个,则执行延迟将增加1.5倍。

RSetCache set = redisson.getSetCache("user-set") ;
set.add(new User(3L, "阴阳路", 66), 180L, TimeUnit.SECONDS) ;
事件监听
与Map一样Set也有对应的事件监听,详细查看Map中对应的说明。

Set排序
基于 Redis 的 Java 分布式 SortedSet 实现了 java.util.SortedSet 接口。该对象线程安全。它使用比较器对元素进行排序并保持唯一性。对于字符串数据类型,建议使用 LexSortedSet 对象,以提高性能。

RSortedSet set = redisson.getSortedSet("set-sort") ;
// 这里不可以写成lambda表达式:(o1, o2) -> Integer.compare(o1, o2)
set.trySetComparator(new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 > o2 ? 1 : (o1 < o2 ? -1 : 0) ;
}
}) ;
set.add(3) ;
set.add(1) ;
set.add(2) ;
redis中生成如下2个key:

set-sort对应的值:

2.3 List集合
基于 Redis 的 Java 分布式 List 对象实现了 java.util.List 接口。它按插入顺序保存元素。它有 Async、Reactive 和 RxJava3 接口。Redis 限制列表大小为 4 294 967 295 个元素。

RList类关系
public interface RList extends List, ... {}
基本操作
RList list = redisson.getList("user-list");
User user = new User(1L, "张三", 10);
list.add(user) ;
User ret = list.get(0) ;
System.out.println("ret = " + ret) ;
list.remove(user) ;
事件监听
RList list = redisson.getList("user-list") ;
list.addListener(new ExpiredObjectListener() {
@Override
public void onExpired(String name) {
// ...
}
}) ;
// 其它事件
/**

  • DeletedObjectListener
  • ListAddListener
  • ListInsertListener
  • ListSetListener
  • ListRemoveListener
  • ListTrimListener
    */

2.4 Queue队列
基于 Redis 的 Java 分布式无界队列对象,实现了 java.util.Queue 接口。该对象是完全线程安全的。它有 Async、Reactive 和 RxJava3 接口。

RQueue类关系
public interface RQueue extends Queue, ... {}
基本操作
RQueue queue = redisson.getQueue("user-queue");
queue.add(new User()) ;
// 获取但不删除
User u1 = queue.peek() ;
// 获取并删除
User u2 = queue.poll() ;
redis使用的数据结构:

事件监听
RQueue queue = redisson.getQueue("user-queue") ;
queue.addListener(new ExpiredObjectListener() {
@Override
public void onExpired(String name) {
// ...
}
}) ;
// 其它事件
/**

  • ListAddListener
  • ListInsertListener
  • ListRemoveListener
    */
    2.5 阻塞队列
    基于Redis 的Java 分布式无界BlockingQueue对象,实现了 java.util.concurrent.BlockingQueue接口。该对象是完全线程安全的。它有 Async、Reactive 和 RxJava3 接口。

类关系
public interface RBlockingQueue extends BlockingQueue, ... {}
基本操作
RBlockingQueue queue = redisson.getBlockingQueue("user-blockqueue");
queue.offer(new User(1L, "哈哈", 22)) ;
// queue.offer(new User(2L, "嘿嘿", 33)) ;

User u1 = queue.peek() ;
User u2 = queue.poll() ;
// 这里会被阻塞,最多等待10s队列中有元素则直接返回
User u3 = queue.poll(10, TimeUnit.SECONDS) ;
对应redis使用的数据结构:

2.6 有界阻塞队列
大致使用用途上面一致:

RBoundedBlockingQueue queue = redisson.getBoundedBlockingQueue("user-capacity-queue");
// 设置容量大小
queue.trySetCapacity(2);

queue.offer(new User(1L, "张三", 20));
queue.offer(new User(2L, "李四", 10));
Redisson提供了很多分布式的队列实现,如还有双端队列,优先级队列等

相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
相关文章
|
13天前
|
NoSQL Java Redis
实现基于Redis的分布式锁机制
实现基于Redis的分布式锁机制
|
5天前
|
canal 缓存 NoSQL
Redis常见面试题(一):Redis使用场景,缓存、分布式锁;缓存穿透、缓存击穿、缓存雪崩;双写一致,Canal,Redis持久化,数据过期策略,数据淘汰策略
Redis使用场景,缓存、分布式锁;缓存穿透、缓存击穿、缓存雪崩;先删除缓存还是先修改数据库,双写一致,Canal,Redis持久化,数据过期策略,数据淘汰策略
Redis常见面试题(一):Redis使用场景,缓存、分布式锁;缓存穿透、缓存击穿、缓存雪崩;双写一致,Canal,Redis持久化,数据过期策略,数据淘汰策略
|
1天前
|
负载均衡 NoSQL Java
|
1天前
|
NoSQL Redis 数据库
|
8天前
|
分布式计算 API 对象存储
Ray是一个开源的分布式计算框架,用于构建和扩展分布式应用。它提供了简单的API,使得开发者可以轻松地编写并行和分布式代码,而无需担心底层的复杂性。
Ray是一个开源的分布式计算框架,用于构建和扩展分布式应用。它提供了简单的API,使得开发者可以轻松地编写并行和分布式代码,而无需担心底层的复杂性。
|
5天前
|
NoSQL Redis 数据库
|
9天前
|
NoSQL 安全 Java
技术好文:Redis分布式锁的正确实现方式
技术好文:Redis分布式锁的正确实现方式
11 0
|
16天前
|
存储 NoSQL Java
Redis10------Set类型,存在着无序的特征存储的顺序和插入的顺序是无关的,set集合的一大特点是不可重复,在redis中支持交集插集等特殊功能,好友列表,共同关注等等
Redis10------Set类型,存在着无序的特征存储的顺序和插入的顺序是无关的,set集合的一大特点是不可重复,在redis中支持交集插集等特殊功能,好友列表,共同关注等等
|
17天前
|
缓存 Devops 微服务
微服务01好处,随着代码越多耦合度越多,升级维护困难,微服务技术栈,异步通信技术,缓存技术,DevOps技术,搜索技术,单体架构,分布式架构将业务功能进行拆分,部署时费劲,集连失败如何解决
微服务01好处,随着代码越多耦合度越多,升级维护困难,微服务技术栈,异步通信技术,缓存技术,DevOps技术,搜索技术,单体架构,分布式架构将业务功能进行拆分,部署时费劲,集连失败如何解决
|
23天前
|
NoSQL Java Redis
通过Redis 实现分布式锁_利用Jedis 客户端
通过Redis 实现分布式锁_利用Jedis 客户端

热门文章

最新文章