1.搭建集群

Linux系统的Redis各版本下载路径：https://download.redis.io/releases/，建议下载5.0以上的版本，下载后进行解压安装

（1）单机版

安装环境

  1. yum install gcc-c++ -y

关闭防火墙

  1. systemctl stop firewalld   #关闭
  2. systemctl disable firewalld  #永久关闭

解压

  1. # 进入到redis安装目录，进行解压即可
  2. cd /home/linux/redis
  3. tar -xvf redis-5.0.13.tar.gz

修改配置文件

  1. cd /home/linux/redis/redis-5.0.13/
  2. vi redis.conf

修改的地方如下

  1. bind 192.168.168.100  #绑定的ip，本机ip
  2. #requirepass redis123   #密码，可以不加

进入redis-5.0.13进行编译

  1. cd /home/linux/redis/redis-5.0.13/
  2. make
  3. cd src
  4. make install



编译成功后会有对应的src、conf等文件夹

为了方便管理，将Redis文件中的conf配置文件和常用的命令移动到统一文件中创建bin和etc文件夹

  1. cd /home/linux/redis/
  2. mkdir bin etc

将redis.conf文件移动到home/linux/redis/etc目录下，将/src下的一些文件移到bin下

  1. cd /home/linux/redis/redis-5.0.13/
  2. mv redis.conf /home/linux/redis/etc
  3. cd /home/linux/redis/redis-5.0.13/src
  4. mv redis-trib.rb mkreleasehdr.sh redis-benchmark redis-check-aof redis-check-rdb redis-cli redis-server redis-sentinel /home/redis-6.0.6/bin

启动

  1. bin/redis-server etc/redis.conf

客户端连接测试

（2）集群版

因为redis集群至少需要6台(3主3从)，为了减少工作量我们选择在一台虚拟机上来完成搭建都任务。

建立文件夹

  1. cd /home/linux/redis_cluster
  2. mkdir 7001 7002 7003 7004 7005 7006

copy文件到目录下

  1. cd redis-5.0.13/
  2. cp etc/redis.conf /home/linux/redis_cluster/7001
  3. cp etc/redis.conf /home/linux/redis_cluster/7002
  4. cp etc/redis.conf /home/linux/redis_cluster/7003
  5. cp etc/redis.conf /home/linux/redis_cluster/7004
  6. cp etc/redis.conf /home/linux/redis_cluster/7005
  7. cp etc/redis.conf /home/linux/redis_cluster/7006

修改配置文件

  1. cd /home/linux/redis_cluster/7006
  2. vi redis.conf

文件需要修改的内容如下

  1. 1）port 7001 //设置端口号
  3. 2）dir /usr/local/redis_cluster/7001/ //数据存放位置，必须要指定
  5. 3）cluster-enabled yes //启动集群模式
  7. 4）cluster-config-file nodes-7001.conf //集群节点信息文件
  9. 6）cluster-node-timeout 5000
  10. 7）appendonly yes //开启AOF模式,默认的持久化上RDB
  11. 8） appendfsync always   //可以不加

其他7002....类似修改配置文件

测试启动

  1. cd redis-5.0.13/bin
  2. redis-server /home/soft/redis_cluster/7001/redis.conf

其他的也启动

启动完之后新开窗口加入集群

创建redis集群(5.0版本以后直接使用redis-cli)

  1. redis-cli --cluster create  192.168.168.103:7001 192.168.168.103:7002 192.168.168.103:7003 192.168.168.103:7004 192.168.168.103:7005 192.168.168.103:7006 --cluster-replicas 1

//-a *** 密码 如果redis.conf中配置了密码创建集群时需要添加

2、springboot整合redis（单机、哨兵、集群）

依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.3.0.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  12.     <groupId>com.gblfy</groupId>
  13.     <artifactId>springboot2-redis</artifactId>
  14.     <version>0.0.1-SNAPSHOT</version>
  16.     <name>springboot2-redis</name>
  17.     <description>Spring Boot整合redia 单机 哨兵 集群 三种方式</description>
  19.     <properties>
  20.         <java.version>1.8</java.version>
  21.     </properties>
  23.     <dependencies>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-web</artifactId>
  27.         </dependency>
  28.         <!--redis Start-->
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-data-redis</artifactId>
  32.         </dependency>
  33.         <!-- redis lettuce 依赖commons-pool  -->
  34.         <dependency>
  35.             <groupId>org.apache.commons</groupId>
  36.             <artifactId>commons-pool2</artifactId>
  37.         </dependency>
  38.         <!--redis End-->
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-starter-test</artifactId>
  43.             <scope>test</scope>
  44.         </dependency>
  45.         <!--工具包-->
  46.         <dependency>
  47.             <groupId>org.apache.commons</groupId>
  48.             <artifactId>commons-lang3</artifactId>
  49.             <version>3.9</version>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>commons-collections</groupId>
  53.             <artifactId>commons-collections</artifactId>
  54.             <version>3.2.2</version>
  55.         </dependency>
  56.         <dependency>
  57.             <groupId>org.projectlombok</groupId>
  58.             <artifactId>lombok</artifactId>
  59.             <optional>true</optional>
  60.         </dependency>
  61.         <!--序列化-->
  62.         <dependency>
  63.             <groupId>com.google.code.gson</groupId>
  64.             <artifactId>gson</artifactId>
  65.         </dependency>
  66.     </dependencies>
  68.     <build>
  69.         <plugins>
  70.             <plugin>
  71.                 <groupId>org.springframework.boot</groupId>
  72.                 <artifactId>spring-boot-maven-plugin</artifactId>
  73.             </plugin>
  74.         </plugins>
  75.     </build>
  77. </project>

