devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot中集成Redis详解_springboot集成redis主从架构

作者：秋刀鱼在做梦 | 2024-07-01 11:31:02

赞

踩

springboot集成redis主从架构

一、Redis 介绍

1、什么是 Redis

Redis（Remote Dictionary Server）是一个开源的高性能键值对存储数据库，属于非关系型数据库（NoSQL）。它通过在内存中存储数据来提供快速的读写访问，并使用磁盘持久化来保证数据的可靠性。

Redis 提供了丰富的数据结构支持，包括字符串（String）、哈希（Hash）、列表（List）、集合（Set）、有序集合（Sorted Set）等。这些数据结构非常灵活，能够满足各种实际应用场景的需求。

2、Redis 的主要特点包括

  1. 快速读写：Redis 的数据都存储在内存中，使得它具有非常高的读写性能。它还使用了一些优化技术，如异步和多线程，以提高性能。

  2. 持久化：Redis 提供了两种方式来持久化数据，即快照（snapshot）和日志（append-only file）。快照是将数据写入磁盘，而日志则是记录每个写操作，用以恢复数据。

  3. 分布式：Redis 支持分布式部署，可以通过集群（Cluster）、主从复制（Master-Slave）等方式来扩展容量和提高可用性。

  4. 数据类型丰富：除了基本的键值对存储，Redis 还提供了丰富的数据结构，如哈希（Hash）、列表（List）、集合（Set）、有序集合（Sorted Set）等，使得它能够适应各种不同的数据需求。

  5. 支持事务：Redis 支持事务操作，允许一系列命令按顺序执行，并且在执行期间不会被其他客户端的命令打断。

  6. 可扩展性：Redis 可以通过增加更多的节点来扩展容量和吞吐量，以满足大规模业务的需求。

Redis 可以用于广泛的应用场景，如缓存、消息队列、计数器、排行榜、实时发布/订阅等。其简单、高效和灵活的特性使其成为流行的数据存储解决方案。

3、Redis 的应用场景

  • 排行榜

  • 计数器

  • 限速器

  • 分布式锁

  • 分布式会话

  • 热点数据缓存

4、Redis 与其它 Key-Value 的区别

  • Redis 支持数据的备份，即 master - slave 模式的数据备份。

  • Redis 支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。

  • Redis 不仅仅支持简单的 key - value 类型的数据，同时还提供 list、set、zset、hash 等数据结构的存储。

二、SpringBoot 操作 Redis

1、Maven 引入相关依赖

引入 SpringBoot 和 Redis 依赖，由于 SpringBoot 2.x + 版本后是用 lettuce 作为连接池，所以需要引入 commons-pool2 依赖。

  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.  
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>2.3.4.RELEASE</version>
  10.     </parent>
  11.  
  12.     <groupId>com.demo</groupId>
  13.     <artifactId>springboot-redis-example</artifactId>
  14.     <version>0.0.1</version>
  15.     <name>springboot-redis-example</name>
  16.     <description>Demo project for Spring Boot Redis</description>
  17.  
  18.     <properties>
  19.         <java.version>1.8</java.version>
  20.     </properties>
  21.  
  22.     <dependencies>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-data-redis</artifactId>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.apache.commons</groupId>
  33.             <artifactId>commons-pool2</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.projectlombok</groupId>
  37.             <artifactId>lombok</artifactId>
  38.         </dependency>
  39.     </dependencies>
  40.  
  41.     <build>
  42.         <plugins>
  43.             <plugin>
  44.                 <groupId>org.springframework.boot</groupId>
  45.                 <artifactId>spring-boot-maven-plugin</artifactId>
  46.             </plugin>
  47.         </plugins>
  48.     </build>
  49.  
  50. </project>

2、配置文件中添加相关参数

Redis 有多重部署方式，所以连接 Redis 又有多种方式，下面介绍下如何配置 单机、哨兵、集群 的连接参数，需要将这些参数配置到 SpringBoot 的 application 配置文件中。

