Jedis、RedisTemplate、Redisson 详解和实例_redission、jedis、hiredis-CSDN博客

本文链接：https://blog.csdn.net/leesinbad/article/details/128053757

Jedis 是 Redis 官方推荐的面向 Java 的操作Redis 的客户端，通过jedis我们可以实现连接Redis，以及操作 Redis 。

一、Jedis 需要注意的点

在redis3.2之后，redis增加了protected-mode，在这个模式下，即使注释掉了bind 127.0.0.1，再访问redisd时候还是报错查看redis.confy文件，如果protected-mode 是 yes 那么需要设置用户密码

1、Jedis类

Jedis父类BinaryJedis所依赖的接口：
    BasicCommands:
        提供基础的查询命令,如ping,quit,flushdb
    BinaryJedisCommands:
        提供了针对redis数据结构的CURD等操作,其中参数(K-V)必须以byte数组形式提供
    MultiKeyBinaryCommands:
        提供了针对redis数据结构的CURD等批量操作,其中参数(K-V)必须以byte数组形式提供
    AdvancedBinaryJedisCommands:
        提供高级操作redis的命令,如config相关,slowlog,client等命令,其中参数(K-V)必须以byte数组形式提供
    BinaryScriptingCommands:
        提供Lua脚本运行命令,命令必须以byte数组形式提供。
Jedis所依赖的接口：
    JedisCommands:
        提供了针对redis数据结构的CURD等操作,其中参数(K-V)必须以String形式提供
    MultiKeyCommands:
        提供了针对redis数据结构的CURD等批量操作,其中参数(K-V)必须以String数组形式提供
    AdvancedJedisCommands:
        提供高级操作redis的命令,如config相关,slowlog,client等命令,其中参数(K-V)必须以String形式提供
    ScriptingCommands:
        提供Lua脚本运行命令,命令必须以String形式提供。
    BasicCommands:
        提供如ping,quit,flushDb运维类命令
    ClusterCommands:
        提供集群状态查看,集群操作的命令
    SentinelCommands:
        提供哨兵操作命令
    ModuleCommands:
        提供redis模块加载和卸载命令

引入pom:

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
    <type>jar</type>
    <scope>compile</scope>
</dependency>

yml文件配置：

  redis:
    host: 127.21.55.48
    port: 6398
    password: 88888
    jedis:
     pool:
        #最大连接数
        max-active: 8
        #最大阻塞等待时间(负数表示没限制)
        max-wait: -1
        #最大空闲
        max-idle: 8
        #最小空闲
        min-idle: 0
        #连接超时时间
    timeout: 10000

2、基本用法示例

2.1 在多线程环境中使用 Jedis

您不应该使用来自不同线程的同一实例，因为会出现奇怪的错误。有时创建大量Jedis实例还不够好，因为这意味着大量的套接字和连接，这也会导致奇怪的错误。单个Jedis实例不是线程安全的！为了避免这些问题，您应该使用JedisPool，这是一个线程安全的网络连接池。如果完成后将Jedis实例返回到池中，则可以使用池可靠地创建多个Jedis示例。通过这种方式，您可以克服这些奇怪的错误并获得出色的性能。

要使用它，请初始化池：

JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");

您可以将池静态存储在某个位置，它是线程安全的。

JedisPoolConfig 包括许多有用的 Redis 特定连接池默认值。JedisPool基于Commons Pool 2，所以你可能想看看Commons Pool的配置。

您可以通过以下方式使用它：

/// Jedis implements Closeable. Hence, the jedis instance will be auto-closed after the last statement.
try (Jedis jedis = pool.getResource()) {
  /// ... do stuff here ... for example
  jedis.set("foo", "bar");
  String foobar = jedis.get("foo");
  jedis.zadd("sose", 0, "car"); jedis.zadd("sose", 0, "bike"); 
  Set<String> sose = jedis.zrange("sose", 0, -1);
}
/// ... when closing your application:
pool.close();

如果您不能在资源中使用try，您仍然可以使用Jedis.close（）。

Jedis jedis = null;
try {
  jedis = pool.getResource();
  /// ... do stuff here ... for example
  jedis.set("foo", "bar");
  String foobar = jedis.get("foo");
  jedis.zadd("sose", 0, "car"); jedis.zadd("sose", 0, "bike"); 
  Set<String> sose = jedis.zrange("sose", 0, -1);
} finally {
  // You have to close jedis object. If you don't close then
  // it doesn't release back to pool and you can't get a new
  // resource from pool.
  if (jedis != null) {
    jedis.close();
  }
}
/// ... when closing your application:
pool.close();