application.yml

  1. server:
  2.   port: 80
  3. spring:
  4.   profiles:
  5.     active:

（1）单机版模式

  1. spring:
  2.   redis:
  3.     host: 192.168.0.114
  4.     port: 6379
  5.     ### Redis数据库索引(默认为0)
  6.     database: 0
  7.     ### 连接超时时间（毫秒）
  8.     timeout: 60000ms
  9.     password:
  10.     lettuce:
  11.       pool:
  12.         ### 最大连接数（使用负值表示没有限制） 默认8
  13.         max-active: 8
  14.         ### 最小空闲连接  默认8
  15.         min-idle: 0
  16.         ### 连接池中的最大空闲连接 默认8
  17.         max-idle: 8
  18.         ### 连接池最大阻塞等待时间（使用负值表示没有限制）
  19.         max-wait: -1ms

(2)哨兵模式

  1. #哨兵
  2. spring:
  3.   redis:
  4.     sentinel:
  5.       master: mymaster
  6.       nodes:
  7.         - 192.168.0.114:26379
  8.         - 192.168.0.114:26380
  9.         - 192.168.0.114:26381
  10.     lettuce:
  11.       pool:
  12.         ### 最大连接数（使用负值表示没有限制） 默认8
  13.         max-active: 8
  14.         ### 最小空闲连接  默认8
  15.         min-idle: 0
  16.         ### 连接池中的最大空闲连接 默认8
  17.         max-idle: 8
  18.         ### 连接池最大阻塞等待时间（使用负值表示没有限制）
  19.         max-wait: -1ms
  20.     ### 连接超时时间（毫秒）
  21.     timeout: 60000ms
  22.     password:

(3)集群模式

  1. #集群
  2. spring:
  3.   redis:
  4.     cluster:
  5.       nodes:
  6.         - 192.168.0.114:7001
  7.         - 192.168.0.114:7002
  8.         - 192.168.0.114:7003
  9.         - 192.168.0.114:7004
  10.         - 192.168.0.114:7005
  11.         - 192.168.0.114:7006
  12.     lettuce:
  13.       pool:
  14.         ### 最大连接数（使用负值表示没有限制） 默认8
  15.         max-active: 8
  16.         ### 最小空闲连接  默认8
  17.         min-idle: 0
  18.         ### 连接池中的最大空闲连接 默认8
  19.         max-idle: 8
  20.         ### 连接池最大阻塞等待时间（使用负值表示没有限制）
  21.         max-wait: -1ms
  22.     ### 连接超时时间（毫秒）
  23.     timeout: 60000ms
  24.     password:

redis配置

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.RedisConnectionFactory;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  9. import org.springframework.data.redis.serializer.StringRedisSerializer;
  11. /**
  12.  * redis配置类
  13.  *
  14.  * @author gblfy
  15.  * @date 2020-04-19
  16.  */
  17. @Configuration
  18. public class RedisConfig {
  20.     @Bean
  21.     @SuppressWarnings("all")
  22.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  24.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
  25.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  27.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  28.         ObjectMapper objectMapper = new ObjectMapper();
  29.         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  30.         objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  31.         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
  33.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  35.         // key采用String的序列化方式
  36.         redisTemplate.setKeySerializer(stringRedisSerializer);
  37.         // hash的key也采用String的序列化方式
  38.         redisTemplate.setHashKeySerializer(stringRedisSerializer);
  39.         // valuevalue采用jackson序列化方式
  40.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  41.         // hash的value采用jackson序列化方式
  42.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  43.         //开启事务支持
  44.         redisTemplate.setEnableTransactionSupport(true);
  45.         redisTemplate.afterPropertiesSet();
  46.         return redisTemplate;
  47.     }
  48. }