Redis 单机配置：

  1. spring:
  2.   redis:
  3.     database: 0             #数据库
  4.     ssl: false              #是否开启ssl
  5.     timeout: 1000           #超时时间，单位为毫秒
  6.     host: 127.0.0.1         #Reids主机地址
  7.     port: 6379              #Redis端口号
  8.     lettuce:                #使用 lettuce 连接池
  9.       pool:
  10.         max-active: 20      #连接池最大连接数（使用负值表示没有限制）
  11.         max-wait: -1        #连接池最大阻塞等待时间（使用负值表示没有限制）
  12.         min-idle: 0         #连接池中的最大空闲连接
  13.         max-idle: 10        #连接池中的最小空闲连接

Redis 哨兵配置： 

  1. spring:
  2.   redis:
  3.     sentinel:                 #哨兵配置
  4.       master: my-master       #Redis服务器名称
  5.       nodes:                  #Redis哨兵地址
  6.         - 192.168.2.11:6379
  7.         - 192.168.2.12:6379
  8.         - 192.168.2.13:6379
  9.     database: 0               #Redis 索引（0~15，默认为0）
  10.     timeout: 1000             #Redis 连接的超时时间
  11.     password: 123456          #Redis 密码，如果没有就默认不配置此参数  
  12.     lettuce:                  #使用 lettuce 连接池
  13.       pool:
  14.         max-active: 20        #连接池最大连接数（使用负值表示没有限制）
  15.         max-wait: -1          #连接池最大阻塞等待时间（使用负值表示没有限制）
  16.         min-idle: 0           #连接池中的最大空闲连接
  17.         max-idle: 10          #连接池中的最小空闲连接

Redis 集群配置：

  1. spring:
  2.   redis:
  3.     database: 0               #Redis 索引（0~15，默认为0）
  4.     timeout: 1000             #Redis 连接的超时时间
  5.     password: 123456          #Redis 密码，如果没有就默认不配置此参数  
  6.     cluster:                  #Redis 集群配置
  7.       max-redirects: 5        #Redis 命令执行时最多转发次数    
  8.       nodes:                  #Redis 集群地址  
  9.         - 192.168.2.11:6379
  10.         - 192.168.2.12:6379
  11.         - 192.168.2.13:6379
  12.         - 192.168.2.11:6380
  13.         - 192.168.2.12:6380
  14.         - 192.168.2.13:6380
  15.     lettuce:                  #使用 lettuce 连接池
  16.       pool:
  17.         max-active: 20        #连接池最大连接数（使用负值表示没有限制）
  18.         max-wait: -1          #连接池最大阻塞等待时间（使用负值表示没有限制）
  19.         min-idle: 0           #连接池中的最大空闲连接
  20.         max-idle: 10          #连接池中的最小空闲连接

3、配置 RedisTemplate 中序列化参数

在 RedisTemplate 默认是使用的 Java 字符串序列化，该序列化存入 Redis 并不能够提供可读性，比较流行的做法是替换成 Jackson 序列化，以 JSON 方式进行存储。

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.data.redis.connection.RedisConnectionFactory;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.data.redis.serializer.*;
  6.  
  7. /**
  8.  * Redis 配置
  9.  */
  10. @Configuration
  11. public class RedisConfig {
  12.  
  13.     /**
  14.      * Redis 序列化配置
  15.      */
  16.     @Bean
  17.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
  18.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  19.         redisTemplate.setConnectionFactory(connectionFactory);
  20.         // 使用GenericJackson2JsonRedisSerializer替换默认序列化
  21.         GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  22.         // 设置 Key 和 Value 的序列化规则
  23.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  24.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  25.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  26.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  27.         // 初始化 RedisTemplate 序列化完成
  28.         redisTemplate.afterPropertiesSet();
  29.         return redisTemplate;
  30.     }
  31.  
  32. }

4、使用 RedisTemplate 操作 Redis

