Redisson是一個在Redis的基礎上實現的Java常駐記憶體資料網格(In-Memory Data Grid)。它不僅提供了一系列的分散式的Java常用物件，還提供了許多分散式服務。Redisson提供了使用Redis的簡單、便捷的方法。本文主要介紹使用Redisson操作redis，使用到的軟體版本：Java 1.8.0_191、Redis 5.0.8、Redisson 3.13.2。

1、引入依賴

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</
 
artifactId>
    <version>3.13.2</version>
</dependency>

2、Redisson操作redis

package com.inspur.demo.general.redis;

import io.reactivex.Scheduler;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.redisson.Redisson;
import org.redisson.api.*;
import
 
 org.redisson.config.Config;
import redis.clients.jedis.Jedis;

import java.io.*;
import java.sql.SQLSyntaxErrorException;
import java.util.BitSet;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Redisson操作redis
 * Redisson除了提供同步介面外，還提供了非同步（Async）、反射式（Reactive）和RxJava2標準的介面。
 * Redisson會序列化java物件然後儲存到reids，所以通過redis命令列設定的值，Redisson來獲取值會報錯；通redis命令列獲取Redisson設定的值前面會多出序列化相關的資訊
 
 
*/
public class RedissonCase {
    private RedissonClient client;
    private RedissonReactiveClient reactiveClient;
    private RedissonRxClient rxClient;

    @Before
    public void before() {
        Config config = new Config();
        //config.setCodec(new org.redisson.client.codec.StringCodec());
        config.useSingleServer().setAddress("redis://10.49.196.10:6379").setPassword("123456");
        client = Redisson.create(config);
        reactiveClient = Redisson.createReactive(config);
        rxClient = Redisson.createRx(config);
    }

    @After
    public void after() {
        client.shutdown();
        reactiveClient.shutdown();
        rxClient.shutdown();
    }

    /**
     * 通用物件桶，可以用來存放任型別的物件
     */
    @Test
    public void bucket() throws Exception {
        //同步
        RBucket<String> bucket = client.getBucket("name");
        bucket.set("zhaoyun");
        System.out.println(bucket.get());

        //非同步
        RBucket<String> bucket2 = client.getBucket("name2");
        bucket2.setAsync("趙雲2").get();
        bucket2.getAsync().thenAccept(System.out::println);

        //Reactive
        RBucketReactive<String> bucket3 = reactiveClient.getBucket("name3");
        bucket3.set("趙雲3").block();
        bucket3.get().subscribe(System.out::println);

        //RxJava2
        RBucketRx<String> bucket4 = rxClient.getBucket("name4");
        bucket4.set("趙雲4").blockingGet();
        bucket4.get().subscribe(System.out::println);

        Thread.sleep(1000 * 5);
    }

    /**
     * 二進位制流
     * 提供了InputStream介面和OutputStream介面的實現
     */
    @Test
    public void stream() throws Exception {
        RBinaryStream stream = client.getBinaryStream("stream");
        stream.set("趙雲".getBytes());
        OutputStream outputStream = stream.getOutputStream();
        outputStream.write("張飛".getBytes());

        InputStream inputStream = stream.getInputStream();
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] b = new byte[1024];
        int len;
        while ((len = inputStream.read(b)) != -1) {
            result.write(b, 0, len);
        }
        System.out.println(result.toString());
    }

    @Test
    public void atomicLong() {
        RAtomicLong atomicLong = client.getAtomicLong("atomicLong");
        atomicLong.set(10);
        atomicLong.incrementAndGet();
        System.out.println(atomicLong);
    }

    /**
     * 限流器
     */
    @Test
    public void rateLimiter() throws InterruptedException {
        RRateLimiter rateLimiter = client.getRateLimiter("rateLimiter");
        //初始化 最大流速:每1秒鐘產生5個令牌
        rateLimiter.trySetRate(RateType.OVERALL, 5, 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();
        }

        Thread.sleep(1000 * 5);
    }

    /**
     * RList實現了java.util.List介面
     */
    @Test
    public void list() {
        RList<String> list = client.getList("list");
        list.add("a");
        list.add("趙雲");
        list.add("張飛");
        list.remove(1);
        System.out.println(list);
    }

    /**
     * RMap實現了java.util.concurrent.ConcurrentMap介面和java.util.Map介面
     * @throws Exception
     */
    @Test
    public void map() throws Exception {
        RMap<String, String> map = client.getMap("map");
        map.put("name", "趙雲");
        map.put("location", "常山");
        map.put("camp", "蜀");
        map.remove("location");
        map.forEach((key, value) -> {System.out.println("key=" + key + ",value=" + value);});
    }

    /**
     * RSet實現了java.util.Set介面
     * @throws Exception
     */
    @Test
    public void set() {
        RSet<String> set = client.getSet("set");
        set.add("趙雲");
        set.add("張飛");
        set.forEach(System.out::println);
    }

    /**
     * RQueue實現了java.util.Queue介面
     */
    @Test
    public void queue() {
        RQueue<String> queue = client.getQueue("queue");
        queue.add("趙雲");
        queue.add("張飛");
        System.out.println(queue.poll());
        System.out.println(queue.poll());
    }

    /**
     * 可重入鎖 RLock實現了java.util.concurrent.locks.Lock介面
     */
    @Test
    public void lock() throws InterruptedException {
        RLock lock = client.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();
        }
        Thread.sleep(1000 * 5);
    }
}

