一、基础使用
1.1 概述
-
Spring Boot 操作数据：
- Spring Data；
- Jpa；
- Jdbc；
- mongdb；
- redis；
-
Spring Boot 2.x 版本以后，默认使用 lettuce（以前 Jedis）；
- Jedis：采用的直连，多线程操作的话，是不安全的，为避免不安全，需要使用 Jedis pool 连接池，更像 BIO 模式；
- lettuce：采用 netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数量，更像 NIO 模式；
源码分析
- Redis 自动配置类：
RedisAutoConfiguration
@AutoConfiguration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
@Bean
// @ConditionalOnMissingBean：如果不存在这个Bean才生效
// 可以自定义redisTemplate，替换默认的
@ConditionalOnMissingBean(name = "redisTemplate")
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 默认的RedisTemplate，没有过多的设置，redis对象都是需要序列化的
// 两个泛型都需是Object, Object类型的，使用时需要强制转换成<String, Object>
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
// String是redis中最常使用的类型，所以单独提出来一个Sring的Bean
@Bean
@ConditionalOnMissingBean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
return new StringRedisTemplate(redisConnectionFactory);
}
}
-
在 Spring Boot 中，一般使用 RedisTemplate 提供的方法，来操作Redis；
-
RedisConnectionFactory：是一个接口类，作用：配置连接信息，需要使用它的实现类：
-
RedisConnectionFactory 对应两个接口实现类：
-
JedisConnectionFactory：好多类不存在，已无法使用；
-
LettuceConnectionFactory：正常（Spring Boot 2.x 版本）；
-
1.2 整合测试
-
创建 Spring Boot 项目，勾选以下依赖：
-
Redis 相关依赖：
<!--springboot整合redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
- 配置 Redis：
application.yaml
# 配置 redis
spring:
redis:
# Redis索引 0~15，默认 0
database: 1
# 默认地址 localhost
host: 127.0.0.1
# 默认端口
port: 6379
# 密码（默认为空）
# password:
# lettuce: # 这里标明使用lettuce配置
# pool:
# max-active: 8 #连接池最大连接数（使用负值表示没有限制）
# max-wait: -1ms #连接池最大阻塞等待时间（使用负值表示没有限制）
# max-idle: 5 #连接池中的最大空闲连接
# min-idle: 0 #连接池中的最小空闲连接
# timeout: 10000ms #连接超时时间（毫秒）
- 测试类：
@SpringBootTest
class SpringbootRedisApplicationTests {
// @Autowired：2.7.0版本 使用默认redisTemplate时，报错，但可以运行
@Resource
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
// redisTemplate：操作不同的数据类型，API和redis指令一样
// opsForValue()：操作字符串，类似String
// opsForList()：操作List,类似String
redisTemplate.opsForValue().set("myKey", "Redis 测试");
System.out.println(redisTemplate.opsForValue().get("myKey"));
}
}
- 获取 Redis 的连接对象：
// 获取redis的连接对象
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
connection.flushDb();
connection.flushAll();
二、RedisTemplate 序列化
2.1 序列化测试
- Redis 序列化配置：
RedisTemplate；
-
默认使用的是 JDK 序列化方式：
-
创建测试实体类：对象未进行序列化；
// 注册组件
@Repository
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private String name;
private Integer age;
}
- 测试：在方法中，将对象进行序列化转换；
@Test
public void test() throws JsonProcessingException {
// 真实开发，一般都使用json来传递对象
User user = new User("测试用户", 20);
// 序列化对象，生成json格式
String jsonUser = new ObjectMapper().writeValueAsString(user);
redisTemplate.opsForValue().set("user", jsonUser);
System.out.println(redisTemplate.opsForValue().get("user"));
}
-
运行结果：正常
-
直接传递对象，不进行序列化测试：
@Test
public void test() throws JsonProcessingException {
// 真实开发，一般都使用json来传递对象
User user = new User("测试用户", 20);
redisTemplate.opsForValue().set("user", user);
System.out.println(redisTemplate.opsForValue().get("user"));
}
-
运行结果：报错
-
未进行序列化，报错，所以所有对象必须进行序列化；
-
修改实体类，将对象序列化：
// 注册组件
@Repository
@Data
@AllArgsConstructor
@NoArgsConstructor
// Serializable：序列化，在实际开发中，所有的 pojo 类都必须序列化
public class User implements Serializable {
private String name;
private Integer age;
}
- 再次运行测试，正常输出；
2.2 自定义 RedisTemplate 进行序列化
-
RedisTemplate 可以接收任意的 Object 作为值，写入 Redis，只不过写入前，会把 Object 序列化为字节形式，默认采用 JDK 序列化，但这种方式有两个缺点：
- 可读性差：对键值对进行了序列化，中文字符串序列化后的内容，表示为 16 进制表示的数据；
- 内存空间占用大：存储了额外的对象的类型信息；
-
RedisTemplate 序列化的两种方式：
-
自定义 RedisTemplate 进行序列化；
-
使用 StringRedisTemplate 进行序列化；
-
-
自定义配置类：redisTemplate；
@Configuration
public class RedisConfig {
// 自定义一个 redisTemplate
// 固定代码
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
// 为了开发方便，一般使用<String,Object>
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// 配置具体的序列化方式
// 1.json的序列化配置
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
// enableDefaultTyping:方法已弃用 activateDefaultTyping：替代方法
om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 2.string的序列化配置
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用string序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用string的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value采用Jackson的序列化方式
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value也采用Jackson的序列化方式
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
- 测试类：使用自定义的 redisTemplate；
@SpringBootTest
class SpringbootRedisApplicationTests {
// @Autowired：2.7.0版本 使用默认redisTemplate时，报错，但可以运行
// @Resource
@Autowired
// @Qualifier：按名称自动装配(自定义配置类)
@Qualifier("redisTemplate")
private RedisTemplate redisTemplate;
//...
}
2.3 使用 StringRedisTemplate 进行序列化
- 测试类：注入 StringRedisTemplate 类
@Autowired
private StringRedisTemplate stringRedisTemplate;
- 测试方法1：字符串测试
- 对于存储 String 类型的数据，SpringRedisTempalte 默认实现了存储前的序列化，以及取出前的反序列化；
@Test
void testString() {
// 字符串测试
stringRedisTemplate.opsForValue().set("name", "用户2");
System.out.println(stringRedisTemplate.opsForValue().get("name"));
}
- 测试方法2：Object
- 对于存取 Object 数据，存取前，都需要借助类 ObjectMapper，手动地进行序列化和反序列化；
@Test
void testSaveUser() throws JsonProcessingException {
// Object测试
// 创建
ObjectMapper mapper = new ObjectMapper();
// 创建对象
User user = new User("用户", 24);
// 手动序列化
String json = mapper.writeValueAsString(user);
// 写入数据
stringRedisTemplate.opsForValue().set("user:3", json);
// 获取数据
String jsonUser = stringRedisTemplate.opsForValue().get("user:3");
// 手动反序列化
User user3 = mapper.readValue(jsonUser, User.class);
System.out.println(user3);
}
三、封装工具类
- 写一个 Redis 工具类（直接用 RedisTemplate 操作 Redis，需要很多代码，因此直接封装好一个 RedisUtils，这样写代码更方便点，这个 RedisUtils 交给 Spring 容器实例化，使用时直接注解注入）
package com.study.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
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;
@Component
public class RedisUtils {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* 指定缓存失效时间
*
* @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(String.valueOf(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)
*/
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)
*/
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
*/
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 对应多个键值
*/
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)
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
*/
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 键
*/
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代表所有值
*/
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 键
*/
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倒数第二个元素，依次类推
*/
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 值
*/
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 时间(秒)
*/
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;
}
}
}
- 测试：
@Autowired
// 自定义的Redis工具类
private RedisUtils redisUtils;
// 测试方法
@Test
public void test3(){
redisUtils.set("name:user","工具类测试");
System.out.println(redisUtils.get("name:user"));
}