redis工具类

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.data.redis.core.RedisTemplate;
  3. import org.springframework.stereotype.Component;
  4. import org.springframework.util.CollectionUtils;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Set;
  9. import java.util.concurrent.TimeUnit;
  11. /**
  12.  * Redis工具类
  13.  *
  14.  * @author gblfy
  15.  * @date 2020-04-19
  16.  */
  17. @Component
  18. public final class RedisUtils {
  20.     @Autowired
  21.     private RedisTemplate<String, Object> redisTemplate;
  23.     // =============================common============================
  25.     /**
  26.      * 指定缓存失效时间
  27.      *
  28.      * @param key  键
  29.      * @param time 时间(秒)
  30.      * @return
  31.      */
  32.     public boolean expire(String key, long time) {
  33.         try {
  34.             if (time > 0) {
  35.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  36.             }
  37.             return true;
  38.         } catch (Exception e) {
  39.             e.printStackTrace();
  40.             return false;
  41.         }
  42.     }
  44.     /**
  45.      * 根据key 获取过期时间
  46.      *
  47.      * @param key 键 不能为null
  48.      * @return 时间(秒) 返回0代表为永久有效
  49.      */
  50.     public long getExpire(String key) {
  51.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  52.     }
  54.     /**
  55.      * 判断key是否存在
  56.      *
  57.      * @param key 键
  58.      * @return true 存在 false不存在
  59.      */
  60.     public boolean hasKey(String key) {
  61.         try {
  62.             return redisTemplate.hasKey(key);
  63.         } catch (Exception e) {
  64.             e.printStackTrace();
  65.             return false;
  66.         }
  67.     }
  69.     /**
  70.      * 删除缓存
  71.      *
  72.      * @param key 可以传一个值 或多个
  73.      */
  74.     @SuppressWarnings("unchecked")
  75.     public void del(String... key) {
  76.         if (key != null && key.length > 0) {
  77.             if (key.length == 1) {
  78.                 redisTemplate.delete(key[0]);
  79.             } else {
  80.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  81.             }
  82.         }
  83.     }
  85.     // ============================String=============================
  87.     /**
  88.      * 普通缓存获取
  89.      *
  90.      * @param key 键
  91.      * @return 值
  92.      */
  93.     public Object get(String key) {
  94.         return key == null ? null : redisTemplate.opsForValue().get(key);
  95.     }
  97.     /**
  98.      * 普通缓存放入
  99.      *
  100.      * @param key   键
  101.      * @param value 值
  102.      * @return true成功 false失败
  103.      */
  104.     public boolean set(String key, Object value) {
  105.         try {
  106.             redisTemplate.opsForValue().set(key, value);
  107.             return true;
  108.         } catch (Exception e) {
  109.             e.printStackTrace();
  110.             return false;
  111.         }
  112.     }
  114.     /**
  115.      * 普通缓存放入并设置时间
  116.      *
  117.      * @param key   键
  118.      * @param value 值
  119.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  120.      * @return true成功 false 失败
  121.      */
  122.     public boolean set(String key, Object value, long time) {
  123.         try {
  124.             if (time > 0) {
  125.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  126.             } else {
  127.                 set(key, value);
  128.             }
  129.             return true;
  130.         } catch (Exception e) {
  131.             e.printStackTrace();
  132.             return false;
  133.         }
  134.     }
  136.     /**
  137.      * 递增
  138.      *
  139.      * @param key   键
  140.      * @param delta 要增加几(大于0)
  141.      * @return
  142.      */
  143.     public long incr(String key, long delta) {
  144.         if (delta < 0) {
  145.             throw new RuntimeException("递增因子必须大于0");
  146.         }
  147.         return redisTemplate.opsForValue().increment(key, delta);
  148.     }
  150.     /**
  151.      * 递减
  152.      *
  153.      * @param key   键
  154.      * @param delta 要减少几(小于0)
  155.      * @return
  156.      */
  157.     public long decr(String key, long delta) {
  158.         if (delta < 0) {
  159.             throw new RuntimeException("递减因子必须大于0");
  160.         }
  161.         return redisTemplate.opsForValue().increment(key, -delta);
  162.     }
  164.     // ================================Map=================================
  166.     /**
  167.      * HashGet
  168.      *
  169.      * @param key  键 不能为null
  170.      * @param item 项 不能为null
  171.      * @return 值
  172.      */
  173.     public Object hget(String key, String item) {
  174.         return redisTemplate.opsForHash().get(key, item);
  175.     }
  177.     /**
  178.      * 获取hashKey对应的所有键值
  179.      *
  180.      * @param key 键
  181.      * @return 对应的多个键值
  182.      */
  183.     public Map<Object, Object> hmget(String key) {
  184.         return redisTemplate.opsForHash().entries(key);
  185.     }
  187.     /**
  188.      * HashSet
  189.      *
  190.      * @param key 键
  191.      * @param map 对应多个键值
  192.      * @return true 成功 false 失败
  193.      */
  194.     public boolean hmset(String key, Map<String, Object> map) {
  195.         try {
  196.             redisTemplate.opsForHash().putAll(key, map);
  197.             return true;
  198.         } catch (Exception e) {
  199.             e.printStackTrace();
  200.             return false;
  201.         }
  202.     }
  204.     /**
  205.      * HashSet 并设置时间
  206.      *
  207.      * @param key  键
  208.      * @param map  对应多个键值
  209.      * @param time 时间(秒)
  210.      * @return true成功 false失败
  211.      */
  212.     public boolean hmset(String key, Map<String, Object> map, long time) {
  213.         try {
  214.             redisTemplate.opsForHash().putAll(key, map);
  215.             if (time > 0) {
  216.                 expire(key, time);
  217.             }
  218.             return true;
  219.         } catch (Exception e) {
  220.             e.printStackTrace();
  221.             return false;
  222.         }
  223.     }
  225.     /**
  226.      * 向一张hash表中放入数据,如果不存在将创建
  227.      *
  228.      * @param key   键
  229.      * @param item  项
  230.      * @param value 值
  231.      * @return true 成功 false失败
  232.      */
  233.     public boolean hset(String key, String item, Object value) {
  234.         try {
  235.             redisTemplate.opsForHash().put(key, item, value);
  236.             return true;
  237.         } catch (Exception e) {
  238.             e.printStackTrace();
  239.             return false;
  240.         }
  241.     }
  243.     /**
  244.      * 向一张hash表中放入数据,如果不存在将创建
  245.      *
  246.      * @param key   键
  247.      * @param item  项
  248.      * @param value 值
  249.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  250.      * @return true 成功 false失败
  251.      */
  252.     public boolean hset(String key, String item, Object value, long time) {
  253.         try {
  254.             redisTemplate.opsForHash().put(key, item, value);
  255.             if (time > 0) {
  256.                 expire(key, time);
  257.             }
  258.             return true;
  259.         } catch (Exception e) {
  260.             e.printStackTrace();
  261.             return false;
  262.         }
  263.     }
  265.     /**
  266.      * 删除hash表中的值
  267.      *
  268.      * @param key  键 不能为null
  269.      * @param item 项 可以使多个 不能为null
  270.      */
  271.     public void hdel(String key, Object... item) {
  272.         redisTemplate.opsForHash().delete(key, item);
  273.     }
  275.     /**
  276.      * 判断hash表中是否有该项的值
  277.      *
  278.      * @param key  键 不能为null
  279.      * @param item 项 不能为null
  280.      * @return true 存在 false不存在
  281.      */
  282.     public boolean hHasKey(String key, String item) {
  283.         return redisTemplate.opsForHash().hasKey(key, item);
  284.     }
  286.     /**
  287.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  288.      *
  289.      * @param key  键
  290.      * @param item 项
  291.      * @param by   要增加几(大于0)
  292.      * @return
  293.      */
  294.     public double hincr(String key, String item, double by) {
  295.         return redisTemplate.opsForHash().increment(key, item, by);
  296.     }
  298.     /**
  299.      * hash递减
  300.      *
  301.      * @param key  键
  302.      * @param item 项
  303.      * @param by   要减少记(小于0)
  304.      * @return
  305.      */
  306.     public double hdecr(String key, String item, double by) {
  307.         return redisTemplate.opsForHash().increment(key, item, -by);
  308.     }
  310.     // ============================set=============================
  312.     /**
  313.      * 根据key获取Set中的所有值
  314.      *
  315.      * @param key 键
  316.      * @return
  317.      */
  318.     public Set<Object> sGet(String key) {
  319.         try {
  320.             return redisTemplate.opsForSet().members(key);
  321.         } catch (Exception e) {
  322.             e.printStackTrace();
  323.             return null;
  324.         }
  325.     }
  327.     /**
  328.      * 根据value从一个set中查询,是否存在
  329.      *
  330.      * @param key   键
  331.      * @param value 值
  332.      * @return true 存在 false不存在
  333.      */
  334.     public boolean sHasKey(String key, Object value) {
  335.         try {
  336.             return redisTemplate.opsForSet().isMember(key, value);
  337.         } catch (Exception e) {
  338.             e.printStackTrace();
  339.             return false;
  340.         }
  341.     }
  343.     /**
  344.      * 将数据放入set缓存
  345.      *
  346.      * @param key    键
  347.      * @param values 值 可以是多个
  348.      * @return 成功个数
  349.      */
  350.     public long sSet(String key, Object... values) {
  351.         try {
  352.             return redisTemplate.opsForSet().add(key, values);
  353.         } catch (Exception e) {
  354.             e.printStackTrace();
  355.             return 0;
  356.         }
  357.     }
  359.     /**
  360.      * 将set数据放入缓存
  361.      *
  362.      * @param key    键
  363.      * @param time   时间(秒)
  364.      * @param values 值 可以是多个
  365.      * @return 成功个数
  366.      */
  367.     public long sSetAndTime(String key, long time, Object... values) {
  368.         try {
  369.             Long count = redisTemplate.opsForSet().add(key, values);
  370.             if (time > 0)
  371.                 expire(key, time);
  372.             return count;
  373.         } catch (Exception e) {
  374.             e.printStackTrace();
  375.             return 0;
  376.         }
  377.     }
  379.     /**
  380.      * 获取set缓存的长度
  381.      *
  382.      * @param key 键
  383.      * @return
  384.      */
  385.     public long sGetSetSize(String key) {
  386.         try {
  387.             return redisTemplate.opsForSet().size(key);
  388.         } catch (Exception e) {
  389.             e.printStackTrace();
  390.             return 0;
  391.         }
  392.     }
  394.     /**
  395.      * 移除值为value的
  396.      *
  397.      * @param key    键
  398.      * @param values 值 可以是多个
  399.      * @return 移除的个数
  400.      */
  401.     public long setRemove(String key, Object... values) {
  402.         try {
  403.             Long count = redisTemplate.opsForSet().remove(key, values);
  404.             return count;
  405.         } catch (Exception e) {
  406.             e.printStackTrace();
  407.             return 0;
  408.         }
  409.     }
  411.     // ===============================list=================================
  413.     /**
  414.      * 获取list缓存的内容
  415.      *
  416.      * @param key   键
  417.      * @param start 开始
  418.      * @param end   结束 0 到 -1代表所有值
  419.      * @return
  420.      */
  421.     public List<Object> lGet(String key, long start, long end) {
  422.         try {
  423.             return redisTemplate.opsForList().range(key, start, end);
  424.         } catch (Exception e) {
  425.             e.printStackTrace();
  426.             return null;
  427.         }
  428.     }
  430.     /**
  431.      * 获取list缓存的长度
  432.      *
  433.      * @param key 键
  434.      * @return
  435.      */
  436.     public long lGetListSize(String key) {
  437.         try {
  438.             return redisTemplate.opsForList().size(key);
  439.         } catch (Exception e) {
  440.             e.printStackTrace();
  441.             return 0;
  442.         }
  443.     }
  445.     /**
  446.      * 通过索引 获取list中的值
  447.      *
  448.      * @param key   键
  449.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  450.      * @return
  451.      */
  452.     public Object lGetIndex(String key, long index) {
  453.         try {
  454.             return redisTemplate.opsForList().index(key, index);
  455.         } catch (Exception e) {
  456.             e.printStackTrace();
  457.             return null;
  458.         }
  459.     }
  461.     /**
  462.      * 将list放入缓存
  463.      *
  464.      * @param key   键
  465.      * @param value 值
  466.      * @param time  时间(秒)
  467.      * @return
  468.      */
  469.     public boolean lSet(String key, Object value) {
  470.         try {
  471.             redisTemplate.opsForList().rightPush(key, value);
  472.             return true;
  473.         } catch (Exception e) {
  474.             e.printStackTrace();
  475.             return false;
  476.         }
  477.     }
  479.     /**
  480.      * 将list放入缓存
  481.      *
  482.      * @param key   键
  483.      * @param value 值
  484.      * @param time  时间(秒)
  485.      * @return
  486.      */
  487.     public boolean lSet(String key, Object value, long time) {
  488.         try {
  489.             redisTemplate.opsForList().rightPush(key, value);
  490.             if (time > 0)
  491.                 expire(key, time);
  492.             return true;
  493.         } catch (Exception e) {
  494.             e.printStackTrace();
  495.             return false;
  496.         }
  497.     }
  499.     /**
  500.      * 将list放入缓存
  501.      *
  502.      * @param key   键
  503.      * @param value 值
  504.      * @param time  时间(秒)
  505.      * @return
  506.      */
  507.     public boolean lSet(String key, List<Object> value) {
  508.         try {
  509.             redisTemplate.opsForList().rightPushAll(key, value);
  510.             return true;
  511.         } catch (Exception e) {
  512.             e.printStackTrace();
  513.             return false;
  514.         }
  515.     }
  517.     /**
  518.      * 将list放入缓存
  519.      *
  520.      * @param key   键
  521.      * @param value 值
  522.      * @param time  时间(秒)
  523.      * @return
  524.      */
  525.     public boolean lSet(String key, List<Object> value, long time) {
  526.         try {
  527.             redisTemplate.opsForList().rightPushAll(key, value);
  528.             if (time > 0)
  529.                 expire(key, time);
  530.             return true;
  531.         } catch (Exception e) {
  532.             e.printStackTrace();
  533.             return false;
  534.         }
  535.     }
  537.     /**
  538.      * 根据索引修改list中的某条数据
  539.      *
  540.      * @param key   键
  541.      * @param index 索引
  542.      * @param value 值
  543.      * @return
  544.      */
  545.     public boolean lUpdateIndex(String key, long index, Object value) {
  546.         try {
  547.             redisTemplate.opsForList().set(key, index, value);
  548.             return true;
  549.         } catch (Exception e) {
  550.             e.printStackTrace();
  551.             return false;
  552.         }
  553.     }
  555.     /**
  556.      * 移除N个值为value
  557.      *
  558.      * @param key   键
  559.      * @param count 移除多少个
  560.      * @param value 值
  561.      * @return 移除的个数
  562.      */
  563.     public long lRemove(String key, long count, Object value) {
  564.         try {
  565.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  566.             return remove;
  567.         } catch (Exception e) {
  568.             e.printStackTrace();
  569.             return 0;
  570.         }
  571.     }
  572. }

