redis redisson 集合的使用案例(RList、Rset、RMap)

redis redisson 集合操作

相关类及接口

Rlist:链表

public interface RList<V> extends List<V>, RExpirable, RListAsync<V>, RSortable<List<V>>, RandomAccess {
    List<V> get(int... var1);              //获取指定的节点值
    int addAfter(V var1, V var2);          //在var1前添加var2
    int addBefore(V var1, V var2);         //在var1后添加var2
    void fastSet(int var1, V var2);        //修改var1处的只为var2

    List<V> readAll();                     //获取链表的所有值
    RList<V> subList(int var1, int var2);  //获取var1到var2的子链表
    List<V> range(int var1);               //返回var1往后的链表
    List<V> range(int var1, int var2);     //返回var1到var2的链表

    void trim(int var1, int var2);         //保留var1到var2处的链表,其余删除
    void fastRemove(int var1);             //删除var1处的值
    boolean remove(Object var1, int var2); //判断元素是否删除
    <KOut, VOut> RCollectionMapReduce<V, KOut, VOut> mapReduce();  //mapreduce操作
}

RSet:无序集合

public interface RSet<V> extends Set<V>, RExpirable, RSetAsync<V>, RSortable<Set<V>> {
    V removeRandom();
    Set<V> removeRandom(int var1);     //删除对象
    V random();
    Set<V> random(int var1);           //随机返回对象
    boolean move(String var1, V var2); //判断集合var1中是否存在var2,类似contains()方法
    Set<V> readAll();                  //获取所有对象
    int union(String... var1);         //集合并集对象个数
    Set<V> readUnion(String... var1);  //集合并集
    int diff(String... var1);          //集合差集对象个数
    Set<V> readDiff(String... var1);   //集合差集

    int intersection(String... var1);         //集合交集的对象个数
    Set<V> readIntersection(String... var1);  //集合交集
    Iterator<V> iterator(int var1);
    Iterator<V> iterator(String var1, int var2);
    Iterator<V> iterator(String var1);        //遍历集合

    <KOut, VOut> RCollectionMapReduce<V, KOut, VOut> mapReduce();
    RSemaphore getSemaphore(V var1);
    RCountDownLatch getCountDownLatch(V var1);
    RPermitExpirableSemaphore getPermitExpirableSemaphore(V var1);  //信号量

    RLock getLock(V var1);
    RLock getFairLock(V var1);
    RReadWriteLock getReadWriteLock(V var1); //锁操作

    Stream<V> stream(int var1);
    Stream<V> stream(String var1, int var2);
    Stream<V> stream(String var1);          //流操作
}

RMap:键值对

public interface RMap<K, V> extends ConcurrentMap<K, V>, RExpirable, RMapAsync<K, V> {
    void loadAll(boolean var1, int var2);
    void loadAll(Set<? extends K> var1, boolean var2, int var3);

    V get(Object var1);                       //获取var1的值
    V put(K var1, V var2);                    //添加对象
    V putIfAbsent(K var1, V var2);            //对象不存在则设置
    V replace(K var1, V var2);                //替换对象
    boolean replace(K var1, V var2, V var3);  //替换对象
    V remove(Object var1);                    //移除对象
    boolean remove(Object var1, Object var2); //移除对象
    void putAll(Map<? extends K, ? extends V> var1);
    void putAll(Map<? extends K, ? extends V> var1, int var2);   //添加对象

    Map<K, V> getAll(Set<K> var1);                               //获取key在集合var1中的键值对
    int valueSize(K var1);                   //key为var1的value大小
    V addAndGet(K var1, Number var2);        //key为var1的value加var2
    long fastRemove(K... var1);              //移除对象
    boolean fastPut(K var1, V var2);         //添加对象
    boolean fastReplace(K var1, V var2);     //替换key为var1的值为var2
    boolean fastPutIfAbsent(K var1, V var2); //如果不存在则设置

    Set<K> readAllKeySet();                  //获取所有key,以set形式返回
    Collection<V> readAllValues();           //获取所有value,以collection返回
    Set<Entry<K, V>> readAllEntrySet();      //遍历键值对
    Map<K, V> readAllMap();                  //集合形式转换为map类型

    Set<K> keySet();
    Set<K> keySet(int var1);
    Set<K> keySet(String var1, int var2);
    Set<K> keySet(String var1);              //获取key集合

