SpringBoot集成Redis使用Lettuce

- 日理万妓 2024-03-26 13:27 89阅读 0赞

Redis是最常用的KV数据库，Spring 通过模板方式（RedisTemplate）提供了对Redis的数据查询和操作功能。本文主要介绍基于RedisTemplate + lettuce方式对Redis进行查询和操作的案例。

一、Redis基础数据类型

首先对redis来说，所有的key（键）都是字符串。我们在谈基础数据结构时，讨论的是存储值的数据类型，主要包括常见的5种数据类型，分别是：String、List、Set、Zset、Hash。

<table> 
 <tbody> 
 <tr> 
 <td> 结构类型 </td> 
 <td> 结构存储的值 </td> 
 <td> 结构的读写能力 </td> 
 </tr> 
 <tr> 
 <td> String字符串 </td> 
 <td> 可以是字符串、整数或浮点数 </td> 
 <td> 对整个字符串或字符串的一部分进行操作；对整数或浮点数进行自增或自减操作； </td> 
 </tr> 
 <tr> 
 <td> List列表 </td> 
 <td> 一个链表，链表上的每个节点都包含一个字符串 </td> 
 <td> 对链表的两端进行push和pop操作，读取单个或多个元素；根据值查找或删除元素； </td> 
 </tr> 
 <tr> 
 <td> Set集合 </td> 
 <td> 包含字符串的无序集合 </td> 
 <td> 字符串的集合，包含基础的方法有看是否存在添加、获取、删除；还包含计算交集、并集、差集等 </td> 
 </tr> 
 <tr> 
 <td> Hash散列 </td> 
 <td> 包含键值对的无序散列表 </td> 
 <td> 包含方法有添加、获取、删除单个元素 </td> 
 </tr> 
 <tr> 
 <td> Zset有序集合 </td> 
 <td> 和散列一样，用于存储键值对 </td> 
 <td> 字符串成员与浮点数分数之间的有序映射；元素的排列顺序由分数的大小决定；包含方法有添加、获取、删除单个元素以及根据分值范围或成员来获取元素 </td> 
 </tr> 
 </tbody> 
</table>

二、 Redis常用连接池

Jedis：是Redis的Java实现客户端，提供了比较全面的Redis命令的支持。

Redisson：实现了分布式和可扩展的Java数据结构。

Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。

三、SpringBoot集成Redis案例

1、yml配置常量：

redis:  
\# 地址  
host: 192.168.1.66  
\# 端口，默认为6379  
port: 6379  
\# 数据库索引  
database: 0  
\# 密码(如没有密码请注释掉)  
password: 123456  
\# 连接超时时间  
timeout: 3000  
\# 是否开启ssl  
ssl: false  
lettuce:  
pool:  
max-active: 1000 \# 连接池最大连接数（使用负值表示没有限制）  
max-wait: -1 \# 连接池最大阻塞等待时间（使用负值表示没有限制）  
max-idle: 10 \# 连接池中的最大空闲连接  
min-idle: 5 \# 连接池中的最小空闲连接

2、pom.xml引入依赖：

<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-data-redis</artifactId> 
<version>2.4.0</version> 
</dependency> 
 
<dependency> 
<groupId>org.apache.commons</groupId> 
<artifactId>commons-pool2</artifactId> 
<version>2.8.0</version> 
</dependency>

3、RedisConfig配置类：