源码参考：​https://gitee.com/gb_90/SpringBoot2_Practical_Column​

3、整合redisson

参考：https://blog.csdn.net/qq_27579471/article/details/103921489

redisson优势

提供了看门狗

Redisson提供了一个监控锁的看门狗（watch dog），它的作用是在Redisson实例被关闭前，不断(默认每10s)的延长锁(redis中的目标key)的有效期(默认续期到30s)，也就是说，如果一个拿到锁的线程一直没有完成逻辑，那么看门狗会帮助线程不断的延长锁的超时时间，锁不会因为超时而被释放。加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s内自动过期，不会产生死锁问题；

默认情况下，看门狗的续期时间是30s，也可以通过修改Config.lockWatchdogTimeout来另行指定。

另外Redisson还提供了可以指定leaseTime参数的加锁方法来指定加锁的时间。超过这个时间后锁便自动解开了，不会延长锁的有效期。

提供了多种锁

redisson 还有公平锁、读写锁的实现。

  1. public interface RedissonClient {
  2. 	/**
  3. 	 * 获取锁（默认的非公平锁）
  4. 	 */
  5. 	RLock getLock(String name);
  7. 	/**
  8. 	 * 获取公平锁
  9. 	 */
  10. 	RLock getFairLock(String name);
  12. 	/**
  13. 	 * 获取读写锁
  14. 	 */
  15. 	RReadWriteLock getReadWriteLock(String name);
  16. }
  1. public interface RLock extends Lock, RExpirable, RLockAsync {
  2. 	void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException;
  4. 	boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;
  6. 	void lock(long leaseTime, TimeUnit unit);
  8. 	boolean forceUnlock();
  10. 	boolean isLocked();
  12. 	boolean isHeldByCurrentThread();
  14. 	int getHoldCount();
  15. }