若Jedis是从池中借用的，那个么它将使用正确的方法返回到池中，因为它已经确定发生了JedisConnectionException。若Jedis不是从池中借来的，它将被断开并关闭。

2.1 设置主/从分配

启用复制

Redis 主要用于主/从分发。这意味着写入请求必须显式发送到主服务器（redis 服务器），后者将更改复制到从服务器（也是 redis 服务器）。然后，读取请求可以（但不一定）发送给从站，从而减轻了主站的负担。

您可以使用主控形状，如上所示。为了启用复制，有两种方法可以告诉从站它将是给定主服务器的“slaveOf”：

在 Redis 服务器的 Redis 配置文件的相应部分中指定它
在给定的 jedis 实例上（见上文），调用 slaveOf 方法并将 IP（或“localhost”）和端口作为参数传递：

jedis.slaveof("localhost", 6379);  //  if the master is on the same PC which runs your code
jedis.slaveof("192.168.1.35", 6379);

注意：由于默认情况下Redis 2.6从设备是只读的，因此对它们的写入请求将导致错误。
如果您更改该设置，它们的行为将与正常的redis服务器一样，并接受写入请求而不会出错，但这些更改不会被复制，因此，如果您混淆了jedis实例，这些更改可能会被默默覆盖。

禁用复制/主服务器出现故障时，升级从属服务器

万一你的主人倒下了，你可能想提拔一个奴隶成为新的主人。您应该首先（尝试）首先禁用脱机主服务器的复制，然后，如果您有多个从站，请启用剩余从站到新主站的复制：

slave1jedis.slaveofNoOne();
slave2jedis.slaveof("192.168.1.36", 6379);

详细请参阅：Jedis 使用详解（官方原版）

二、RedisTemplate使用

RedisTemplate方式是SpringBoot集成Redis的客户端方式 ,SpringDataRedis 中对JedisAp i的高度封装。SpringDataRedis 相对于 Jedis 来说可以方便地更换 Redis 的 Java客户端，比 Jedis 多了自动管理连接池的特性，方便与其他 Spring 框架进行搭配使用如：SpringCache

官网：Spring Boot Reference Guide

接口：RedisTemplate (Spring Data Redis 3.0.2 API)

引入pom:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.3</version>
</dependency>

yml文件配置：

 redis:
    host: 192.168.159.133
    port: 6379
    database: 0
    jedis:
      pool:
        max-active: 10
        max-idle: 5
        min-idle: 0
        max-wait: 60000

redisTemplate.opsForValue();//操作字符串
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForZSet();//操作有序set
//向redis里存入数据和设置缓存时间
//参数1：是key 键
//参数2：是值是存入redis里的值
//参数3：时间，类型为long
//参数4：时间类型，
如：TimeUnit.MILLISECONDS 代表分钟
RedisTemplate.opsForValue().set("baike", "100", 60 * 10, TimeUnit.SECONDS);
//根据key获取缓存中的val
RedisTemplate.opsForValue().get("baike")
//根据key获取过期时间并指定返回形式
RedisTemplate.opsForValue().getOperations.getExpire("baike",TimeUnit.HOURS);
//根据key获取过期时间并换算成指定单位
RedisTemplate.getExpire("baike",TimeUnit.SECONDS);
//根据key删除缓存
RedisTemplate.delete("baike");
//检查key是否存在，返回boolean值
RedisTemplate.hasKey("baike");
//向指定key中存放set集合
RedisTemplate.opsForSet().add("baike", "1","2","3");
//设置过期时间
RedisTemplate.expire("baike",1000 , TimeUnit.MILLISECONDS);
//根据key查看集合中是否存在指定数据

