Redisson（一）介绍与常见API

一、Redisson介绍

1、背景：

Redisson - 是一个高级的分布式协调Redis客服端，能帮助用户在分布式环境中轻松实现一些Java的对象。Redisson、Jedis、Lettuce 是三个常用的操作 Redis 的客户端，Jedis、Lettuce 的 API 更侧重对 Reids 数据库的 CRUD（增删改查）；而 Redisson API 侧重于分布式开发，提供了多种分布式Java对象和服务，包括分布式锁、分布式集合、分布式对象、分布式限流器、可重入锁等。

2、介绍：

Redisson是一个在Redis的基础上实现的Java内存数据网格（In-Memory Data Grid），它充分利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类，让使用Redis更加简单、便捷，从而让使用者能够将更多精力集中到业务逻辑处理上。

 也就是说Redisson不仅仅是一个Redis客户端，它是一个以内存 Redis 服务器作为后端的处理 Java 对象，它还实现了很多具有分布式特性的常用工具类。比如分布式锁、布隆过滤器等。下图是官网提供的Redisson可以做的事情。

二、组件

Redisson的几个常用客户端有：

1、RedissonClient（最常用）

通过Config对象配置RedissonClient所需要的参数，然后获取RedissonClient对象即可。

Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
RedissonClient redisson = Redisson.create(config);

2、其他组件

• RedissonRxClient（响应式）
• RedissonReactiveClient（响应式）
• ReactiveRedisTemplate（响应式）

二、RedissonClient常见API

实际应用中，如果是操作数据存取一般不使用Redisson，可以使用Jedis或者轻量型的RedisTemplate；Redisson一般用在分布式锁中，还有限流也有使用到Redisson。

 1、分布式锁

   可重入锁RLock

 RLock lock = redissonClient.getLock("lock");
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread() + "-" + System.currentTimeMillis() + "-" + "获取了锁");
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }).start();
        }

org.redisson.api.RLock 有以下常用API：

（1）创建锁对象

RLock getLock(String var1);

 （2）判断是否已经锁了

boolean isLocked();

（3） 尝试加锁

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

（4）直接加锁 

void lock(long var1, TimeUnit var3);

（5）解锁

void unlock();

 2、限流器

基于Redis的分布式限流器可以用来在分布式环境下现在请求方的调用频率。既适用于不同Redisson实例下的多线程限流，也适用于相同Redisson实例下的多线程限流。该算法不保证公平性。

 RRateLimiter rateLimiter = redissonClient.getRateLimiter("rateLimiter");
        //创建限流器，最大流速:每1秒钟产生20个令牌
        rateLimiter.trySetRate(RateType.OVERALL, 20, 1, RateIntervalUnit.SECONDS);
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                int i = 0;
                @Override
                public void run() {
                    while(true) {
                        rateLimiter.acquire(1);
                        System.out.println(Thread.currentThread() + "-" + System.currentTimeMillis() + "-" + i++);
                    }
                }
            }).start();
        }

如：

 public boolean isSystemRateLimited(String from, String to, String userId){
            try{
                String SYSTEM_RATE_LIMIT_KEY = "system_rate_limit_user:{0}_from:{1}_to:{2}";
                String redisKey = MessageFormat.format(SYSTEM_RATE_LIMIT_KEY, userId, from, to);
                RRateLimiter rateLimiter = redissonClient.getRateLimiter(redisKey);
                rateLimiter.trySetRate(RateType.OVERALL, 100, 60, RateIntervalUnit.SECONDS);
                boolean acquired = rateLimiter.tryAcquire();
                if (acquired) rateLimiter.expire(Duration.of(60, ChronoUnit.SECONDS));
                return !acquired;
            } catch (Exception e) {
                return false;
            }
        }

3、String字符串

  Redisson将Redis中的字符串数据结构封装成了RBucket，通过RedissonClient的getBucket(key)方法获取一个RBucket对象实例，通过这个实例可以设置value或设置value和有效期。并且可以操作所有类型的对象。

//1、存 
RBucket<Object> bucket = redissonClient.getBucket(你的键名称);
        //设置值，过期时间为3小时
        bucket.set(你的value,30, TimeUnit.HOURS);
        
        //2、通过key取value值
        Object name = redissonClient.getBucket(你的键名称).get();
        System.out.println(name);

 RBucket<Object> bucket = redissonClient.getBucket("myString-key");
  bucket.set("{\"userName\":\"test\",\"userPwd\":\"test\",\"email\":\"xxx@163.com\",\"captcha\":\"3552\"}");