添加依赖,注意redisson和springboot的版本对应

  1.      <dependency>
  2.             <groupId>org.redisson</groupId>
  3.             <artifactId>redisson-spring-boot-starter</artifactId>
  4.             <version>3.15.0</version>
  6.   </dependency>

分析源码

redisson-spring-boot-starter这个包下只有2个类：RedissonProperties和RedissonAutoConfiguration。阅读源码发现RedissonAutoConfiguration会自动注册RedissonConnectionFactory和RedissonClient。



redisson-spring-boot-starter支持三种配置方式

方式一：完全兼容spring-boot-starter-data-redis的配置，即只需在application.yml中使用spring.redis来配置redis，redisson-spring-boot-starter会根据Redis的配置自动配置redisson。（已测试可行）

方式二：redisson的spring.redis.redisson.file方式，即在application.yml中使用spring.redis.redisson.file=classpath:redisson.yml来指定redisson的配置文件路径，然后在redisson.yml中配置redisson。

方式三：redisson的spring.redis.redisson.config方式，即在application.yml中使用spring.redis.redisson.config=xxx来直接配置Redisson。

多种方式的优先级：spring.redis.redisson.config > spring.redis.redisson.file> spring.redis。详细参考org.redisson.spring.starter.RedissonAutoConfiguration#redisson()。