Redis 基本操作

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.connection.DataType;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.stereotype.Service;
  6. import java.util.Arrays;
  7. import java.util.concurrent.TimeUnit;
  8.  
  9. @Slf4j
  10. @Service
  11. public class RedisBase {
  12.  
  13.     @Autowired
  14.     private RedisTemplate<String, Object> redisTemplate;
  15.  
  16.     /**
  17.      * 指定 key 的过期时间
  18.      *
  19.      * @param key  键
  20.      * @param time 时间(秒)
  21.      */
  22.     public void expire(String key, long time) {
  23.         redisTemplate.expire(key, time, TimeUnit.SECONDS);
  24.     }
  25.  
  26.     /**
  27.      * 根据 key 获取过期时间（-1 即为永不过期）
  28.      *
  29.      * @param key 键
  30.      * @return 过期时间
  31.      */
  32.     public Long ttl(String key) {
  33.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  34.     }
  35.  
  36.  
  37.     /**
  38.      * 判断 key 是否存在
  39.      *
  40.      * @param key 键
  41.      * @return 如果存在 key 则返回 true，否则返回 false
  42.      */
  43.     public Boolean exists(String key) {
  44.         return redisTemplate.hasKey(key);
  45.     }
  46.  
  47.     /**
  48.      * 删除 key
  49.      *
  50.      * @param key 键
  51.      */
  52.     public Long del(String... key) {
  53.         if (key == null || key.length < 1) {
  54.             return 0L;
  55.         }
  56.         return redisTemplate.delete(Arrays.asList(key));
  57.     }
  58.  
  59.     /**
  60.      * 获取 Key 的类型
  61.      *
  62.      * @param key 键
  63.      */
  64.     public String type(String key) {
  65.         DataType dataType = redisTemplate.type(key);
  66.         assert dataType != null;
  67.         return dataType.code();
  68.     }
  69.  
  70. }

Redis 批量操作

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.stereotype.Service;
  5. import java.util.List;
  6. import java.util.Map;
  7.  
  8. @Slf4j
  9. @Service
  10. public class RedisBatch {
  11.  
  12.     @Autowired
  13.     private RedisTemplate<String, Object> redisTemplate;
  14.  
  15.     /**
  16.      * 批量设置值
  17.      *
  18.      * @param map 要插入的 key value 集合
  19.      */
  20.     public void barchSet(Map<String, Object> map) {
  21.         redisTemplate.opsForValue().multiSet(map);
  22.     }
  23.  
  24.     /**
  25.      * 批量获取值
  26.      *
  27.      * @param list 查询的 Key 列表
  28.      * @return value 列表
  29.      */
  30.     public List<Object> batchGet(List<String> list) {
  31.         return redisTemplate.opsForValue().multiGet(list);
  32.     }
  33.  
  34. }

Redis 字符串操作

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.stereotype.Service;
  5. import java.util.Collection;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.concurrent.TimeUnit;
  9.  
  10. @Slf4j
  11. @Service
  12. public class RedisString {
  13.  
  14.     @Autowired
  15.     private RedisTemplate<String, Object> redisTemplate;
  16.  
  17.     /**
  18.      * 获取指定 key 的值
  19.      *
  20.      * @param key 键
  21.      * @return 返回 key 的值
  22.      */
  23.     public Object get(String key) {
  24.         return redisTemplate.opsForValue().get(key);
  25.     }
  26.  
  27.     /**
  28.      * 获取所有一个或多个给定 key 的值
  29.      *
  30.      * @param list Key 集合
  31.      * @return 值集合
  32.      */
  33.     public List<Object> mGet(Collection<String> list) {
  34.         return redisTemplate.opsForValue().multiGet(list);
  35.     }
  36.  
  37.     /**
  38.      * 设置给定 key 的值（如果 key 已经存在就覆写旧值）
  39.      *
  40.      * @param key   键
  41.      * @param value 值
  42.      */
  43.     public void set(String key, Object value) {
  44.         redisTemplate.opsForValue().set(key, value);
  45.     }
  46.  
  47.     /**
  48.      * 同时设置一个或多个 key-value 对
  49.      *
  50.      * @param map 键值集合
  51.      */
  52.     public void set(Map<String, Object> map) {
  53.         redisTemplate.opsForValue().multiSet(map);
  54.     }
  55.  
  56.     /**
  57.      * 设置给定 key 的值，并设置过期时间
  58.      *
  59.      * @param key   键
  60.      * @param value 值
  61.      * @param time  过期时间(秒)
  62.      */
  63.     public void set(String key, Object value, long time) {
  64.         if (time > 0) {
  65.             redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  66.         } else {
  67.             set(key, value);
  68.         }
  69.     }
  70.  
  71.     /**
  72.      * 递增
  73.      *
  74.      * @param key   键
  75.      * @param delta 要增加几(大于0)
  76.      * @return 递增后的值
  77.      */
  78.     public Long incr(String key, long delta) {
  79.         if (delta > 0) {
  80.             throw new IllegalArgumentException("递减因子必须大于0");
  81.         }
  82.         return redisTemplate.opsForValue().increment(key, delta);
  83.     }
  84.  
  85.     /**
  86.      * 递减
  87.      *
  88.      * @param key   键
  89.      * @param delta 要减少几(小于0)
  90.      * @return 递减后的值
  91.      */
  92.     public Long decr(String key, long delta) {
  93.         if (delta < 0) {
  94.             throw new IllegalArgumentException("递减因子必须小于0");
  95.         }
  96.         return redisTemplate.opsForValue().increment(key, -delta);
  97.     }
  98.  
  99. }

