Redis（十七）-SpringBoot集成Redis
Posted 码农飞哥
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Redis（十七）-SpringBoot集成Redis相关的知识，希望对你有一定的参考价值。
您好，我是码农飞哥，感谢您阅读本文，欢迎一键三连哦。
💪🏻 1. Python基础专栏，基础知识一网打尽，9.9元买不了吃亏，买不了上当。 Python从入门到精通
❤️ 2. Python爬虫专栏，系统性的学习爬虫的知识点。9.9元买不了吃亏，买不了上当 。python爬虫入门进阶
❤️ 3. Ceph实战，从原理到实战应有尽有。 Ceph实战
❤️ 4. Java高并发编程入门，打卡学习Java高并发。 Java高并发编程入门
😁 5. 社区逛一逛，周周有福利，周周有惊喜。码农飞哥社区，飞跃计划
全网同名【码农飞哥】欢迎关注，个人VX: wei158556
文章目录
简介
SpringBoot是一个开发基于Spring框架的应用的快速开发框架，它也是SpringCloud构建微服务分布式系统的基础设施。
本文将重点介绍如何在SpringBoot项目中集成Redis。
1. 创建SpringBoot项目
- 打开IDEA 选中： File—>New—>Module
- 进入创建模型的页面，选择 Spring Initializr
- 点击Next，输入包路径 com.jay，项目名spring_boot_redis。
- 接着点击Next，选择如下两个依赖。
这样就创建了一个名为spring_boot_redis的SpringBoot项目。
2. 在pom.xml中添加依赖
在pom文件中引入redis的依赖和common-pool2依赖。
<!--引入redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--spring 2.x 集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.6.2</version>
</dependency>
<!--序列化值时使用-->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>
3. 设置配置类
为了方便配置，这里将application.properties文件改成application.yml文件，这里主要设置redis的主机，端口号，数据库名等。
spring:
redis:
host: 127.0.0.1
port: 6379
database: 0
connect-timeout: 1800000 #连接超时时间30分钟
lettuce:
pool:
max-active: 20 #连接池最大连接数
max-idle: 8 #最大空闲连接
min-idle: 0 #最小空闲连接
4. 设置配置类
配置类的作用就是用来生成RedisTemplate的实例。其中，@Configuration 注解用于指定该类是一个配置类。这里指定Redis的序列化方式采用string的序列化方式。而不是采用JDK序列化方式。
@Configuration
public class RedisConfig
@Bean
@Primary
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
try
// 测试连通性
factory.getConnection();
catch (RedisConnectionFailureException e)
System.out.println("未发现redis服务。");
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
//采用string的序列化方式
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new StringRedisSerializer());
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
5. 定义工具类
直接操作redisTemplate类可能比较麻烦，所以，这里定义了一个工具类来操作Redis。该工具类定义了操作String，list，set，zset，hash等数据类型的各种方法。
package com.jay;
import com.google.gson.Gson;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* Redis工具类
*/
@Component
public class RedisUtils
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* 默认过期时长，单位：秒
*/
public static final long DEFAULT_EXPIRE = 60 * 60 * 24L;
/**
* 不设置过期时长
*/
public static final long NOT_EXPIRE = -1;
private static final Gson gson = new Gson();
//获取redis的值,字符串
public <T> T get(String key, Class<T> clazz)
Object value = redisTemplate.opsForValue().get(key);
if (value != null)
return fromJson(value.toString(), clazz);
return null;
public void set(String key, Object value, long expire)
if (expire != NOT_EXPIRE)
redisTemplate.opsForValue().set(key, value, expire);
else
redisTemplate.opsForValue().set(key, value);
public void set(String key, Object value)
set(key, value, DEFAULT_EXPIRE);
// add new function since 2.22.22
/** -------------------key相关操作--------------------- */
/**
* 删除key
*
* @param key
*/
public void delete(String key)
redisTemplate.delete(key);
/**
* 批量删除key
*
* @param keys
*/
public void delete(Collection<String> keys)
redisTemplate.delete(keys);
/**
* 序列化key
*
* @param key
* @return
*/
public byte[] dump(String key)
return redisTemplate.dump(key);
/**
* 是否存在key
*
* @param key
* @return
*/
public Boolean hasKey(String key)
return redisTemplate.hasKey(key);
/**
* 设置过期时间
*
* @param key
* @param timeout
* @param unit
* @return
*/
public Boolean expire(String key, long timeout, TimeUnit unit)
return redisTemplate.expire(key, timeout, unit);
/**
* 设置过期时间
*
* @param key
* @param date
* @return
*/
public Boolean expireAt(String key, Date date)
return redisTemplate.expireAt(key, date);
/**
* 查找匹配的key
*
* @param pattern
* @return
*/
public Set<String> keys(String pattern)
return redisTemplate.keys(pattern);
/**
* 将当前数据库的 key 移动到给定的数据库 db 当中
*
* @param key
* @param dbIndex
* @return
*/
public Boolean move(String key, int dbIndex)
return redisTemplate.move(key, dbIndex);
/**
* 移除 key 的过期时间，key 将持久保持
*
* @param key
* @return
*/
public Boolean persist(String key)
return redisTemplate.persist(key);
/**
* 返回 key 的剩余的过期时间
*
* @param key
* @param unit
* @return
*/
public Long getExpire(String key, TimeUnit unit)
return redisTemplate.getExpire(key, unit);
/**
* 返回 key 的剩余的过期时间
*
* @param key
* @return
*/
public Long getExpire(String key)
return redisTemplate.getExpire(key);
/**
* 从当前数据库中随机返回一个 key
*
* @return
*/
public String randomKey()
return redisTemplate.randomKey();
/**
* 修改 key 的名称
*
* @param oldKey
* @param newKey
*/
public void rename(String oldKey, String newKey)
redisTemplate.rename(oldKey, newKey);
/**
* 仅当 newkey 不存在时，将 oldKey 改名为 newkey
*
* @param oldKey
* @param newKey
* @return
*/
public Boolean renameIfAbsent(String oldKey, String newKey)
return redisTemplate.renameIfAbsent(oldKey, newKey);
/**
* 返回 key 所储存的值的类型
*
* @param key
* @return
*/
public DataType type(String key)
return redisTemplate.type(key);
/** -------------------string相关操作--------------------- */
/**
* 返回 key 中字符串值的子字符
*
* @param key
* @param start
* @param end
* @return
*/
public String getRange(String key, long start, long end)
return redisTemplate.opsForValue().get(key, start, end);
/**
* 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
*
* @param key
* @param value
* @return
*/
public Object getAndSet(String key, Object value)
return String.valueOf(redisTemplate.opsForValue().getAndSet(key, value));
/**
* 批量获取
*
* @param keys
* @return
*/
public List<Object> multiGet(Collection<String> keys)
return redisTemplate.opsForValue().multiGet(keys);
/**
* 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value
*
* @param key
* @param offset 位置
* @param value 值,true为1, false为0
* @return
*/
public boolean setBit(String key, long offset, boolean value)
return redisTemplate.opsForValue().setBit(key, offset, value);
/**
* 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
*
* @param key
* @param value
* @param timeout 过期时间
* @param unit 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
* 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
*/
public void setEx(String key, Object value, long timeout, TimeUnit unit)
redisTemplate.opsForValue().set(key, value, timeout, unit);
/**
* 只有在 key 不存在时设置 key 的值
*
* @param key
* @param value
* @return 之前已经存在返回false, 不存在返回true
*/
public boolean setIfAbsent(String key, Object value)
return redisTemplate.opsForValue().setIfAbsent(key, value);
/**
* 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
*
* @param key
* @param value
* @param offset 从指定位置开始覆写
*/
public void setRange(String key, Object value, long offset)
redisTemplate.opsForValue().set(key, value, offset);
/**
* 获取字符串的长度
*
* @param key
* @return
*/
public Long size(String key)
return redisTemplate.opsForValue().size(key);
/**
* 批量添加
*
* @param maps
*/
public void multiSet(Map<String, Object> maps)
redisTemplate.opsForValue().multiSet(maps);
/**
* 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
*
* @param maps
* @return 之前已经存在返回false, 不存在返回true
*/
public boolean multiSetIfAbsent(Map<String, Object> maps)
return redisTemplate.opsForValue().multiSetIfAbsent(maps);
/**
* 增加(自增长), 负数则为自减
*
* @param key
* @param increment
* @return
*/
public Long incrBy(String key, long increment)
return redisTemplate.opsForValue().increment(key, increment);
/**
* @param key
* @param increment
* @return
*/
public Double incrByFloat(String key, double increment)
return redisTemplate.opsForValue().increment(key, increment);
/**
* 追加到末尾
*
* @param key
* @param value
* @return
*/
public Integer append(String key, String value)
return redisTemplate.opsForValue().append(key, value);
/** -------------------hash相关操作------------------------- */
/**
* 获取存储在哈希表中指定字段的值
*
* @param key
* @param field
* @return
*/
public Object hGet(String key, String field)
return redisTemplate.opsForHash().get(key, field);
/**
* 获取所有给定字段的值
*
* @param key
* @return
*/
public Map<Object, Object> hGetAll(String key)
return redisTemplate.opsForHash().entries(key);
/**
* 获取所有给定字段的值
*
* @param key
* @param fields
* @return
*/
public List<Object> hMultiGet(String key, Collection<Object> fields)
return redisTemplate.opsForHash().multiGet(key, fields);
public void hPut(String key, String hashKey, String value)
redisTemplate.opsForHash().put(key, hashKey, value);
public void hPutAll(String key, Map<String, String> maps)
redisTemplate.opsForHash().putAll(key, maps);
/**
* 仅当hashKey不存在时才设置
*
* @param key
* @param hashKey
* @param value
* @return
*/
public Boolean hPutIfAbsent(String key, String hashKey, String value)
return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
/**
* 删除一个或多个哈希表字段
*
* @param key
* @param fields
* @return
*/
public Long hDelete(String key, Object... fields)
return redisTemplate.opsForHash().delete(key, fields);
/**
* 查看哈希表 key 中，指定的字段是否存在
*
* @param key
* @param field
* @return
*/
public boolean hExists(String key, String field)
return redisTemplate.opsForHash().hasKey(key, field);
(十七)ATP应用测试平台——自定义实现一个springboot2的线程池启动器starter
(十七)ATP应用测试平台——自定义实现一个springboot2的线程池启动器starter
Springbootspring-boot-starter-redis包报错 :unknown
SpringBoot 集成Redisson 提示：java.lang.ClassNotFoundException: **.redis.connection.ReactiveRedisConnec