简单使用

配置了redis和redisson的信息之后，就可以在项目中使用@Autowired注入org.redisson.api.RedissonClient（redisson提供的默认实现类是org.redisson.Redisson，且redisson-spring-boot-starter会自动往IOC容器中注册org.redisson.Redisson）。

Redis操作注入RedisTemplate进行使用。

Redission分布式锁可以引入RedissionClient进行使用。

  1. @RestController
  2. public class RedissonController {
  4.     @Autowired
  5.     private RedissonClient redissonClient;
  7.     @GetMapping(value = "/redisson/{key}")
  8.     public String redissonTest(@PathVariable("key") String lockKey) {
  9.         RLock lock = redissonClient.getLock(lockKey);
  10.         try {
  11.             lock.lock();
  12.             Thread.sleep(10000);
  13.         } catch (Exception e) {
  15.         } finally {
  16.             lock.unlock();
  17.         }
  18.         return "已解锁";
  19.     }
  20. }

优化一下 封装redissonClient

  1. package com.xx.core.redisson.lock;
  3. /**
  4.  * Redisson分布式锁接口
  5.  * <p>
  6.  * RLock的实现有可重入非公平锁（RedissonLock）、可重入公平锁（RedissonFairLock）、联锁（RedissonMultiLock）、 红锁（RedissonRedLock）、 读锁（RedissonReadLock）、 写锁（RedissonWriteLock）等
  7.  */
  8. public interface DistributedLocker {
  9.     RLock lock(String lockKey);
  11.     RLock lock(String lockKey, long timeout);
  13.     RLock lock(String lockKey, TimeUnit unit, long timeout);
  15.     boolean tryLock(String lockKey, TimeUnit unit, long leaseTime);
  17.     boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime);
  19.     void unlock(String lockKey);
  21.     void unlock(RLock lock);
  22. }
  1. /**
  2.  * Redisson分布式锁实现-使用可重入非公平锁（RedissonLock）
  3.  */
  4. @Component
  5. public class RedissonDistributedLocker implements DistributedLocker {
  6. 	@Autowired
  7.     private RedissonClient redissonClient;
  9. 	public RLock lock(String lockKey) {
  10.         RLock lock = this.redissonClient.getLock(lockKey);
  11.         lock.lock();
  12.         return lock;
  13.     }
  15. 	public RLock lock(String lockKey, long timeout) {
  16.         RLock lock = this.redissonClient.getLock(lockKey);
  17.         lock.lock(timeout, TimeUnit.SECONDS);
  18.         return lock;
  19.     }
  21. 	public RLock lock(String lockKey, TimeUnit unit, long timeout) {
  22.         RLock lock = this.redissonClient.getLock(lockKey);
  23.         lock.lock(timeout, unit);
  24.         return lock;
  25.     }
  27. 	public boolean tryLock(String lockKey, TimeUnit unit, long leaseTime) {
  28.         RLock lock = this.redissonClient.getLock(lockKey);
  29.         try {
  30.             return lock.tryLock(0L, leaseTime, unit);
  31.         } catch (InterruptedException var7) {
  32.             return false;
  33.         }
  34.     }
  36. 	public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime){
  37. 		RLock lock = redissonClient.getLock(lockKey);
  38. 		try {
  39. 	    	return lock.tryLock(waitTime, leaseTime, unit);
  40. 	    } catch (InterruptedException e) {
  41. 			return false;
  42. 		}
  43. 	}
  45. 	public void unlock(String lockKey){
  46. 	    RLock lock = redissonClient.getLock(lockKey);
  47. 	    try {
  48. 	        if (lock.isLocked()) {
  49. 	            lock.unlock();
  50. 	        }
  51. 	    } catch (IllegalMonitorStateException localIllegalMonitorStateException) {}
  52. 	}
  54. 	public void unlock(RLock lock) {
  55.         try {
  56.             if (lock.isLocked()) {
  57.                 lock.unlock();
  58.             }
  59.         } catch (IllegalMonitorStateException var3) {}
  60.     }
  61. }