示例代码：

 @Autowired
    RedisTemplate redisTemplate;

    /**
     * 指定key的失效时间
     */
    @GetMapping("expire")
    public void expire(String key, long time) {
        //参数一：key
        //参数二：睡眠时间
        //参数三：睡眠时间单位 TimeUnit.DAYS 天 TimeUnit.HOURS 小时 。。。
        redisTemplate.expire(key, time, TimeUnit.MINUTES);
    }

    /**
     * 根据key获取过期时间
     */
    @GetMapping("getexpire")
    public long getExpire(String key) {
        Long expire = redisTemplate.getExpire(key);
        return expire;
    }

    /**
     * 判断key是否存在
     */
    @GetMapping("haskey")
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 根据key删除reids中缓存数据
     */
    @GetMapping("delredisbykey")
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 保存和读取String
     */
    @GetMapping("stringredisdemo")
    public String stringredisdemo() {
        //设置过期时间为1分钟
        redisTemplate.opsForValue().set("key1", "value1", 1, TimeUnit.MINUTES);
        redisTemplate.opsForValue().set("key2", "value2");
        redisTemplate.opsForValue().set("key3", "value3");
        //读取redis数据
        String result1 = redisTemplate.opsForValue().get("key1").toString();
        String result2 = redisTemplate.opsForValue().get("key2").toString();
        String result3 = redisTemplate.opsForValue().get("key3").toString();
        System.out.println("缓存结果为：result：" + result1 + "  " + result2 + "   " + result3);
        return "缓存结果为：result：" + result1 + "  " + result2 + "   " + result3;
    }

    /**
     * 保存和读取list
     */
    @GetMapping("listredisdemo")
    public String listredisdemo() {
        List<String> list1 = new ArrayList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        List<String> list2 = new ArrayList<>();
        list2.add("b1");
        list2.add("b2");
        list2.add("b3");
        redisTemplate.opsForList().leftPush("listkey1", list1);
        redisTemplate.opsForList().rightPush("listkey2", list2);
        List<String> resultList1 = (List<String>) redisTemplate.opsForList().leftPop("listkey1");
        List<String> resultList2 = (List<String>) redisTemplate.opsForList().rightPop("listkey2");
        System.out.println("resultList1:" + resultList1);
        System.out.println("resultList2:" + resultList2);
        return "成功";
    }

    /**
     * Hash结构，保存和读取map
     */
    @GetMapping("mapredisdemo")
    public String mapredisdemo() {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        redisTemplate.opsForHash().putAll("map1", map);
        Map<String, String> resultMap = redisTemplate.opsForHash().entries("map1");
        List<String> reslutMapList = redisTemplate.opsForHash().values("map1");
        Set<String> resultMapSet = redisTemplate.opsForHash().keys("map1");
        String value = (String) redisTemplate.opsForHash().get("map1", "key1");
        System.out.println("value:" + value);
        System.out.println("resultMapSet:" + resultMapSet);
        System.out.println("resultMap:" + resultMap);
        System.out.println("resulreslutMapListtMap:" + reslutMapList);
        return "成功";
    }

    /**
     * 保存和读取Set
     */
    @GetMapping("setredisdemo")
    public String getredisdemo() {
        SetOperations<String, String> set = redisTemplate.opsForSet();
        set.add("key1", "value1");
        set.add("key1", "value2");
        set.add("key1", "value3");
        Set<String> resultSet = redisTemplate.opsForSet().members("key1");
        System.out.println("resultSet:" + resultSet);
        return "resultSet:" + resultSet;
    }

    /**
     * 保存和读取zset
     */
    @GetMapping("zsetredisdemo")
    public String zsetredisdemo() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5", 9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6", 9.9);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        System.out.println(redisTemplate.opsForZSet().add("zset1", tuples));
        System.out.println(redisTemplate.opsForZSet().range("zset1", 0, -1));
        return "成功";
    }

三、Redisson使用

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上，Redisson底层采用的是Netty 框架

RLock是Redisson分布式锁的最核心接口，继承了concurrent包的Lock接口和自己的RLockAsync接口，RLockAsync的返回值都是RFuture，是Redisson执行异步实现的核心逻辑，也是Netty发挥的主要阵地。

支持的主要功能：分布式锁、分布式服务、数据序列化、分布式对象处理

基于Netty框架。兼容 Redis 3.0+ 和 JDK 1.8+。

Redisson开发代码：
引入pom:

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

单Redis节点模式：

Redisson程序化的配置方法是通过构建Config对象实例来实现的。例如：

 
Config config = new Config();
config.setTransportMode(TransportMode.EPOLL); // 默认是NIO的方式
config.useClusterServers()
      //可以用"rediss://"来启用SSL连接，前缀必须是redis:// or rediss://
      .addNodeAddress("redis://127.0.0.1:7181");

Redisson的配置文件可以是或YAML格式。也通过调用config.fromYAML方法并指定一个File实例来实现读取YAML格式的配置：

Config config = Config.fromYAML(new File("config-file.yaml"));
RedissonClient redisson = Redisson.create(config);

1、集群模式

1.1 集群模式配置：