    Collection<V> values();
    Collection<V> values(String var1);
    Collection<V> values(String var1, int var2);
    Collection<V> values(int var1);          //获取所有value

    Set<Entry<K, V>> entrySet();
    Set<Entry<K, V>> entrySet(String var1);
    Set<Entry<K, V>> entrySet(String var1, int var2);
    Set<Entry<K, V>> entrySet(int var1);     //遍历键值对
    <KOut, VOut> RMapReduce<K, V, KOut, VOut> mapReduce();
    RSemaphore getSemaphore(K var1);
    RCountDownLatch getCountDownLatch(K var1);
    RPermitExpirableSemaphore getPermitExpirableSemaphore(K var1);  //信号量操作

    RLock getLock(K var1);
    RLock getFairLock(K var1);
    RReadWriteLock getReadWriteLock(K var1);  //锁操作
}

使用示例

public class MyTest {
    public static void main(String[] args){
        Config config=new Config();
        config.useSingleServer().setAddress("redis://******:6379").setPassword("123456");
        RedissonClient client= Redisson.create(config);
         RList<String> list=client.getList("list");
        for (int i=0;i<10;i++){
            list.add("瓜田李下 "+i);
        }

        list.readAll().forEach(System.out::println);
        System.out.println("list的数量为:"+list.size()+"\n");
        RSet<String> set=client.getSet("set");
        for (int i=0;i<10;i++){
            set.add("瓜田李下 "+i);
        }

        for (String s : set) {
            System.out.println(s);
        }
        System.out.println("set的大小为:"+set.size()+"\n");
        RMap<Integer,String> map=client.getMap("map");
        for (int i=0;i<10;i++){
            map.put(i,"瓜田李下 "+i);
        }

        for (Map.Entry<Integer,String> entry:map.entrySet()){
            System.out.println(entry.getKey()+" ==> "+entry.getValue());
        }
        System.out.println("map的大小为:"+map.size());
    }
}

控制台输出

瓜田李下 0
瓜田李下 1
瓜田李下 2
瓜田李下 3
瓜田李下 4
瓜田李下 5
瓜田李下 6
瓜田李下 7
瓜田李下 8
瓜田李下 9
list的数量为:10

瓜田李下 0
瓜田李下 1
瓜田李下 7
瓜田李下 3
瓜田李下 5
瓜田李下 4
瓜田李下 9
瓜田李下 8
瓜田李下 6
瓜田李下 2
set的大小为:10

0 ==> 瓜田李下 0
1 ==> 瓜田李下 1
2 ==> 瓜田李下 2
3 ==> 瓜田李下 3
4 ==> 瓜田李下 4
5 ==> 瓜田李下 5
6 ==> 瓜田李下 6
7 ==> 瓜田李下 7
8 ==> 瓜田李下 8
9 ==> 瓜田李下 9
map的大小为:10

Redisson使用注意事项

Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格,相较于暴露底层操作的Jedis,Redisson提供了一系列的分布式的 Java 常用对象,还提供了许多分布式服务。

特性 & 功能:

  • 支持 Redis 单节点(single)模式、哨兵(sentinel)模式、主从(Master/Slave)模式以及集群(Redis Cluster)模式
  • 程序接口调用方式采用异步执行和异步流执行两种方式
  • 数据序列化,Redisson 的对象编码类是用于将对象进行序列化和反序列化,以实现对该对象在 Redis 里的读取和存储
  • 单个集合数据分片,在集群模式下,Redisson 为单个 Redis 集合类型提供了自动分片的功能
  • 提供多种分布式对象,如:Object Bucket,Bitset,AtomicLong,Bloom Filter 和 HyperLogLog 等
  • 提供丰富的分布式集合,如:Map,Multimap,Set,SortedSet,List,Deque,Queue 等
  • 分布式锁和同步器的实现,可重入锁(Reentrant Lock),公平锁(Fair Lock),联锁(MultiLock),红锁(Red Lock),信号量(Semaphonre),可过期性信号锁(PermitExpirableSemaphore)等
  • 提供先进的分布式服务,如分布式远程服务(Remote Service),分布式实时对象(Live Object)服务,分布式执行服务(Executor Service),分布式调度任务服务(Schedule Service)和分布式映射归纳服务(MapReduce)
  • 更多特性和功能,请关注官网:http://redisson.org

实现原理