Redis 哈希操作

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.stereotype.Service;
  5. import java.util.Map;
  6.  
  7. @Slf4j
  8. @Service
  9. public class RedisHash {
  10.  
  11.     @Autowired
  12.     private RedisTemplate<String, Object> redisTemplate;
  13.  
  14.     @Autowired
  15.     private RedisBase redisBase;
  16.  
  17.     /**
  18.      * 获取存储在哈希表中指定字段的值
  19.      *
  20.      * @param key  键
  21.      * @param item 项
  22.      * @return 值
  23.      */
  24.     public Object hGet(String key, String item) {
  25.         return redisTemplate.opsForHash().get(key, item);
  26.     }
  27.  
  28.     /**
  29.      * 将哈希表 key 中的字段 field 的值设为 value（如果不存在将创建）
  30.      *
  31.      * @param key   键
  32.      * @param item  项
  33.      * @param value 值
  34.      */
  35.     public void hSet(String key, String item, Object value) {
  36.         redisTemplate.opsForHash().put(key, item, value);
  37.     }
  38.  
  39.     /**
  40.      * 将哈希表 key 中的字段 field 的值设为 value，并设置过期时间
  41.      * （如果不存在将创建，且如果已存在的hash表有时间,这里将会替换原有的时间）
  42.      *
  43.      * @param key   键
  44.      * @param item  项
  45.      * @param value 值
  46.      * @param time  时间（秒）
  47.      */
  48.     public void hSet(String key, String item, Object value, long time) {
  49.         redisTemplate.opsForHash().put(key, item, value);
  50.         if (time > 0) {
  51.             redisBase.expire(key, time);
  52.         }
  53.     }
  54.  
  55.     /**
  56.      * 获取所有给定字段的值
  57.      *
  58.      * @param key 键
  59.      * @return 一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样
  60.      */
  61.     public Map<Object, Object> hmGet(String key) {
  62.         return redisTemplate.opsForHash().entries(key);
  63.     }
  64.  
  65.     /**
  66.      * 同时将多个“域-值”对设置到哈希表 key 中
  67.      *
  68.      * @param key 键
  69.      * @param map 对应多个键值
  70.      */
  71.     public void hmSet(String key, Map<String, Object> map) {
  72.         redisTemplate.opsForHash().putAll(key, map);
  73.     }
  74.  
  75.     /**
  76.      * 同时将多个“域-值”对设置到哈希表 key 中，并设置过期时间
  77.      *
  78.      * @param key  键
  79.      * @param map  对应多个键值
  80.      * @param time 时间（秒）
  81.      */
  82.     public void hmSet(String key, Map<String, Object> map, long time) {
  83.         redisTemplate.opsForHash().putAll(key, map);
  84.         if (time > 0) {
  85.             redisBase.expire(key, time);
  86.         }
  87.     }
  88.  
  89.     /**
  90.      * 删除一个或多个哈希表字段
  91.      *
  92.      * @param key  键
  93.      * @param item 项（可以使多个）
  94.      * @return 成功删除字段的数量
  95.      */
  96.     public Long hDel(String key, Object... item) {
  97.         return redisTemplate.opsForHash().delete(key, item);
  98.     }
  99.  
  100.     /**
  101.      * 查看哈希表 key 中，指定的字段是否存在
  102.      *
  103.      * @param key  键 不能为null
  104.      * @param item 项 不能为null
  105.      * @return 如果存在则返回 true，不存在则返回 false
  106.      */
  107.     public Boolean hExists(String key, String item) {
  108.         return redisTemplate.opsForHash().hasKey(key, item);
  109.     }
  110.  
  111.     /**
  112.      * 哈希证书递增或递减数（正数递增、负数递减），如果不存在,就会创建一个，并把新增后的值返回
  113.      *
  114.      * @param key  键
  115.      * @param item 项
  116.      * @param by   增加或减少的数
  117.      * @return 执行操作后，哈希表中字段的值
  118.      */
  119.     public Double hIncrby(String key, String item, double by) {
  120.         return redisTemplate.opsForHash().increment(key, item, by);
  121.     }
  122.  
  123. }