Config config = new Config();
config.useClusterServers()
    .setScanInterval(2000) // 集群状态扫描间隔时间，单位是毫秒
    //可以用"rediss://"来启用SSL连接
    .addNodeAddress("redis://127.0.0.1:7000", "redis://127.0.0.1:7001")
    .addNodeAddress("redis://127.0.0.1:7002");

RedissonClient redisson = Redisson.create(config);

集群设置：

群集连接模式由以下行激活：

ClusterServersConfig clusterConfig = config.useClusterServers();

ClusterServersConfig 类的设置参数如下：

nodeAddresses（添加节点地址）

可以通过的格式来添加Redis集群节点的地址。多个节点可以一次性批量添加。host:port

scanInterval（集群扫描间隔时间）

默认值： 1000

对Redis集群节点状态扫描的时间间隔。单位是毫秒。

slots（分片数量）

默认值：用于指定数据分片过程中的分片数量。支持数据分片/框架结构有：集（Set）、映射（Map）、BitSet、Bloom filter, Spring Cache和Hibernate Cache等.231

readMode（读取操作的负载均衡模式）

默认值：（只在从服务节点里读取）SLAVE

注：在从服务节点里读取的数据说明已经至少有两个节点保存了该数据，确保了数据的高可用性。

设置读取操作选择节点的模式。可用值为： - 只在从服务节点里读取。 - 只在主服务节点里读取。 - 在主从服务节点里都可以读取。SLAVEMASTERMASTER_SLAVE

subscriptionMode（订阅操作的负载均衡模式）

默认值：（只在从服务节点里订阅）SLAVE

设置订阅操作选择节点的模式。可用值为： - 只在从服务节点里订阅。 - 只在主服务节点里订阅。SLAVEMASTER

loadBalancer（负载均衡算法类的选择）

默认值： org.redisson.connection.balancer.RoundRobinLoadBalancer

在多Redis服务节点的环境里，可以选用以下几种负载均衡方式选择一个节点： - 权重轮询调度算法 - 轮询调度算法 - 随机调度算法org.redisson.connection.balancer.WeightedRoundRobinBalancerorg.redisson.connection.balancer.RoundRobinLoadBalancerorg.redisson.connection.balancer.RandomLoadBalancer

subscriptionConnectionMinimumIdleSize（从节点发布和订阅连接的最小空闲连接数）

默认值：1

多从节点的环境里，每个从服务节点里用于发布和订阅连接的最小保持连接数（长连接）。Redisson内部经常通过发布和订阅来实现许多功能。长期保持一定数量的发布订阅连接是必须的。

subscriptionConnectionPoolSize（从节点发布和订阅连接池大小）

默认值：50

多从节点的环境里，每个从服务节点里用于发布和订阅连接的连接池最大容量。连接池的连接数量自动弹性伸缩。

slaveConnectionMinimumIdleSize（从节点最小空闲连接数）

默认值：32

多从节点的环境里，每个从服务节点里用于普通操作（非发布和订阅）的最小保持连接数（长连接）。长期保持一定数量的连接有利于提高瞬时读取反映速度。

slaveConnectionPoolSize（从节点连接池大小）

默认值：64

多从节点的环境里，每个从服务节点里用于普通操作（非发布和订阅）连接的连接池最大容量。连接池的连接数量自动弹性伸缩。

masterConnectionMinimumIdleSize（主节点最小空闲连接数）

默认值：32

多节点的环境里，每个主节点的最小保持连接数（长连接）。长期保持一定数量的连接有利于提高瞬时写入反应速度。

masterConnectionPoolSize（主节点连接池大小）

默认值：64

多主节点的环境里，每个主节点的连接池最大容量。连接池的连接数量自动弹性伸缩。

idleConnectionTimeout（连接空闲超时，单位：毫秒）

默认值：10000

如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。

connectTimeout（连接超时，单位：毫秒）

默认值：10000

同任何节点建立连接时的等待超时。时间单位是毫秒。

timeout（命令等待超时，单位：毫秒）

默认值：3000

等待节点回复命令的时间。该时间从命令发送成功时开始计时。

retryAttempts（命令失败重试次数）

默认值：3

如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。

retryInterval（命令重试发送时间间隔，单位：毫秒）

默认值：1500

在某个节点执行相同或不同命令时，连续失败 failedAttempts（执行失败最大次数） 时，该节点将被从可用节点列表里清除，直到 reconnectionTimeout（重新连接时间间隔） 超时以后再次尝试。

password（密码）

默认值：null

用于节点身份验证的密码。

subscriptionsPerConnection（单个连接最大订阅数量）