再优化一下，使用函数式DistributedLocker 接口新增tryLockAndRun()方法

  1. public interface DistributedLocker {
  2. 	/**
  3.      * @param lockKey
  4.      * @param unit
  5.      * @param waitTime
  6.      * @param leaseTime
  7.      * @param supplier 获取锁后要执行的业务逻辑
  8.      * @param scene 业务逻辑的场景，用于打印日志
  9.      * @param <T>
  10.      * @return
  11.      */
  12.     <T> T tryLockAndRun(@Nonnull String lockKey, @Nonnull TimeUnit unit, long waitTime, long leaseTime, @Nonnull Supplier<T> supplier, String scene);
  13. }
  1. public class RedissonDistributedLocker implements DistributedLocker {
  2. 	@Override
  3.     public <T> T tryLockAndRun(@Nonnull String lockKey, @Nonnull TimeUnit unit, long waitTime, long leaseTime, @Nonnull Supplier<T> supplier, String scene) {
  4.         final long start = SystemClock.now();
  5.         // 获取分布式锁，最长等待时间:10秒,20秒后自动释放。注意锁与事务的顺序：获取分布式锁 -> 开启事务 -> 执行业务 -> 提交事务 -> 释放分布式锁！！！
  6.         final boolean tryLock = this.tryLock(lockKey, unit, waitTime, leaseTime);
  7.         final long end = SystemClock.now();
  8.         if (!tryLock) {
  9.             log.error("[{}]获取分布式锁失败，lockKey = {}，耗时{}ms", scene, lockKey, end - start);
  10.             throw new RequestResultException(JsonCommonCodeEnum.E0004);
  11.         }
  13.         // 注意：一定是获取锁成功后，才进行try{}finally{释放锁}
  14.         try {
  15.         	log.info("[{}]获取分布式锁成功，lockKey = {}，耗时{}ms", scene, lockKey, end - start);
  16.             return supplier.get();
  17.         } finally {
  18.             this.unlock(lockKey);
  19.         }
  20.     }
  21. }

4、问题处理