redis本身是不支持上述的分布式对象和集合,Redisson是通过利用redis的特性在客户端实现了高级数据结构和特性,例如优先队列的实现,是通过客户端排序整理后再存入redis。

客户端实现,意味着当没有任何客户端在线时,这些所有的数据结构和特性都不会保留,也不会自动生效,例如过期事件的触发或原来优先队列的元素增加。

注意事项

实时性

RMap中有一个功能是可以设置键值对的过期时间的,并可以注册键值对的事件监听器

  • 元素淘汰功能(Eviction)
  • Redisson的分布式的RMapCache Java对象在基于RMap的前提下实现了针对单个元素的淘汰机制。同时仍然保留了元素的插入顺序。由于RMapCache是基于RMap实现的,使它同时继承了java.util.concurrent.ConcurrentMap接口和java.util.Map接口。Redisson提供的Spring Cache整合以及JCache正是基于这样的功能来实现的。
  • 目前的Redis自身并不支持散列(Hash)当中的元素淘汰,因此所有过期元素都是通过org.redisson.EvictionScheduler实例来实现定期清理的。为了保证资源的有效利用,每次运行最多清理300个过期元素。任务的启动时间将根据上次实际清理数量自动调整,间隔时间趋于1秒到1小时之间。比如该次清理时删除了300条元素,那么下次执行清理的时间将在1秒以后(最小间隔时间)。一旦该次清理数量少于上次清理数量,时间间隔将增加1.5倍。

正如官方wiki所述,这个功能是通过后台线程定时去清理的, 所以这个是非实时的(issue-1234:on expired event is not executed in real-time.),延迟在5秒到2小时之间,因此对实时性要求比较高的场景就得自己衡量了。

由于过期时间的非实时性,所以导致过期事件的发生也是非实时的,相应的监听器可能会延迟了一会儿才收到通知,在我的测试中,ttl设置在秒级误差是比较大的,分钟级别的ttl倒还好(左侧设置值,右侧实际耗时):

1s _ 5s
3s _ 5s
4s _ 5s
5s _ 9s
6s _ 10s
10s _ 15s
1m _ 1m11s

序列化

由Redisson默认的编码器为JsonJacksonCodec,JsonJackson在序列化有双向引用的对象时,会出现无限循环异常。而fastjson在检查出双向引用后会自动用引用符$ref替换,终止循环。

在我的情况中,我序列化了一个service,这个service已被spring托管,而且和另一个service之间也相互注入了,用fastjson能 正常序列化到redis,而JsonJackson则抛出无限循环异常。

为了序列化后的内容可见,所以不用redission其他自带的二进制编码器,自行实现编码器:

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.buffer.ByteBufInputStream;
import io.netty.buffer.ByteBufOutputStream;
import org.redisson.client.codec.BaseCodec;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.Encoder;​
import java.io.IOException;
​
public class FastjsonCodec extends BaseCodec {​
 private final Encoder encoder = in -> {
 ByteBuf out = ByteBufAllocator.DEFAULT.buffer();
 try {
 ByteBufOutputStream os = new ByteBufOutputStream(out);
 JSON.writeJSONString(os, in,SerializerFeature.WriteClassName);
 return os.buffer();
 } catch (IOException e) {
 out.release();
 throw e;
 } catch (Exception e) {
 out.release();
 throw new IOException(e);
 }
 };
​
 private final Decoder<Object> decoder = (buf, state) ->
 JSON.parseObject(new ByteBufInputStream(buf), Object.class);
​
 @Override
 public Decoder<Object> getValueDecoder() {
 return decoder;
 }
​
 @Override
 public Encoder getValueEncoder() {
 return encoder;
 }
}

订阅发布

Redisson对订阅发布的封装是RTopic,这也是Redisson中很多事件监听的实现原理(例如键值对的事件监听)。