默认值：5

每个连接的最大订阅数量。

clientName（客户端名称）

默认值：null

在Redis节点里显示的客户端名称。

sslEnableEndpointIdentification（启用SSL终端识别）

默认值：true

开启SSL终端识别能力。

sslProvider（SSL实现方式）

默认值：JDK

确定采用哪种方式（JDK或OPENSSL）来实现SSL连接。

sslTruststore（SSL信任证书库路径）

默认值：null

指定SSL信任证书库的路径。

sslTruststorePassword（SSL信任证书库密码）

默认值：null

指定SSL信任证书库的密码。

sslKeystore（SSL钥匙库路径）

默认值：null

指定SSL钥匙库的路径。

sslKeystorePassword（SSL钥匙库密码）

默认值：null

指定SSL钥匙库的密码。

1.2 通过YAML文件配置集群模式

配置集群模式可以通过指定一个YAML格式的文件来实现。以下是YAML格式的配置文件样本。文件中的字段名称必须与和对象里的字段名称相符。

clusterServersConfig:
  idleConnectionTimeout: 10000
  connectTimeout: 10000
  timeout: 3000
  retryAttempts: 3
  retryInterval: 1500
  password: null
  subscriptionsPerConnection: 5
  clientName: null
  loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
  slaveSubscriptionConnectionMinimumIdleSize: 1
  slaveSubscriptionConnectionPoolSize: 50
  slaveConnectionMinimumIdleSize: 32
  slaveConnectionPoolSize: 64
  masterConnectionMinimumIdleSize: 32
  masterConnectionPoolSize: 64
  readMode: "SLAVE"
  nodeAddresses:
  - "redis://127.0.0.1:7004"
  - "redis://127.0.0.1:7001"
  - "redis://127.0.0.1:7000"
  scanInterval: 1000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}
"transportMode":"NIO"

2、单节点设置

Redis程序的配置和架设文档在这里。Redisson的单Redis节点模式的使用方法如下： SingleServerConfig singleConfig = config.useSingleServer();

SingleServerConfig 类的设置参数如下：

address（节点地址）

可以通过的格式来指定节点地址。host:port

subscriptionConnectionMinimumIdleSize（发布和订阅连接的最小空闲连接数）

默认值：1

用于发布和订阅连接的最小保持连接数（长连接）。Redisson内部经常通过发布和订阅来实现许多功能。长期保持一定数量的发布订阅连接是必须的。

subscriptionConnectionPoolSize（发布和订阅连接池大小）

默认值：50

用于发布和订阅连接的连接池最大容量。连接池的连接数量自动弹性伸缩。

connectionMinimumIdleSize（最小空闲连接数）

默认值：32

最小保持连接数（长连接）。长期保持一定数量的连接有利于提高瞬时写入反应速度。

connectionPoolSize（连接池大小）

默认值：64

在启用该功能以后，Redisson将会监测DNS的变化情况。

dnsMonitoringInterval（DNS监测时间间隔，单位：毫秒）

默认值：5000

监测DNS的变化情况的时间间隔。

idleConnectionTimeout（连接空闲超时，单位：毫秒）

默认值：10000

connectTimeout（连接超时，单位：毫秒）

默认值：10000

同节点建立连接时的等待超时。时间单位是毫秒。

timeout（命令等待超时，单位：毫秒）

默认值：3000

等待节点回复命令的时间。该时间从命令发送成功时开始计时。

retryAttempts（命令失败重试次数）

默认值：3

retryInterval（命令重试发送时间间隔，单位：毫秒）

默认值：1500

database（数据库编号）

默认值：0

尝试连接的数据库编号。

password（密码）

默认值：null

用于节点身份验证的密码。

subscriptionsPerConnection（单个连接最大订阅数量）

默认值：5

每个连接的最大订阅数量。

clientName（客户端名称）

默认值：null

在Redis节点里显示的客户端名称。

sslEnableEndpointIdentification（启用SSL终端识别）

默认值：true

开启SSL终端识别能力。

sslProvider（SSL实现方式）

默认值：JDK

确定采用哪种方式（JDK或OPENSSL）来实现SSL连接。

sslTruststore（SSL信任证书库路径）

默认值：null

指定SSL信任证书库的路径。

sslTruststorePassword（SSL信任证书库密码）

默认值：null

指定SSL信任证书库的密码。

sslKeystore（SSL钥匙库路径）

默认值：null

指定SSL钥匙库的路径。

