IT评测·应用市场-qidao123.com技术社区

标题: Jedis、RedisTemplate、Redisson 详解和实例 [打印本页]
作者: 千千梦丶琪    时间: 2024-7-17 02:33
标题: Jedis、RedisTemplate、Redisson 详解和实例

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类

  1. Jedis父类BinaryJedis所依赖的接口：
  2.     BasicCommands:
  3.         提供基础的查询命令,如ping,quit,flushdb
  4.     BinaryJedisCommands:
  5.         提供了针对redis数据结构的CURD等操作,其中参数(K-V)必须以byte数组形式提供
  6.     MultiKeyBinaryCommands:
  7.         提供了针对redis数据结构的CURD等批量操作,其中参数(K-V)必须以byte数组形式提供
  8.     AdvancedBinaryJedisCommands:
  9.         提供高级操作redis的命令,如config相关,slowlog,client等命令,其中参数(K-V)必须以byte数组形式提供
  10.     BinaryScriptingCommands:
  11.         提供Lua脚本运行命令,命令必须以byte数组形式提供。
  12. Jedis所依赖的接口：
  13.     JedisCommands:
  14.         提供了针对redis数据结构的CURD等操作,其中参数(K-V)必须以String形式提供
  15.     MultiKeyCommands:
  16.         提供了针对redis数据结构的CURD等批量操作,其中参数(K-V)必须以String数组形式提供
  17.     AdvancedJedisCommands:
  18.         提供高级操作redis的命令,如config相关,slowlog,client等命令,其中参数(K-V)必须以String形式提供
  19.     ScriptingCommands:
  20.         提供Lua脚本运行命令,命令必须以String形式提供。
  21.     BasicCommands:
  22.         提供如ping,quit,flushDb运维类命令
  23.     ClusterCommands:
  24.         提供集群状态查看,集群操作的命令
  25.     SentinelCommands:
  26.         提供哨兵操作命令
  27.     ModuleCommands:
  28.         提供redis模块加载和卸载命令
复制代码
引入pom:
  1. <dependency>
  2.     <groupId>redis.clients</groupId>
  3.     <artifactId>jedis</artifactId>
  4.     <version>2.9.0</version>
  5.     <type>jar</type>
  6.     <scope>compile</scope>
  7. </dependency>
复制代码
 yml文件配置：
  1.   redis:
  2.     host: 127.21.55.48
  3.     port: 6398
  4.     password: 88888
  5.     jedis:
  6.      pool:
  7.         #最大连接数
  8.         max-active: 8
  9.         #最大阻塞等待时间(负数表示没限制)
  10.         max-wait: -1
  11.         #最大空闲
  12.         max-idle: 8
  13.         #最小空闲
  14.         min-idle: 0
  15.         #连接超时时间
  16.     timeout: 10000
复制代码
2、基本用法示例

2.1 在多线程环境中使用 Jedis

您不应该使用来自差别线程的同一实例，因为会出现奇怪的错误。有时创建大量Jedis实例还不敷好，因为这意味着大量的套接字和连接，这也会导致奇怪的错误。单个Jedis实例不是线程安全的！为了避免这些问题，您应该使用JedisPool，这是一个线程安全的网络连接池。如果完成后将Jedis实例返回到池中，则可以使用池可靠地创建多个Jedis示例。通过这种方式，您可以克服这些奇怪的错误并获得出色的性能。
要使用它，请初始化池：
  1. JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
复制代码
您可以将池静态存储在某个位置，它是线程安全的。
JedisPoolConfig 包罗许多有效的 Redis 特定连接池默认值。JedisPool基于Commons Pool 2，以是你大概想看看Commons Pool的配置。
您可以通过以下方式使用它：
  1. /// Jedis implements Closeable. Hence, the jedis instance will be auto-closed after the last statement.
  2. try (Jedis jedis = pool.getResource()) {
  3.   /// ... do stuff here ... for example
  4.   jedis.set("foo", "bar");
  5.   String foobar = jedis.get("foo");
  6.   jedis.zadd("sose", 0, "car"); jedis.zadd("sose", 0, "bike");
  7.   Set<String> sose = jedis.zrange("sose", 0, -1);
  8. }
  9. /// ... when closing your application:
  10. pool.close();