Redis 列表操作

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.stereotype.Service;
  5. import java.util.List;
  6.  
  7. @Slf4j
  8. @Service
  9. public class RedisList {
  10.  
  11.     @Autowired
  12.     private RedisTemplate<String, Object> redisTemplate;
  13.  
  14.     @Autowired
  15.     private RedisBase redisBase;
  16.  
  17.     /**
  18.      * 获取列表指定范围内的元素，正数则表示正向查找，负数则倒叙查找
  19.      *
  20.      * @param key   键
  21.      * @param start 开始
  22.      * @param end   结束
  23.      * @return boolean
  24.      * @see <a href="https://redis.io/commands/lrange">Redis Documentation: LRANGE</a>
  25.      */
  26.     public List<Object> lRange(String key, long start, long end) {
  27.         return redisTemplate.opsForList().range(key, start, end);
  28.     }
  29.  
  30.     /**
  31.      * 获取列表长度
  32.      *
  33.      * @param key 键
  34.      * @return 列表长度
  35.      */
  36.     public Long lLen(String key) {
  37.         return redisTemplate.opsForList().size(key);
  38.     }
  39.  
  40.     /**
  41.      * 通过索引获取列表中的元素
  42.      *
  43.      * @param key   键
  44.      * @param index 索引（index>=0时，0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推）
  45.      * @return 列表中的元素
  46.      */
  47.     public Object lIndex(String key, long index) {
  48.         return redisTemplate.opsForList().index(key, index);
  49.     }
  50.  
  51.     /**
  52.      * 在列表前端添加一个值
  53.      *
  54.      * @param key   键
  55.      * @param value 值
  56.      * @return 返回列表当前长度
  57.      */
  58.     public Long lPush(String key, Object value) {
  59.         return redisTemplate.opsForList().rightPush(key, value);
  60.     }
  61.  
  62.     /**
  63.      * 在列表前端添加一个值，并设置过期时间
  64.      *
  65.      * @param key   键
  66.      * @param value 值
  67.      * @param time  时间（秒）
  68.      * @return 返回列表当前长度
  69.      */
  70.     public Long lPush(String key, Object value, long time) {
  71.         Long size = redisTemplate.opsForList().leftPush(key, value);
  72.         if (time > 0) {
  73.             redisBase.expire(key, time);
  74.         }
  75.         return size;
  76.     }
  77.  
  78.     /**
  79.      * 在列表前端添加多个值
  80.      *
  81.      * @param key   键
  82.      * @param value 值
  83.      * @return 返回列表当前长度
  84.      */
  85.     public Long lPush(String key, List<Object> value) {
  86.         return redisTemplate.opsForList().leftPushAll(key, value);
  87.     }
  88.  
  89.     /**
  90.      * 在列表前端添加多个值，并设置过期时间
  91.      *
  92.      * @param key   键
  93.      * @param value 值
  94.      * @param time  时间（秒）
  95.      * @return 返回列表当前长度
  96.      */
  97.     public Long lPush(String key, List<Object> value, long time) {
  98.         Long size = redisTemplate.opsForList().leftPushAll(key, value);
  99.         if (time > 0) {
  100.             redisBase.expire(key, time);
  101.         }
  102.         return size;
  103.     }
  104.  
  105.     /**
  106.      * 在列末尾端添加一个值
  107.      *
  108.      * @param key   键
  109.      * @param value 值
  110.      * @return 返回列表当前长度
  111.      */
  112.     public Long rPush(String key, Object value) {
  113.         return redisTemplate.opsForList().rightPush(key, value);
  114.     }
  115.  
  116.     /**
  117.      * 在列表末尾添加一个值，并设置过期时间
  118.      *
  119.      * @param key   键
  120.      * @param value 值
  121.      * @param time  时间（秒）
  122.      * @return 返回列表当前长度
  123.      */
  124.     public Long rPush(String key, Object value, long time) {
  125.         Long size = redisTemplate.opsForList().leftPush(key, value);
  126.         if (time > 0) {
  127.             redisBase.expire(key, time);
  128.         }
  129.         return size;
  130.     }
  131.  
  132.     /**
  133.      * 在列表末尾添加多个值
  134.      *
  135.      * @param key   键
  136.      * @param value 值
  137.      * @return 返回列表当前长度
  138.      */
  139.     public Long rPush(String key, List<Object> value) {
  140.         return redisTemplate.opsForList().rightPushAll(key, value);
  141.     }
  142.  
  143.     /**
  144.      * 在列表末尾添加多个值，并设置过期时间
  145.      *
  146.      * @param key   键
  147.      * @param value 值
  148.      * @param time  时间（秒）
  149.      * @return 返回列表当前长度
  150.      */
  151.     public Long rPush(String key, List<Object> value, long time) {
  152.         Long size = redisTemplate.opsForList().rightPushAll(key, value);
  153.         if (time > 0) {
  154.             redisBase.expire(key, time);
  155.         }
  156.         return size;
  157.     }
  158.  
  159.     /**
  160.      * 通过索引设置列表元素的值
  161.      *
  162.      * @param key   键
  163.      * @param index 索引
  164.      * @param value 值
  165.      */
  166.     public void lSet(String key, long index, Object value) {
  167.         redisTemplate.opsForList().set(key, index, value);
  168.     }
  169.  
  170.     /**
  171.      * 移除列表元素
  172.      *
  173.      * @param key   键
  174.      * @param count 移除数量（"负数"则从列表倒叙查找删除 count 个对应的值; "整数"则从列表正序查找删除 count 个对应的值;）
  175.      * @param value 值
  176.      * @return 成功移除的个数
  177.      */
  178.     public Long lRem(String key, long count, Object value) {
  179.         return redisTemplate.opsForList().remove(key, count, value);
  180.     }
  181.  
  182. }