package com.cn.common.conf;
 
 import com.alibaba.fastjson.parser.ParserConfig;
 import com.alibaba.fastjson.support.config.FastJsonConfig;
 import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
 
 
 /**
 * redis配置类
 *
 * @author zq
 */
 
 @Configuration
 @EnableCaching
 public class RedisConfig {
 
 // 倘若 spring.redis.host 不存在，则会默认为127.0.0.1.
 @Value("${spring.redis.host:#{'127.0.0.1'}}")
 private String hostName;
 
 @Value("${spring.redis.port:#{6379}}")
 private int port;
 
 @Value("${spring.redis.password:#{123456}}")
 private String password;
 
 @Value("${spring.redis.timeout:#{3000}}")
 private int timeout;
 
 @Value("${spring.redis.lettuce.pool.max-idle:#{16}}")
 private int maxIdle;
 
 @Value("${spring.redis.lettuce.pool.min-idle:#{1}}")
 private int minIdle;
 
 @Value("${spring.redis.lettuce.pool.max-wait:#{16}}")
 private long maxWaitMillis;
 
 @Value("${spring.redis.lettuce.pool.max-active:#{16}}")
 private int maxActive;
 
 @Value("${spring.redis.database:#{0}}")
 private int databaseId;
 
 @Bean
 public LettuceConnectionFactory lettuceConnectionFactory() {
 
 RedisConfiguration redisConfiguration = new RedisStandaloneConfiguration(
 hostName, port
 );
 
 // 设置选用的数据库号码
 ((RedisStandaloneConfiguration) redisConfiguration).setDatabase(databaseId);
 
 // 设置 redis 数据库密码
 ((RedisStandaloneConfiguration) redisConfiguration).setPassword(password);
 
 // 连接池配置
 GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
 poolConfig.setMaxIdle(maxIdle);
 poolConfig.setMinIdle(minIdle);
 poolConfig.setMaxTotal(maxActive);
 poolConfig.setMaxWaitMillis(maxWaitMillis);
 
 LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder
 = LettucePoolingClientConfiguration.builder()
 .commandTimeout(Duration.ofMillis(timeout));
 
 LettucePoolingClientConfiguration lettucePoolingClientConfiguration = builder.build();
 
 builder.poolConfig(poolConfig);
 
 // 根据配置和客户端配置创建连接
 LettuceConnectionFactory factory = new LettuceConnectionFactory(redisConfiguration, lettucePoolingClientConfiguration);
 return factory;
 }
 
 /**
 * springboot2.x 使用LettuceConnectionFactory 代替 RedisConnectionFactory
 * application.yml配置基本信息后,springboot2.x RedisAutoConfiguration能够自动装配
 * LettuceConnectionFactory 和 RedisConnectionFactory 及其 RedisTemplate
 *
 * @param
 * @return
 */
 @Bean(name = "redisTemplate")
 public RedisTemplate<String, Object> redisTemplate(
 LettuceConnectionFactory lettuceConnectionFactory
 ) {
 
 RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
 redisTemplate.setConnectionFactory(lettuceConnectionFactory);
 
 // 使用 FastJsonRedisSerializer 来序列化和反序列化redis 的 value的值
 FastJsonRedisSerializer<Object> serializer = new FastJsonRedisSerializer<>(Object.class);
 ParserConfig.getGlobalInstance().addAccept("com.muzz");
 FastJsonConfig fastJsonConfig = new FastJsonConfig();
 fastJsonConfig.setCharset(StandardCharsets.UTF_8);
 serializer.setFastJsonConfig(fastJsonConfig);
 
 // key 的 String 序列化采用 StringRedisSerializer
 StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 redisTemplate.setKeySerializer(stringRedisSerializer);
 redisTemplate.setHashKeySerializer(stringRedisSerializer);
 
 // value 的值序列化采用 fastJsonRedisSerializer
 redisTemplate.setValueSerializer(serializer);
 redisTemplate.setHashValueSerializer(serializer);
 
 redisTemplate.afterPropertiesSet();
 
 System.out.println(redisTemplate.getDefaultSerializer());
 
 return redisTemplate;
 }
 
 @Bean
 public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
 
 // 使用 FastJsonRedisSerializer 来序列化和反序列化redis 的 value的值
 FastJsonRedisSerializer<Object> serializer = new FastJsonRedisSerializer<>(Object.class);
 ParserConfig.getGlobalInstance().addAccept("com.muzz");
 FastJsonConfig fastJsonConfig = new FastJsonConfig();
 fastJsonConfig.setCharset(StandardCharsets.UTF_8);
 serializer.setFastJsonConfig(fastJsonConfig);
 return serializer;
 }
 
 
 }

4、 RedisUtil工具类：