复制代码
如果您不能在资源中使用try，您仍然可以使用Jedis.close（）。
  1. Jedis jedis = null;
  2. try {
  3.   jedis = pool.getResource();
  4.   /// ... do stuff here ... for example
  5.   jedis.set("foo", "bar");
  6.   String foobar = jedis.get("foo");
  7.   jedis.zadd("sose", 0, "car"); jedis.zadd("sose", 0, "bike");
  8.   Set<String> sose = jedis.zrange("sose", 0, -1);
  9. } finally {
  10.   // You have to close jedis object. If you don't close then
  11.   // it doesn't release back to pool and you can't get a new
  12.   // resource from pool.
  13.   if (jedis != null) {
  14.     jedis.close();
  15.   }
  16. }
  17. /// ... when closing your application:
  18. pool.close();
复制代码
若Jedis是从池中借用的，那个么它将使用精确的方法返回到池中，因为它已经确定发生了JedisConnectionException。若Jedis不是从池中借来的，它将被断开并关闭。
2.1 设置主/从分配

启用复制
Redis 重要用于主/从分发。这意味着写入哀求必须显式发送到主服务器（redis 服务器），后者将更改复制到从服务器（也是 redis 服务器）。然后，读取哀求可以（但不一定）发送给从站，从而减轻了主站的负担。
您可以使用主控外形，如上所示。为了启用复制，有两种方法可以告诉从站它将是给定主服务器的“slaveOf”：

  1. jedis.slaveof("localhost", 6379);  //  if the master is on the same PC which runs your code
  2. jedis.slaveof("192.168.1.35", 6379);
复制代码
注意：由于默认环境下Redis 2.6从装备是只读的，因此对它们的写入哀求将导致错误。
如果您更改该设置，它们的行为将与正常的redis服务器一样，并担当写入哀求而不会出错，但这些更改不会被复制，因此，如果您混淆了jedis实例，这些更改大概会被冷静覆盖。
禁用复制/主服务器出现故障时，升级从属服务器
万一你的主人倒下了，你大概想提拔一个仆从成为新的主人。您应该首先（实验）首先禁用脱机主服务器的复制，然后，如果您有多个从站，请启用剩余从站到新主站的复制：
  1. slave1jedis.slaveofNoOne();
  2. 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:
  1. <dependency>
  2.     <groupId>org.projectlombok</groupId>
  3.     <artifactId>lombok</artifactId>
  4.     <optional>true</optional>
  5. </dependency>
  6. <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-data-redis</artifactId>
  9. </dependency>
  10. <dependency>
  11.     <groupId>com.alibaba</groupId>
  12.     <artifactId>fastjson</artifactId>
  13.     <version>1.2.3</version>
  14. </dependency>
复制代码
yml文件配置：
  1. redis:
  2.     host: 192.168.159.133
  3.     port: 6379
  4.     database: 0
  5.     jedis:
  6.       pool:
  7.         max-active: 10
  8.         max-idle: 5
  9.         min-idle: 0
  10.         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检察聚集中是否存在指定命据  