Redis 集合操作

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.stereotype.Service;
  5. import java.util.Set;
  6.  
  7. @Slf4j
  8. @Service
  9. public class RedisSet {
  10.  
  11.     @Autowired
  12.     private RedisTemplate<String, Object> redisTemplate;
  13.  
  14.     @Autowired
  15.     private RedisBase redisBase;
  16.  
  17.     /**
  18.      * 返回集合中的所有成员
  19.      *
  20.      * @param key 键
  21.      * @return 集合中的所有成员
  22.      */
  23.     public Set<Object> sMembers(String key) {
  24.         return redisTemplate.opsForSet().members(key);
  25.     }
  26.  
  27.     /**
  28.      * 判断 member 元素是否是集合 key 的成员
  29.      *
  30.      * @param key   键
  31.      * @param value 值
  32.      * @return 如果存在则返回 true 否则返回 false
  33.      */
  34.     public Boolean sisMember(String key, Object value) {
  35.         return redisTemplate.opsForSet().isMember(key, value);
  36.     }
  37.  
  38.     /**
  39.      * 向集合添加一个或多个成员
  40.      *
  41.      * @param key    键
  42.      * @param values 值
  43.      * @return 添加成功元素的个数
  44.      */
  45.     public Long sAdd(String key, Object... values) {
  46.         return redisTemplate.opsForSet().add(key, values);
  47.     }
  48.  
  49.     /**
  50.      * 向集合添加一个或多个成员，并设置过期时间
  51.      *
  52.      * @param key    键
  53.      * @param time   时间（秒）
  54.      * @param values 值（可以是多个）
  55.      * @return 添加成功元素的个数
  56.      */
  57.     public Long sAdd(String key, long time, Object... values) {
  58.         Long count = redisTemplate.opsForSet().add(key, values);
  59.         if (time > 0) {
  60.             redisBase.expire(key, time);
  61.         }
  62.         return count;
  63.     }
  64.  
  65.     /**
  66.      * 获取集合的成员数
  67.      *
  68.      * @param key 键
  69.      * @return 返回集合中元素的数量
  70.      */
  71.     public Long sCard(String key) {
  72.         return redisTemplate.opsForSet().size(key);
  73.     }
  74.  
  75.     /**
  76.      * 移除集合中一个或多个成员
  77.      *
  78.      * @param key    键
  79.      * @param values 值 可以是多个
  80.      * @return 移除的个数
  81.      */
  82.     public Long sRem(String key, Object... values) {
  83.         return redisTemplate.opsForSet().remove(key, values);
  84.     }
  85.  
  86. }