3、Redisson配置

package com.inspur.demo.general.redis;

import org.junit.Test;
import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

/**
 * Redisson配置
 */
public class RedissonConfigCase {
    /**
     * 單Redis節點模式
     */
    @Test
    public void singl() {
        Config config = new Config();
        config.useSingleServer()
                .setAddress("redis://10.49.196.10:6379")
                .setPassword("123456")
                .setConnectionPoolSize(5)//連線池大小
                .setConnectionMinimumIdleSize(2)//最小空閒連線數
                .setDatabase(0);
        RedissonClient client = Redisson.create(config);
        RBucket<String> name = client.getBucket("name");
        System.out.println(name.get());
    }

    /**
     * 主從模式
     */
    @Test
    public void masterSlave() {
        Config config = new Config();
        config.useMasterSlaveServers()
                .setMasterAddress("redis://10.49.196.20:6379")
                .addSlaveAddress("redis://10.49.196.21:6379")
                .addSlaveAddress("redis://10.49.196.22:6379")
                .setPassword("123456")
                .setMasterConnectionPoolSize(5)//主節點連線池大小
                .setMasterConnectionMinimumIdleSize(2)//主節點最小空閒連線數
                .setSlaveConnectionPoolSize(5)//從節點連線池大小
                .setSlaveConnectionMinimumIdleSize(2)//從節點最小空閒連線數
                .setDatabase(0);
        RedissonClient client = Redisson.create(config);
        RBucket<String> name = client.getBucket("name");
        System.out.println(name.get());
    }

    /**
     * 哨兵模式
     */
    @Test
    public void sentinel() {
        Config config = new Config();
        config.useSentinelServers()
                .setMasterName("mymaster")
                .addSentinelAddress("redis://10.49.196.20:26379")
                .addSentinelAddress("redis://10.49.196.21:26379")
                .addSentinelAddress("redis://10.49.196.22:26379")
                .setPassword("123456")
                .setMasterConnectionPoolSize(5)//主節點連線池大小
                .setMasterConnectionMinimumIdleSize(3)//主節點最小空閒連線數
                .setSlaveConnectionPoolSize(5)//從節點連線池大小
                .setSlaveConnectionMinimumIdleSize(3)//從節點最小空閒連線數
                .setCheckSentinelsList(false)
                .setDatabase(0);
        System.out.println(config.useSentinelServers().getSentinelAddresses());

        RedissonClient client = Redisson.create(config);
        RBucket<String> name = client.getBucket("name");
        name.set("趙雲");
        System.out.println(name.get());
    }

    /**
     * 叢集
     */
    @Test
    public void cluster() {
        Config config = new Config();
        config.useClusterServers()
                .setScanInterval(1000 * 2)
                .addNodeAddress("redis://10.49.196.20:7000", "redis://10.49.196.20:7001")
                .addNodeAddress("redis://10.49.196.21:7000", "redis://10.49.196.21:7001")
                .addNodeAddress("redis://10.49.196.22:7000", "redis://10.49.196.22:7001")
                .setPassword("123456")
                .setMasterConnectionPoolSize(5)
                .setMasterConnectionMinimumIdleSize(2)
                .setSlaveConnectionPoolSize(5)
                .setSlaveConnectionMinimumIdleSize(2);
        RedissonClient client = Redisson.create(config);
        RBucket<String> name = client.getBucket("name");
        name.set("趙雲");
        System.out.println(name.get());
    }
}