​
//存
redissonClient.getBucket(key).set(value);
//取
String value = (String) redissonClient.getBucket(key).get();

 4、List

 RList<String> list = redissonClient.getList("users");
        list.add("zs");
        list.add("ls");
        System.out.println(list);
       //通过key取value值
        List<Object> list1 = redissonClient.getList("users").get();
        //移除索引0位置元素
        list.remove(0);

5、Set

 RSet<Object> set = redissonClient.getSet("users");
        set.add("zs");
        set.add("ls");
        //通过key取value值
        RSet<Object> set1 = redissonClient.getSet("users");

4、Hash

RMap<Object, Object> map = redissonClient.getMap("myFirstMap");
map.put("productId2","100055301");

​
 RMap<Object, Object> map = redissonClient.getMap("userMap");
        map.put("zs","张三");
        map.put("ls","李四");
        map.forEach((key,value)->{
            System.out.println("key = "+key+" ,value = "+ value);
        });
 
        //通过key取value值
        Object o = redissonClient.getMap("userMap").get("zs");

5、SortedSet（ZSET） 

RScoredSortedSet<String> sortedSet = redissonClient.getScoredSortedSet("sortedKey-32");
 sortedSet.add(1.0, "zs");
 sortedSet.add(2.0, "lisi");

6、二进制流存储

提供了InputStream接口和OutputStream接口的实现

//====================操作流来存储对象====================
        RBinaryStream stream = redissonClient.getBinaryStream("stream");
        stream.set("name is ".getBytes());
        OutputStream outputStream = stream.getOutputStream();
 
        outputStream.write("victory".getBytes());
        InputStream inputStream = stream.getInputStream();
 
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] bytes = new byte[1024];
        int length;
        while ((length = inputStream.read(bytes)) != -1) {
            result.write(bytes, 0, length);
        }
        System.out.println(result.toString());

 7、队列

 RQueue<String> queue = redissonClient.getQueue("queue");
        //存值
        queue.add("zs");
        queue.add("ls");
        //取值
        String item = queue.poll();
        System.out.println(item);
 
        //
        RQueue<Object> queue1 = redissonClient.getQueue("queue");

10、发布订阅

Redisson的分布式话题 RTopic 对象实现了发布、订阅的机制。 

 //====================操作topic执行发布操作====================
        RTopic topic1 = redissonClient.getTopic("topic",new SerializationCodec());
        topic1.publish(new Message(1L,"victory",18));
 
        //====================操作topic执行订阅操作====================
        Thread.sleep(5000);
        RTopic topic = redissonClient1.getTopic("topic", new SerializationCodec());
        topic.addListener(Message.class, new MessageListener<Message>() {
            @Override
            public void onMessage(CharSequence channel, Message msg) {
                System.out.println("onMessage:=========" + channel + "; Thread:========= " + Thread.currentThread().toString());
                System.out.println(" name : " + msg.getName() + " age : " + msg.getAge());
                LoggerFactory.getLogger(RedissonDemo.class).info("Redisson接收到消息",msg);
            }
        });

 11、 布隆过滤器

RBloomFilter<String> bloomFilter = redissonClient.getBloomFilter("bloom-filter");
        // 初始化布隆过滤器，初始化预期插入的数据量为200，期望误差率为0.01
        bloomFilter.tryInit(200, 0.01);
        //插入数据
        bloomFilter.add("丁胜利");
        bloomFilter.add("丁向前");
        bloomFilter.add("胜利丁");
        //判断是否包含
        boolean victory = bloomFilter.contains("丁胜利");
        boolean forward = bloomFilter.contains("向前丁");
        System.out.println(victory); //true
        System.out.println(forward); //false

12、对象

RObject object = redisson.getAtomicObject("object");
object.set(new MyObject(1, "hello"));
MyObject val = (MyObject)object.get();
System.out.println(val); // MyObject{id=1, name='hello'}

Redisson自定义序列化_redisson 序列化_yzh_1346983557的博客-优快云博客

redis存取的数据一定是可序列化的，而可序列化方式可以自定义。如果不同客户端设置的可序列化方式不一样，会导致读取不一致的问题。常见的序列化方式有几下几种