示例代码：
  1. @Autowired
  2.     RedisTemplate redisTemplate;
  4.     /**
  5.      * 指定key的失效时间
  6.      */
  7.     @GetMapping("expire")
  8.     public void expire(String key, long time) {
  9.         //参数一：key
  10.         //参数二：睡眠时间
  11.         //参数三：睡眠时间单位 TimeUnit.DAYS 天 TimeUnit.HOURS 小时 。。。
  12.         redisTemplate.expire(key, time, TimeUnit.MINUTES);
  13.     }
  15.     /**
  16.      * 根据key获取过期时间
  17.      */
  18.     @GetMapping("getexpire")
  19.     public long getExpire(String key) {
  20.         Long expire = redisTemplate.getExpire(key);
  21.         return expire;
  22.     }
  24.     /**
  25.      * 判断key是否存在
  26.      */
  27.     @GetMapping("haskey")
  28.     public boolean hasKey(String key) {
  29.         return redisTemplate.hasKey(key);
  30.     }
  32.     /**
  33.      * 根据key删除reids中缓存数据
  34.      */
  35.     @GetMapping("delredisbykey")
  36.     public void delete(String key) {
  37.         redisTemplate.delete(key);
  38.     }
  40.     /**
  41.      * 保存和读取String
  42.      */
  43.     @GetMapping("stringredisdemo")
  44.     public String stringredisdemo() {
  45.         //设置过期时间为1分钟
  46.         redisTemplate.opsForValue().set("key1", "value1", 1, TimeUnit.MINUTES);
  47.         redisTemplate.opsForValue().set("key2", "value2");
  48.         redisTemplate.opsForValue().set("key3", "value3");
  49.         //读取redis数据
  50.         String result1 = redisTemplate.opsForValue().get("key1").toString();
  51.         String result2 = redisTemplate.opsForValue().get("key2").toString();
  52.         String result3 = redisTemplate.opsForValue().get("key3").toString();
  53.         System.out.println("缓存结果为：result：" + result1 + "  " + result2 + "   " + result3);
  54.         return "缓存结果为：result：" + result1 + "  " + result2 + "   " + result3;
  55.     }
  57.     /**
  58.      * 保存和读取list
  59.      */
  60.     @GetMapping("listredisdemo")
  61.     public String listredisdemo() {
  62.         List<String> list1 = new ArrayList<>();
  63.         list1.add("a1");
  64.         list1.add("a2");
  65.         list1.add("a3");
  66.         List<String> list2 = new ArrayList<>();
  67.         list2.add("b1");
  68.         list2.add("b2");
  69.         list2.add("b3");
  70.         redisTemplate.opsForList().leftPush("listkey1", list1);
  71.         redisTemplate.opsForList().rightPush("listkey2", list2);
  72.         List<String> resultList1 = (List<String>) redisTemplate.opsForList().leftPop("listkey1");
  73.         List<String> resultList2 = (List<String>) redisTemplate.opsForList().rightPop("listkey2");
  74.         System.out.println("resultList1:" + resultList1);
  75.         System.out.println("resultList2:" + resultList2);
  76.         return "成功";
  77.     }
  79.     /**
  80.      * Hash结构，保存和读取map
  81.      */
  82.     @GetMapping("mapredisdemo")
  83.     public String mapredisdemo() {
  84.         Map<String, String> map = new HashMap<>();
  85.         map.put("key1", "value1");
  86.         map.put("key2", "value2");
  87.         map.put("key3", "value3");
  88.         redisTemplate.opsForHash().putAll("map1", map);
  89.         Map<String, String> resultMap = redisTemplate.opsForHash().entries("map1");
  90.         List<String> reslutMapList = redisTemplate.opsForHash().values("map1");
  91.         Set<String> resultMapSet = redisTemplate.opsForHash().keys("map1");
  92.         String value = (String) redisTemplate.opsForHash().get("map1", "key1");
  93.         System.out.println("value:" + value);
  94.         System.out.println("resultMapSet:" + resultMapSet);
  95.         System.out.println("resultMap:" + resultMap);
  96.         System.out.println("resulreslutMapListtMap:" + reslutMapList);
  97.         return "成功";
  98.     }
  100.     /**
  101.      * 保存和读取Set
  102.      */
  103.     @GetMapping("setredisdemo")
  104.     public String getredisdemo() {
  105.         SetOperations<String, String> set = redisTemplate.opsForSet();
  106.         set.add("key1", "value1");
  107.         set.add("key1", "value2");
  108.         set.add("key1", "value3");
  109.         Set<String> resultSet = redisTemplate.opsForSet().members("key1");
  110.         System.out.println("resultSet:" + resultSet);
  111.         return "resultSet:" + resultSet;
  112.     }
  114.     /**
  115.      * 保存和读取zset
  116.      */
  117.     @GetMapping("zsetredisdemo")
  118.     public String zsetredisdemo() {
  119.         ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5", 9.6);
  120.         ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6", 9.9);
  121.         Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
  122.         tuples.add(objectTypedTuple1);
  123.         tuples.add(objectTypedTuple2);
  124.         System.out.println(redisTemplate.opsForZSet().add("zset1", tuples));
  125.         System.out.println(redisTemplate.opsForZSet().range("zset1", 0, -1));
  126.         return "成功";
  127.     }