Redis 有序集合操作

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.data.redis.core.RedisTemplate;
  4. import org.springframework.data.redis.core.ZSetOperations;
  5. import org.springframework.stereotype.Service;
  6. import java.util.Set;
  7.  
  8. @Slf4j
  9. @Service
  10. public class RedisSortSet {
  11.  
  12.     @Autowired
  13.     private RedisTemplate<String, Object> redisTemplate;
  14.  
  15.     /**
  16.      * 向有序集合添加成员
  17.      *
  18.      * @param key   键
  19.      * @param value 值
  20.      * @param score 分数
  21.      * @return 添加成功元素的个数
  22.      */
  23.     public Boolean zAdd(String key, Object value, double score) {
  24.         return redisTemplate.opsForZSet().add(key, value, score);
  25.     }
  26.  
  27.     /**
  28.      * 向有序集合添加多个成员
  29.      *
  30.      * @param key 键
  31.      * @param set 值
  32.      * @return 添加成功元素的个数
  33.      */
  34.     public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> set) {
  35.         return redisTemplate.opsForZSet().add(key, set);
  36.     }
  37.  
  38.     /**
  39.      * 移除有序集合中的一个或多个成员
  40.      *
  41.      * @param key    键
  42.      * @param values 值
  43.      */
  44.     public Long zRem(String key, Object... values) {
  45.         return redisTemplate.opsForZSet().remove(key, values);
  46.     }
  47.  
  48.     /**
  49.      * 有序集合操作分数的加/减
  50.      *
  51.      * @param key   键
  52.      * @param value 值
  53.      * @param score 分数
  54.      * @return 成员的新分数值
  55.      */
  56.     public Double zincrby(String key, String value, double score) {
  57.         return redisTemplate.opsForZSet().incrementScore(key, value, score);
  58.     }
  59.  
  60.     /**
  61.      * 返回有序集中，成员的分数值
  62.      *
  63.      * @param key   键
  64.      * @param value 值
  65.      * @return 成员的分数值
  66.      */
  67.     public Double zScore(String key, String value) {
  68.         return redisTemplate.opsForZSet().score(key, value);
  69.     }
  70.  
  71.     /**
  72.      * 返回有序集合中指定成员的索引
  73.      *
  74.      * @param key   键
  75.      * @param value 值
  76.      * @return 成员的索引
  77.      */
  78.     public Long zRank(String key, String value) {
  79.         return redisTemplate.opsForZSet().rank(key, value);
  80.     }
  81.  
  82.     /**
  83.      * 获取有序集合的成员数（集合长度）
  84.      *
  85.      * @param key 键
  86.      * @return 成员总数
  87.      */
  88.     public Long zCard(String key) {
  89.         return redisTemplate.opsForZSet().zCard(key);
  90.     }
  91.  
  92.     /**
  93.      * 通过索引区间返回有序集合指定区间内的成员（按分数从小到大排序）
  94.      *
  95.      * @param key   键
  96.      * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
  97.      * @param end   结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
  98.      * @return 指定区间内，带有分数值(可选)的有序集成员的列表
  99.      */
  100.     public Set<Object> zrange(String key, int start, int end) {
  101.         return redisTemplate.opsForZSet().range(key, start, end);
  102.     }
  103.  
  104.     /**
  105.      * 通过索引区间返回有序集合指定区间内的成员 & 分数
  106.      *
  107.      * @param key   键
  108.      * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
  109.      * @param end   结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
  110.      * @return 指定区间内，带有分数值(可选)的有序集成员的列表
  111.      */
  112.     public Set<ZSetOperations.TypedTuple<Object>> zRange(String key, int start, int end) {
  113.         return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
  114.     }
  115.  
  116.     /**
  117.      * 返回有序集中指定区间内的成员，通过索引，分数从高到低
  118.      *
  119.      * @param key   键
  120.      * @param start 开始
  121.      * @param end   结束
  122.      * @return 指定区间内的成员
  123.      */
  124.     public Set<Object> zRevRange(String key, int start, int end) {
  125.         return redisTemplate.opsForZSet().reverseRange(key, start, end);
  126.     }
  127.  
  128.     /**
  129.      * 通过分数返回有序集合指定区间内的成员
  130.      *
  131.      * @param key 键
  132.      * @param min 最小
  133.      * @param max 最大
  134.      * @return 指定区间内的成员
  135.      */
  136.     public Set<Object> zRangeByScore(String key, int min, int max) {
  137.         return redisTemplate.opsForZSet().rangeByScore(key, min, max);
  138.     }
  139.  
  140. }