使用单元测试时发现,在事件发布后,订阅方需要延时一下才能收到事件。具体原因待查

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • SpringBoot集成Redisson实现延迟队列的场景分析

    使用场景 1.下单成功,30分钟未支付.支付超时,自动取消订单 2.订单签收,签收后7天未进行评价.订单超时未评价,系统默认好评 3.下单成功,商家5分钟未接单,订单取消 4.配送超时,推送短信提醒 ...... 对于延时比较长的场景.实时性不高的场景,我们可以采用任务调度的方式定时轮询处理.如:xxl-job 今天我们采用一种比较简单.轻量级的方式,使用 Redis 的延迟队列来进行处理.当然有更好的解决方案,可根据公司的技术选型和业务体系选择最优方案.如:使用消息中间件Kafka.Rabbi

  • Redis框架Jedis及Redisson对比解析

    1概述 1.1. 主要内容 本文的主要内容为对比Redis的两个框架:Jedis与Redisson,分析各自的优势与缺点,为项目中Java缓存方案中的Redis编程模型的选择提供参考. 2. Jedis与Redisson对比 2.1. 概况对比 Jedis是Redis的Java实现的客户端,其API提供了比较全面的Redis命令的支持:Redisson实现了分布式和可扩展的Java数据结构,和Jedis相比,功能较为简单,不支持字符串操作,不支持排序.事务.管道.分区等Redis特性.Redis

  • redisson分布式锁的用法大全

    Redisson是Redis官方推荐的Java版的Redis客户端.它提供的功能非常多,此处我们只用它的分布式锁功能. 以springboot整合Redisson项目为例 添加springboot maven依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</artifactId> <version>3.15

  • redis分布式锁RedissonLock的实现细节解析

    redis分布式锁RedissonLock 简单使用 String key = "key-lock"; RLock lock = redisson.getLock(key); lock.lock(); try { // TODO } catch (Exception e){ log.error(e.getMessage(), e); } finally { lock.unlock(); } String key = "key-tryLock"; long maxWa

  • springboot利用redis、Redisson处理并发问题的操作

    一.引入问题 在工作中,遇到的接口基本都是长这样的: 如下为一个库存扣减的接口.从redis中获取库存数量,然后扣减一个数量 问题这个接口在并发的情况下是有问题,可以用jmeter测试一下(用postman压力测试了一下,没有测出并发问题.网上有的博客说postman没法测试并发) jmeter设置:100个并发 打印结果: 问题很严重呀 解决方案,优化如下: jmeter设置:101个并发,stock=100,则正确结果是应该会出现一次"扣减失败,库存不足" 打印如下,没毛病 二.如

  • SpringBoot整合Redisson的步骤(单机版)

    Redisson.Jedis.Lettuce优缺点对比 (1)Redisson 优点: 实现了分布式特性和可扩展的 Java 数据结构,适合分布式开发: API线程安全: 基于Netty框架的事件驱动的通信,可异步调用. 缺点: API更抽象,学习使用成本高. (2)Jedis 优点: 提供了比较全面的Redis操作特性的API API基本与Redis的指令一一对应,使用简单易理解. 缺点: 同步阻塞IO: 不支持异步: 线程不安全. (3)Lettuce 优点: 线程安全; 基于Netty 框

  • 解决线程并发redisson使用遇到的坑

    线程并发redisson的坑 背景 因为业务上的一个购买需求,需要对库存进行行程保护,防止超卖的出现(我们不是电商公司),经过调研,最终选择使用Redission来进行控制. 主要因为Redission丰富的API,开源框架,已经被广泛应用于实际生产环境. 问题描述 当我们使用Ression中Lock.lock()方法之后,如果存在线程并发常见情况下,会出现如下异常: java.lang.IllegalMonitorStateException: attempt to unlock lock,

  • Java redisson实现分布式锁原理详解

    Redisson分布式锁 之前的基于注解的锁有一种锁是基本redis的分布式锁,锁的实现我是基于redisson组件提供的RLock,这篇来看看redisson是如何实现锁的. 不同版本实现锁的机制并不相同 引用的redisson最近发布的版本3.2.3,不同的版本可能实现锁的机制并不相同,早期版本好像是采用简单的setnx,getset等常规命令来配置完成,而后期由于redis支持了脚本Lua变更了实现原理. <dependency> <groupId>org.redisson&

  • redis redisson 集合的使用案例(RList、Rset、RMap)

    redis redisson 集合操作 相关类及接口 Rlist:链表 public interface RList<V> extends List<V>, RExpirable, RListAsync<V>, RSortable<List<V>>, RandomAccess { List<V> get(int... var1); //获取指定的节点值 int addAfter(V var1, V var2); //在var1前添加v

  • Redis Set 集合的实例详解

     Redis Set 集合的实例详解 Redis的Set是string类型的无序集合.集合成员是唯一的,这就意味着集合中不能出现重复的数据. redis 中 集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是O(1). 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员). 实例 redis 127.0.0.1:6379> SADD runoobkey redis (integer) 1 redis 127.0.0.1:6379> SADD ru

  • Redis有序集合类型的常用命令小结

    一.有序集合类型 有序集合类型,大家从名字上应该就可以知道,实际上就是在集合类型上加了个有序而已.Redis中的有序集合类型,实际上是在集合类型上,为每个元素都关联一个分数,有序实际上说的是分数有序,我们根据分数的范围获取集合及其他操作.集合的元素依然是不能够相同的,但是分数可以相同. 下面列举有序集合和类型和列表类型的相似处: ①两者都是有序的(废话!) ②两者都可以获得某一范围的元素 下面列举区别: ①列表是链表实现的,靠近两边的数据读取极快,而元素过多后获取中间元素的速度则会很慢:有序集合

  • 使用Redis有序集合实现IP归属地查询详解

    工作中经常遇到一类需求,根据 IP 地址段来查找 IP 对应的归属地信息.如果把查询过程放到关系型数据库中,会带来很大的 IO 消耗,速度也不能满足,显然是不合适的. 那有哪些更好的办法呢?为此做了一些尝试,下面来详细说明. 构建索引文件 在 GitHub 上看到一个ip2region 项目,作者通过生成一个包含有二级索引的文件来实现快速查询,查询速度足够快,毫秒级别.但如果想更新地址段或归属地信息,每次都要重新生成文件,并不是很方便. 不过还是推荐大家看看这个项目,其中建索引的思想还是很值得学

  • 基于Redis无序集合如何实现禁止多端登录功能

    前言 一个集合类型可以存储最多2^32 -1 个字符串 集合类型在redis内部使用值为空的散列表(hash table)实现,所以集合中的加入或删除元素等时间复杂度为O(1). 集合具有元素唯一性. 本文主要给大家介绍了基于Redis无序集合实现禁止多端登录的相关内容,下面话不多说了,来一起看看详细的介绍吧 应用背景 多个应用端假设名称叫做A和B,禁止用户从A B同时登录,A登录踢B,B登录踢A 实现思路 设置两个无序集合a_set, b_set a b 登录的时候执行 $redis->sAd

  • Java实现Redis的集合(set)命令操作

    配置文件请看上篇Java实现redis https://www.jb51.net/article/190922.htm 下面测试redis的集合set的类型,注释里面的代码是linux中redis命令 package com.huadian.set; import com.huadian.redisUntil.JedisPoolUntil; import org.junit.Before; import org.junit.Test; import redis.clients.jedis.Jed

  • redis redisson 限流器的实例(RRateLimiter)

    redis redisson 限流器实例 作用:限制一段时间内对数据的访问数量 相关接口 RRateLimiter public interface RRateLimiter extends RRateLimiterAsync, RObject { boolean trySetRate(RateType var1, long var2, long var4, RateIntervalUnit var6); //设置访问速率,var2为访问数,var4为单位时间,var6为时间单位 void ac

  • Redis之windows下主从复制案例讲解

    一般的主从复制功能最少是一主二从,我这里就以最低要求进行配置. 1.首先下去官网下载并安装redis 若安装成功点击redis-server  如此是成功 2.点击客户端redis-cli 连接客户端即可使用 3.新建7000.7001两个从redis  4.修改redis-windows.conf   (1)把端口修改成7000 (2)修改cluster-config-file的名字 以免和6379端口的名字重复其他配置默认即可,我个人认为我们都重新建了一个文件夹也不可能出现和6379重复的错

  • SpringBoot集成Redis实现验证码的简单案例

    目录 一.下载安装Redis 二.代码部分 总结 前言 一次学习过程中简单的记录 一.下载安装Redis 这里就不多说了,下载安装好Redis,最好是把Redis Desktop Manager一起安装了,可视化看的舒服一点. 二.代码部分 1.引入库,配置yml 引入Redis依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter

  • 基于Redis结合SpringBoot的秒杀案例详解

    目录 1.构建SpringBoot项目 2.启动类 3.在Controller层里定义秒杀接口 4.在Service层里通过lua脚本实现秒杀效果 5.配置redis连接参数 6.演示秒杀效果 6.1 准备redis环境 6.2 启动项目 6.3 多线程形式发起秒杀请求 1.构建SpringBoot项目 搭建名为quickbuy的springboot项目,相关的依赖包如下所示: <?xml version="1.0" encoding="UTF-8"?>

随机推荐