复制代码
三、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:
  1. <dependency>
  2.     <groupId>org.redisson</groupId>
  3.     <artifactId>redisson</artifactId>
  4.     <version>3.12.3</version>
  5. </dependency>
复制代码
单Redis节点模式 ：
Redisson步伐化的配置方法是通过构建Config对象实例来实现的。比方：
  2. Config config = new Config();
  3. config.setTransportMode(TransportMode.EPOLL); // 默认是NIO的方式
  4. config.useClusterServers()
  5.       //可以用"rediss://"来启用SSL连接，前缀必须是redis:// or rediss://
  6.       .addNodeAddress("redis://127.0.0.1:7181");
复制代码
Redisson的配置文件可以是或YAML格式。 也通过调用config.fromYAML方法并指定一个File实例来实现读取YAML格式的配置：
  1. Config config = Config.fromYAML(new File("config-file.yaml"));
  2. RedissonClient redisson = Redisson.create(config);
复制代码
1、集群模式 

1.1 集群模式配置：

  1. Config config = new Config();
  2. config.useClusterServers()
  3.     .setScanInterval(2000) // 集群状态扫描间隔时间，单位是毫秒
  4.     //可以用"rediss://"来启用SSL连接
  5.     .addNodeAddress("redis://127.0.0.1:7000", "redis://127.0.0.1:7001")
  6.     .addNodeAddress("redis://127.0.0.1:7002");
  8. RedissonClient redisson = Redisson.create(config);
复制代码
 集群设置： 
聚集连接模式由以下行激活：
  1. 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格式的配置文件样本。文件中的字段名称必须与和对象里的字段名称相符。
  1. clusterServersConfig:
  2.   idleConnectionTimeout: 10000
  3.   connectTimeout: 10000
  4.   timeout: 3000
  5.   retryAttempts: 3
  6.   retryInterval: 1500
  7.   password: null
  8.   subscriptionsPerConnection: 5
  9.   clientName: null
  10.   loadBalancer: !<org.redisson.connection.balancer.RoundRobinLoadBalancer> {}
  11.   slaveSubscriptionConnectionMinimumIdleSize: 1
  12.   slaveSubscriptionConnectionPoolSize: 50
  13.   slaveConnectionMinimumIdleSize: 32
  14.   slaveConnectionPoolSize: 64
  15.   masterConnectionMinimumIdleSize: 32
  16.   masterConnectionPoolSize: 64
  17.   readMode: "SLAVE"
  18.   nodeAddresses:
  19.   - "redis://127.0.0.1:7004"
  20.   - "redis://127.0.0.1:7001"
  21.   - "redis://127.0.0.1:7000"
  22.   scanInterval: 1000
  23. threads: 0
  24. nettyThreads: 0
  25. codec: !<org.redisson.codec.JsonJacksonCodec> {}
  26. "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