redis单机、主从、哨兵、集群以及redisson分布式锁的更多相关文章

  1. Redis主从&哨兵集群搭建

    主从集群 在搭建主从集群前,我们先把Redis安装起来: #解压Redis压缩包 [root@master lf]# tar -zxvf redis-6.2.1.tar.gz -- #安装gcc [r ...

  2. C#两大知名Redis客户端连接哨兵集群的姿势

    前言 前面利用<Docker-Compose搭建Redis高可用哨兵集群>, 我们的思路是将Redis.Sentinel.Redis Client App链接到同一个网桥网络,这个网桥内的 ...

  3. 阿里云ECS部署Redis主备哨兵集群遇到的问题

    一.部署 详细部署步骤:https://blog.csdn.net/lihongtai/article/details/82826809 Redis5.0版本需要注意的参数配置:https://www ...

  4. 三千字介绍Redis主从+哨兵+集群

    一.Redis持久化策略 1.RDB 每隔几分钟或者一段时间会将redis内存中的数据全量的写入到一个文件中去. 优点: 因为他是每隔一段时间的全量备份,代表了每个时间段的数据.所以适合做冷备份. R ...

  5. 【Redis学习专题】- Redis主从+哨兵集群部署

    集群版本: redis-4.0.14 集群节点: 节点角色 IP redis-master 10.100.8.21 redis-slave1 10.100.8.22 redis-slave2 10.1 ...

  6. 项目实战11—企业级nosql数据库应用与实战-redis的主从和集群

    企业级nosql数据库应用与实战-redis 环境背景:随着互联网2.0时代的发展,越来越多的公司更加注重用户体验和互动,这些公司的平台上会出现越来越多方便用户操作和选择的新功能,如优惠券发放.抢红包 ...

  7. Redis集合 安装 哨兵集群 配置

    redis相关 redis基础 redis发布订阅 redis持久化RDB与AOF redis不重启,切换RDB备份到AOF备份 redis安全配置 redis主从同步 redis哨兵集群 redis ...

  8. redis系列--深入哨兵集群

    一.前言 在之前的系列文章中介绍了redis的入门.持久化以及复制功能,如果不了解请移步至redis系列进行阅读,当然我也是抱着学习的知识分享,如果有什么问题欢迎指正,也欢迎大家转载.而本次将介绍哨兵 ...

  9. Redis单机安装以及集群搭建

    今天主要来看一下Redis的安装以及集群搭建(我也是第一次搭建). 环境:CentOS 7.1,redis-5.0.7 一.单机安装 1.将Redis安装包放置服务器并解压 2.进入redis安装目录 ...

  10. redis 单机模拟 cluster集群

    一.redis-cluster设计 Redis集群搭建的方式有多种,例如使用zookeeper等,但从redis 3.0之后版本支持redis-cluster集群,Redis-Cluster采用无中心 ...

随机推荐

  1. Lombok注解及其作用

    Lombok是一个Java库,通过使用注解简化Java类的开发,减少冗余的样板代码.以下是一些常用的Lombok注解及其作用: 1. `@Data`:生成所有属性的getter.setter.`toS ...

  2. Java工具类Result＜T＞

    枚举类:ResultCodeEnum /** * 统一返回结果状态信息类 * */ @Getter public enum ResultCodeEnum { SUCCESS(200,"成功& ...

  3. 00.XML入门

    0.了解XML Extensible Markup Language 可扩展标记语言 申明信息不算元素,左图中book为根元素,根元素有且仅有一个; 1.初识XML 1.3用IDE创建xml(以ecl ...

  4. 白帽子讲web安全

    世界安全观 Web安全筒史 起初,研究计算机系统和网络的人,被称为"Hacker","Hacker"在中国按照音译,被称为"黑客" 对于现代 ...

  5. P3498 [POI2010]KOR-Beads 题解

    前言: 最近在做哈希的题,发现了这道好题,看题解里很多大佬的方法都很巧妙,自己就发一个较为朴素的方法吧. 题意: 题目传送门 给你一个序列,需要求出数 k,使划分的子串长度为 k 时,不同的子串数量最 ...

  6. 聊聊 ASP.NET 6 整洁架构开发模板

    大家好,我是Edison. 最近看了一些整洁架构(CleanArchitecture)的文章,自己和同事也简单写了一个基于整洁架构的ASP.NET 6开发模板在玩.这里就仅仅抛个砖,案例主要以自己根据 ...

  7. Mysql 5.7 的安装

    Mysql的安装 1 windows两种安装方式,入门选手推荐第二种(win10演示) Mysql官网下载地址:https://dev.mysql.com/downloads/mysql/ 2 开始准 ...

  8. Linux下日志管理工具Logrotate

    背景: 项目上的Nginx和Tomcat已经跑了大半年了,Nginx的access.log和error.log将近1G大小:Tomcat下的catalina.out日志经常跑到打不出日志然后进行手动移 ...

  9. Prometheus-3：一文详解promQL

    读前提示: 本文字数较多且紧凑,最好预留15min一次性看完,好营养,易吸收. promQL详解 Prometheus提供了内置的数据查询语言PromQL(全称为Prometheus Query La ...

  10. 「学习笔记」KMP 算法

    前置知识 前缀 是指从串首开始到某个位置 \(i\) 结束的一个特殊子串. 真前缀 指除了 \(S\) 本身的 \(S\) 的前缀. 举例来说, 字符串 abcabeda 的所有前缀为 {a, ab, ...