Redis序列化配置类（全）
package com.example.redisdemo.Utils;
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.TypedTuple;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* Redis工具类
* @author LiuCheng
* @data 2021/1/14 15:55
*/
@Component
public class RedisUtils {
private final RedisTemplate<String, Object> redisTemplate;
public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
// -------------------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 存在返回 true, 不存在返回 false
*/
public Boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 设置过期时间
*
* @param key 要设置的 键
* @param timeout 过期时间
* @param unit 时间单位
* @return 设置成功返回 true, 设置失败返回 false
*/
public Boolean expire(String key, long timeout, TimeUnit unit) {
return redisTemplate.expire(key, timeout, unit);
}
/**
* 设置在什么时间过期
*
* @param key 要设置的 键
* @param date 过期时间
* @return 设置成功返回 true, 设置失败返回 false
*/
public Boolean expireAt(String key, Date date) {
return redisTemplate.expireAt(key, date);
}
/**
* 查找匹配的 key
*
* @param pattern 匹配字符串
* @return 满足匹配条件的 键 的 Set 集合
*/
public Set<String> keys(String pattern) {
return redisTemplate.keys(pattern);
}
/**
* 将当前数据库的 key 移动到给定的数据库 db 当中
*
* @param key 要移动的 键
* @param dbIndex 要移动到的 db 的序号, 从 0 开始
* @return 移动成功返回 true, 移动失败返回 false
*/
public Boolean move(String key, int dbIndex) {
return redisTemplate.move(key, dbIndex);
}
/**
* 移除 key 的过期时间，key 将持久保持
*
* @param key 要移除过期时间的 键
* @return 移除成功返回 true, 并且该 key 将持久存在, 移除失败返回 false
*/
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 修改成功返回 true, 修改失败返回 false
*/
public Boolean renameIfAbsent(String oldKey, String newKey) {
return redisTemplate.renameIfAbsent(oldKey, newKey);
}
/**
* 返回 key 所储存的值的类型
*
* @param key 要查询类型的 键
* @return key 的数据类型
*/
public DataType type(String key) {
return redisTemplate.type(key);
}
// -------------------string 相关操作---------------------
/**
* 设置指定 key 的值
*
* @param key 要设置的 键
* @param value 要设置的 值
*/
public void set(String key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 获取指定 key 的值
*
* @param key 键 的名称
* @return 键 对应的 值
*/
public Object get(String key) {
return redisTemplate.opsForValue().get(key);
}
/**
* 返回 key 的 字符串值 中指定位置的 子字符串
*
* @param key 要获取值的 键
* @param start 开始位置, 最小值: 0
* @param end 结束位置, 最大值: 字符串 - 1, 若为 -1 则是获取整个字符串值
* @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 redisTemplate.opsForValue().getAndSet(key, value);
}
/**
* 对 key 所储存的字符串值，获取指定偏移量上的位( bit )
*
* @param key 键
* @param offset 偏移量
* @return 指定偏移量上的 位( 0 / 1)
*/
public Boolean getBit(String key, long offset) {
return redisTemplate.opsForValue().getBit(key, offset);
}
/**
* 批量获取 key 的 值
*
* @param keys 要获取值的 键 的集合
* @return key对应的值的集合
*/
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 设置成功返回 true, 设置失败返回 false
*/
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 时间单位, 天: 小时: 分钟:
* 秒: 毫秒:
*/
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 从指