如果实验达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。如果实验在此限定之内发送成功，则开始启用 timeout（命令等待超时） 计时。
retryInterval（命令重试发送时间间隔，单位：毫秒）
默认值：1500
在某个节点执行相同或差别命令时，连续 失败 failedAttempts（执行失败最大次数） 时，该节点将被从可用节点列表里清除，直到 reconnectionTimeout（重新连接时间间隔） 超时以后再次实验。
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对象的范例：
  1. RedissonClient client = Redisson.create(config);
  2. RAtomicLong longObject = client.getAtomicLong('myLong');
  3. // 同步执行方式
  4. longObject.compareAndSet(3, 401);
  5. // 异步执行方式
  6. RFuture<Boolean> result = longObject.compareAndSetAsync(3, 401);
  8. RedissonReactiveClient client = Redisson.createReactive(config);
  9. RAtomicLongReactive longObject = client.getAtomicLong('myLong');
  10. // 异步流执行方式
  11. Mono<Boolean> result = longObject.compareAndSet(3, 401);
  12. RedissonRxClient client = Redisson.createRx(config);
  13. RAtomicLongRx longObject= client.getAtomicLong("myLong");
  14. // RxJava2方式
  15. Flowable<Boolean result = longObject.compareAndSet(3, 401);
复制代码
3.1. 异步执行方式

险些所有的Redisson对象都实现了一个异步接口，异步接口提供的方法名称与其同步接口的方法名称相互匹配。比方：
  1. // RAtomicLong接口继承了RAtomicLongAsync接口
  2. RAtomicLongAsync longObject = client.getAtomicLong("myLong");
  3. RFuture<Boolean> future = longObject.compareAndSetAsync(1, 401);
复制代码
异步执行的方法都会返回一个实现了RFuture接口的对象。该对象同时提供了java.util.concurrent.CompletionStage和java.util.concurrent.Future两个异步接口。
  2. future.whenComplete((res, exception) -> {
  3.     // ...
  4. });
  5. // 或者
  6. future.thenAccept(res -> {
  7.     // 处理返回
  8. }).exceptionally(exception -> {
  9.     // 处理错误
  10. });
复制代码
3.2. 异步流执行方式

Redisson为大多数分布式数据结构提供了满足Reactor项目的异步流处理处罚尺度的步伐接口。该接口通过两种方式实现：
  1. RedissonReactiveClient client = Redisson.createReactive(config);
  2. RAtomicLongReactive atomicLong = client.getAtomicLong("myLong");
  3. Mono<Boolean> cs = longObject.compareAndSet(10, 91);
  4. Mono<Long> get = longObject.get();
  6. Publisher<Long> getPublisher = longObject.get();
复制代码
 2.基于RxJava2尺度的实现方式。使用范比方下：
  1. RedissonRxClient client = Redisson.createRx(config);
  2. RAtomicLongRx atomicLong = client.getAtomicLong("myLong");
  3. Single<Boolean> cs = longObject.compareAndSet(10, 91);
  4. Single<Long> get = longObject.get();
复制代码
工具类：
  1. import org.redisson.api.RLock;
  2. import org.redisson.api.RReadWriteLock;
  3. import org.redisson.api.RedissonClient;
  4. import org.springframework.stereotype.Component;
  5. import javax.annotation.Resource;
  6. import java.util.UUID;
  8. /**
  9. * Redisson 加锁
  10. */
  11. @Component
  12. public class RedissonUtil {
  14.     @Resource
  15.     private RedissonClient redissonClient;
  17.     public String getKey(){
  18.         return UUID.randomUUID().toString();
  19.     }
  21.         public String getKey(Class<?> tClass, Thread thread){
  22.             return tClass.toString() + "_" + thread.getStackTrace()[2].getMethodName();
  23.         }
  25.     public RLock getClint(String key){
  26.         RReadWriteLock lock = redissonClient.getReadWriteLock(key);
  27.         return lock.writeLock();
  28.     }
  30.     public void lock(String key) {
  31.         this.getClint(key).lock();
  32.     }
  34.     public void unLock(String key) {
  35.         this.getClint(key).unlock();
  36.     }
  38. }
复制代码
 测试用例：
  1. @Autowired
  2.     private RedissonClient redissonClient;
  4.      public void contextLoads() {
  5.         redissonClient.getBucket("hello").set("bug");
  6.         String test = (String) redissonClient.getBucket("hello").get();
  7.         System.out.println(test);
  9.     }
复制代码
锁实现：Redisson分布式锁

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/) Powered by Discuz! X3.4