sslKeystorePassword（SSL钥匙库密码）

默认值：null

指定SSL钥匙库的密码。

3、程序接口调用方式

RedissonClient、RedissonReactiveClient和RedissonRxClient实例本身和Redisson提供的所有分布式对象都是线程安全的。

Redisson为每个操作都提供了自动重试策略，当某个命令执行失败时，Redisson会自动进行重试。自动重试策略可以通过修改retryAttempts（默认值：3）参数和retryInterval（默认值：1000毫秒）参数来进行优化调整。当等待时间达到retryInterval指定的时间间隔以后，将自动重试下一次。全部重试失败以后将抛出错误。

Redisson框架提供的几乎所有对象都包含了同步和异步相互匹配的方法。这些对象都可以通过RedissonClient接口获取。同时还为大部分Redisson对象提供了满足异步流处理标准的程序接口RedissonReactiveClient。除此外还提供了RxJava2规范的RedissonRxClient程序接口。

以下是关于使用RAtomicLong对象的范例：

RedissonClient client = Redisson.create(config);
RAtomicLong longObject = client.getAtomicLong('myLong');
// 同步执行方式
longObject.compareAndSet(3, 401);
// 异步执行方式
RFuture<Boolean> result = longObject.compareAndSetAsync(3, 401);

RedissonReactiveClient client = Redisson.createReactive(config);
RAtomicLongReactive longObject = client.getAtomicLong('myLong');
// 异步流执行方式
Mono<Boolean> result = longObject.compareAndSet(3, 401);
RedissonRxClient client = Redisson.createRx(config);
RAtomicLongRx longObject= client.getAtomicLong("myLong");
// RxJava2方式
Flowable<Boolean result = longObject.compareAndSet(3, 401);

3.1. 异步执行方式

几乎所有的Redisson对象都实现了一个异步接口，异步接口提供的方法名称与其同步接口的方法名称相互匹配。例如：

// RAtomicLong接口继承了RAtomicLongAsync接口
RAtomicLongAsync longObject = client.getAtomicLong("myLong");
RFuture<Boolean> future = longObject.compareAndSetAsync(1, 401);

异步执行的方法都会返回一个实现了RFuture接口的对象。该对象同时提供了java.util.concurrent.CompletionStage和java.util.concurrent.Future两个异步接口。


future.whenComplete((res, exception) -> {
    // ...
});
// 或者
future.thenAccept(res -> {
    // 处理返回
}).exceptionally(exception -> {
    // 处理错误
});

3.2. 异步流执行方式

Redisson为大多数分布式数据结构提供了满足Reactor项目的异步流处理标准的程序接口。该接口通过两种方式实现：

基于Project Reactor标准的实现方式。使用范例如下：

RedissonReactiveClient client = Redisson.createReactive(config);
RAtomicLongReactive atomicLong = client.getAtomicLong("myLong");
Mono<Boolean> cs = longObject.compareAndSet(10, 91);
Mono<Long> get = longObject.get();

Publisher<Long> getPublisher = longObject.get();

2.基于RxJava2标准的实现方式。使用范例如下：

RedissonRxClient client = Redisson.createRx(config);
RAtomicLongRx atomicLong = client.getAtomicLong("myLong");
Single<Boolean> cs = longObject.compareAndSet(10, 91);
Single<Long> get = longObject.get();

工具类：

import org.redisson.api.RLock;
import org.redisson.api.RReadWriteLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.UUID;

/**
 * Redisson 加锁
 */
@Component
public class RedissonUtil {

    @Resource
    private RedissonClient redissonClient;

    public String getKey(){
        return UUID.randomUUID().toString();
    }

	public String getKey(Class<?> tClass, Thread thread){
    	return tClass.toString() + "_" + thread.getStackTrace()[2].getMethodName();
	}
 
    public RLock getClint(String key){
        RReadWriteLock lock = redissonClient.getReadWriteLock(key);
        return lock.writeLock();
    }

    public void lock(String key) {
        this.getClint(key).lock();
    }

    public void unLock(String key) {
        this.getClint(key).unlock();
    }

}

测试用例：

@Autowired
    private RedissonClient redissonClient;

     public void contextLoads() {
        redissonClient.getBucket("hello").set("bug");
        String test = (String) redissonClient.getBucket("hello").get();
        System.out.println(test);

    }

锁实现：Redisson分布式锁

大家好，我是Doker品牌的Sinbad,欢迎点赞和评论,大家的鼓励是我们持续更新的动力！或者加微信进入技术群聊！