package com.cn.util;
 
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 /**
 * @ Description： 基于spring和redis的redisTemplate工具类
 * 针对所有的hash 都是以h开头的方法
 * 针对所有的Set 都是以s开头的方法 不含通用方法
 * 针对所有的List 都是以l开头的方法
 * @ Modified By：
 */
 @Component
 @RequiredArgsConstructor
 public class RedisUtils {
 
 
 private RedisTemplate redisTemplate;
 
 
 private final StringRedisTemplate stringRedisTemplate;
 
 @Autowired(required = false)
 public void setRedisTemplate(RedisTemplate redisTemplate) {
 RedisSerializer stringSerializer = new StringRedisSerializer();
 redisTemplate.setKeySerializer(stringSerializer);
 redisTemplate.setHashKeySerializer(stringSerializer);
 this.redisTemplate = redisTemplate;
 }
 
 /**
 * 获取key
 * @param patten
 * @return
 */
 public Set keys(String patten){
 return stringRedisTemplate.keys(patten);
 }
 
 /**
 * 指定缓存失效时间
 *
 * @param key 键
 * @param time 时间(秒)
 *
 */
 public boolean expire(String key, long time) {
 try {
 if (time > 0) {
 redisTemplate.expire(key, time, TimeUnit.SECONDS);
 }
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 根据key 获取过期时间
 *
 * @param key 键 不能为null
 * @return 时间(秒) 返回0代表为永久有效
 */
 public long getExpire(String key) {
 return redisTemplate.getExpire(key, TimeUnit.SECONDS);
 }
 
 /**
 * 判断key是否存在
 *
 * @param key 键
 * @return true 存在 false不存在
 */
 public boolean hasKey(String key) {
 try {
 return redisTemplate.hasKey(key);
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 删除缓存
 *
 * @param key 可以传一个值 或多个
 */
 @SuppressWarnings("unchecked")
 public void del(String... key) {
 if (key != null && key.length > 0) {
 if (key.length == 1) {
 redisTemplate.delete(key[0]);
 } else {
 redisTemplate.delete(CollectionUtils.arrayToList(key));
 }
 }
 }
 
 //============================String=============================
 
 /**
 * 普通缓存获取
 *
 * @param key 键
 * @return 值
 */
 public Object get(String key) {
 return key == null ? null : redisTemplate.opsForValue().get(key);
 }
 
 /**
 * 普通缓存放入
 *
 * @param key 键
 * @param value 值
 * @return true成功 false失败
 */
 public boolean set(String key, Object value) {
 try {
 redisTemplate.opsForValue().set(key, value);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 
 }
 
 /**
 * 普通缓存放入并设置时间
 *
 * @param key 键
 * @param value 值
 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
 * @return true成功 false 失败
 */
 public boolean set(String key, Object value, long time) {
 try {
 if (time > 0) {
 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
 } else {
 set(key, value);
 }
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 递增
 *
 * @param key 键
 * @param delta 要增加几(大于0)
 * @return
 */
 public long incr(String key, long delta) {
 if (delta < 0) {
 throw new RuntimeException("递增因子必须大于0");
 }
 return redisTemplate.opsForValue().increment(key, delta);
 }
 
 /**
 * 递减
 *
 * @param key 键
 * @param delta 要减少几(小于0)
 * @return
 */
 public long decr(String key, long delta) {
 if (delta < 0) {
 throw new RuntimeException("递减因子必须大于0");
 }
 return redisTemplate.opsForValue().increment(key, -delta);
 }
 
 //================================Map=================================
 
 /**
 * HashGet
 *
 * @param key 键 不能为null
 * @param item 项 不能为null
 * @return 值
 */
 public Object hget(String key, String item) {
 return redisTemplate.opsForHash().get(key, item);
 }
 
 /**
 * 获取hashKey对应的所有键值
 *
 * @param key 键
 * @return 对应的多个键值
 */
 public Map<Object, Object> hmget(String key) {
 return redisTemplate.opsForHash().entries(key);
 }
 
 /**
 * HashSet
 *
 * @param key 键
 * @param map 对应多个键值
 * @return true 成功 false 失败
 */
 public boolean hmset(String key, Map<String, Object> map) {
 try {
 redisTemplate.opsForHash().putAll(key, map);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * HashSet 并设置时间
 *
 * @param key 键
 * @param map 对应多个键值
 * @param time 时间(秒)
 * @return true成功 false失败
 */
 public boolean hmset(String key, Map<String, Object> map, long time) {
 try {
 redisTemplate.opsForHash().putAll(key, map);
 if (time > 0) {
 expire(key, time);
 }
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 向一张hash表中放入数据,如果不存在将创建
 *
 * @param key 键
 * @param item 项
 * @param value 值
 * @return true 成功 false失败
 */
 public boolean hset(String key, String item, Object value) {
 try {
 redisTemplate.opsForHash().put(key, item, value);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 向一张hash表中放入数据,如果不存在将创建
 *
 * @param key 键
 * @param item 项
 * @param value 值
 * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
 * @return true 成功 false失败
 */
 public boolean hset(String key, String item, Object value, long time) {
 try {
 redisTemplate.opsForHash().put(key, item, value);
 if (time > 0) {
 expire(key, time);
 }
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 删除hash表中的值
 *
 * @param key 键 不能为null
 * @param item 项 可以使多个 不能为null
 */
 public void hdel(String key, Object... item) {
 redisTemplate.opsForHash().delete(key, item);
 }
 
 /**
 * 判断hash表中是否有该项的值
 *
 * @param key 键 不能为null
 * @param item 项 不能为null
 * @return true 存在 false不存在
 */
 public boolean hHasKey(String key, String item) {
 return redisTemplate.opsForHash().hasKey(key, item);
 }
 
 /**
 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
 *
 * @param key 键
 * @param item 项
 * @param by 要增加几(大于0)
 * @return
 */
 public double hincr(String key, String item, double by) {
 return redisTemplate.opsForHash().increment(key, item, by);
 }
 
 /**
 * hash递减
 *
 * @param key 键
 * @param item 项
 * @param by 要减少记(小于0)
 * @return
 */
 public double hdecr(String key, String item, double by) {
 return redisTemplate.opsForHash().increment(key, item, -by);
 }
 
 //============================set=============================
 
 /**
 * 根据key获取Set中的所有值
 *
 * @param key 键
 * @return
 */
 public Set<Object> sGet(String key) {
 try {
 return redisTemplate.opsForSet().members(key);
 } catch (Exception e) {
 e.printStackTrace();
 return null;
 }
 }
 
 /**
 * 根据value从一个set中查询,是否存在
 *
 * @param key 键
 * @param value 值
 * @return true 存在 false不存在
 */
 public boolean sHasKey(String key, Object value) {
 try {
 return redisTemplate.opsForSet().isMember(key, value);
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 将数据放入set缓存
 *
 * @param key 键
 * @param values 值 可以是多个
 * @return 成功个数
 */
 public long sSet(String key, Object... values) {
 try {
 return redisTemplate.opsForSet().add(key, values);
 } catch (Exception e) {
 e.printStackTrace();
 return 0;
 }
 }
 
 /**
 * 将set数据放入缓存
 *
 * @param key 键
 * @param time 时间(秒)
 * @param values 值 可以是多个
 * @return 成功个数
 */
 public long sSetAndTime(String key, long time, Object... values) {
 try {
 Long count = redisTemplate.opsForSet().add(key, values);
 if (time > 0) expire(key, time);
 return count;
 } catch (Exception e) {
 e.printStackTrace();
 return 0;
 }
 }
 
 /**
 * 获取set缓存的长度
 *
 * @param key 键
 * @return
 */
 public long sGetSetSize(String key) {
 try {
 return redisTemplate.opsForSet().size(key);
 } catch (Exception e) {
 e.printStackTrace();
 return 0;
 }
 }
 
 /**
 * 移除值为value的
 *
 * @param key 键
 * @param values 值 可以是多个
 * @return 移除的个数
 */
 public long setRemove(String key, Object... values) {
 try {
 Long count = redisTemplate.opsForSet().remove(key, values);
 return count;
 } catch (Exception e) {
 e.printStackTrace();
 return 0;
 }
 }
 //===============================list=================================
 
 /**
 * 获取list缓存的内容
 *
 * @param key 键
 * @param start 开始
 * @param end 结束 0 到 -1代表所有值
 * @return
 */
 public List<Object> lGet(String key, long start, long end) {
 try {
 return redisTemplate.opsForList().range(key, start, end);
 } catch (Exception e) {
 e.printStackTrace();
 return null;
 }
 }
 
 /**
 * 获取list缓存的长度
 *
 * @param key 键
 * @return
 */
 public long lGetListSize(String key) {
 try {
 return redisTemplate.opsForList().size(key);
 } catch (Exception e) {
 e.printStackTrace();
 return 0;
 }
 }
 
 /**
 * 通过索引 获取list中的值
 *
 * @param key 键
 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
 * @return
 */
 public Object lGetIndex(String key, long index) {
 try {
 return redisTemplate.opsForList().index(key, index);
 } catch (Exception e) {
 e.printStackTrace();
 return null;
 }
 }
 
 /**
 * 将list放入缓存
 *
 * @param key 键
 * @param value 值
 * @return
 */
 public boolean lSet(String key, Object value) {
 try {
 redisTemplate.opsForList().rightPush(key, value);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 将list放入缓存
 *
 * @param key 键
 * @param value 值
 * @param time 时间(秒)
 * @return
 */
 public boolean lSet(String key, Object value, long time) {
 try {
 redisTemplate.opsForList().rightPush(key, value);
 if (time > 0) expire(key, time);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 将list放入缓存
 *
 * @param key 键
 * @param value 值
 * @return
 */
 public boolean lSet(String key, List<Object> value) {
 try {
 redisTemplate.opsForList().rightPushAll(key, value);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 将list放入缓存
 *
 * @param key 键
 * @param value 值
 * @param time 时间(秒)
 * @return
 */
 public boolean lSet(String key, List<Object> value, long time) {
 try {
 redisTemplate.opsForList().rightPushAll(key, value);
 if (time > 0) expire(key, time);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 根据索引修改list中的某条数据
 *
 * @param key 键
 * @param index 索引
 * @param value 值
 * @return
 */
 public boolean lUpdateIndex(String key, long index, Object value) {
 try {
 redisTemplate.opsForList().set(key, index, value);
 return true;
 } catch (Exception e) {
 e.printStackTrace();
 return false;
 }
 }
 
 /**
 * 移除N个值为value
 *
 * @param key 键
 * @param count 移除多少个
 * @param value 值
 * @return 移除的个数
 */
 public long lRemove(String key, long count, Object value) {
 try {
 Long remove = redisTemplate.opsForList().remove(key, count, value);
 return remove;
 } catch (Exception e) {
 e.printStackTrace();
 return 0;
 }
 }
 }