5、Redis 操作 Controller

这里写个简单的 Controller 类，简单的调用 Redis 字符串服务操作，内容如下：

  1. import com.example.service.RedisBatch;
  2. import com.example.service.RedisString;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.web.bind.annotation.GetMapping;
  5. import org.springframework.web.bind.annotation.RequestParam;
  6. import org.springframework.web.bind.annotation.RestController;
  7. import java.util.ArrayList;
  8. import java.util.HashMap;
  9. import java.util.List;
  10. import java.util.Map;
  11.  
  12. @RestController
  13. public class RedisController {
  14.  
  15.     @Autowired
  16.     private RedisBatch redisBatch;
  17.  
  18.     @Autowired
  19.     private RedisString redisString;
  20.  
  21.     /**
  22.      * 存值
  23.      *
  24.      * @param key   键
  25.      * @param value 值
  26.      * @return 存储结果
  27.      */
  28.     @GetMapping("/set")
  29.     public String redisStringSet(@RequestParam String key, @RequestParam String value) {
  30.         redisString.set(key, value);
  31.         return "存储成功";
  32.     }
  33.  
  34.     /**
  35.      * 取值
  36.      *
  37.      * @param key 键
  38.      * @return 值
  39.      */
  40.     @GetMapping("/get")
  41.     public Object redisStringGet(@RequestParam String key) {
  42.         return redisString.get(key);
  43.     }
  44.  
  45.     /**
  46.      * 批量存值
  47.      */
  48.     @GetMapping("/batch/set")
  49.     public void redisBatchSet() {
  50.         Map<String, Object> map = new HashMap<>(3);
  51.         map.put("test1", "value1");
  52.         map.put("test2", "value2");
  53.         map.put("test3", "value3");
  54.         redisBatch.barchSet(map);
  55.     }
  56.  
  57.     /**
  58.      * 批量取值
  59.      *
  60.      * @return 值列表
  61.      */
  62.     @GetMapping("/batch/get")
  63.     public List<Object> redisBatchGet() {
  64.         // 批量取值，如果某个 key 不存在，则值为 null
  65.         List<String> list = new ArrayList<>(3);
  66.         list.add("test1");
  67.         list.add("test2");
  68.         list.add("test3");
  69.         return redisBatch.batchGet(list);
  70.     }
  71.  
  72. }

6、SpringBoot 启动类

SpringBoot 的启动类，内容如下：

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3.  
  4. @SpringBootApplication
  5. public class Application {
  6.  
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(Application.class, args);
  9.     }
  10.  
  11. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/776179
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号