整合redis
SpringDataRedis相关的api
1、引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、配置文件
spring:
redis:
# Redis服务器地址
host: 127.0.0.1
# Redis服务器端口号
port: 6379
# 使用的数据库索引,默认是0
database: 0
# 连接超时时间
timeout: 1800000
# 设置密码
password: "123456"
lettuce:
pool:
# 最大阻塞等待时间,负数表示没有限制
max-wait: -1
# 连接池中的最大空闲连接
max-idle: 5
# 连接池中的最小空闲连接
min-idle: 0
# 连接池中最大连接数,负数表示没有限制
max-active: 20
3、代码实践
@Autowired
private RedisTemplate redisTemplate;
@Test
public void redis() {
redisTemplate.opsForValue().set("test","测试");
String name = (String) redisTemplate.opsForValue().get("test");
System.out.println(name); //测试
}
问题出现了:当使用Redis客户端查看刚刚存入的数据时会发现redisTemplate把value值序列化为byte类型,无法直接看出结果。
4、自定义序列化器
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
// 创建模板
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
// 设置连接工厂
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 设置序列化工具
GenericJackson2JsonRedisSerializer jsonRedisSerializer =
new GenericJackson2JsonRedisSerializer();
// key和 hashKey采用 string序列化
redisTemplate.setKeySerializer(RedisSerializer.string());
redisTemplate.setHashKeySerializer(RedisSerializer.string());
// value和 hashValue采用 JSON序列化
redisTemplate.setValueSerializer(jsonRedisSerializer);
redisTemplate.setHashValueSerializer(jsonRedisSerializer);
return redisTemplate;
}
}
当配置好配置类后,再次执行上文的代码就不会出现上述情况了,但是问题又来了,fastjson 和 jackson 默认情况下整数类型优先选取 Integer ,超过 Integer 范围再选择 Long ,以此类推。在反序列化的时候还经常会出现把long值转成int值导致泛型转化失败等场景。
这里推荐不需要json序列化器,直接用string序列化器
用spring的 stringRedisTemplate,要求只能存储String类型的key和value。
这样每次存取很麻烦,但是可以通过redisUtils工具类来屏蔽这层麻烦。
RedisUtil使用
@Slf4j
public class RedisUtils {
private static StringRedisTemplate stringRedisTemplate;
static {
RedisUtils.stringRedisTemplate = SpringUtil.getBean(StringRedisTemplate.class);
}
private static final String LUA_INCR_EXPIRE =
"local key,ttl=KEYS[1],ARGV[1] \n" +
" \n" +
"if redis.call('EXISTS',key)==0 then \n" +
" redis.call('SETEX',key,ttl,1) \n" +
" return 1 \n" +
"else \n" +
" return tonumber(redis.call('INCR',key)) \n" +
"end ";
public static Long inc(String key, int time, TimeUnit unit) {
RedisScript<Long> redisScript = new DefaultRedisScript<>(LUA_INCR_EXPIRE, Long.class);
return stringRedisTemplate.execute(redisScript, Collections.singletonList(key), String.valueOf(unit.toSeconds(time)));
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
*/
public static Boolean expire(String key, long time) {
try {
if (time > 0) {
stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
}
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
return true;
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @param timeUnit 单位
*/
public static Boolean expire(String key, long time, TimeUnit timeUnit) {
try {
if (time > 0) {
stringRedisTemplate.expire(key, time, timeUnit);
}
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
return true;
}
/**
* 根据 key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public static Long getExpire(String key) {
return stringRedisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 根据 key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public static Long getExpire(String key, TimeUnit timeUnit) {
return stringRedisTemplate.getExpire(key, timeUnit);
}
/**
* 查找匹配key
*
* @param pattern key
* @return /
*/
public static List<String> scan(String pattern) {
ScanOptions options = ScanOptions.scanOptions().match(pattern).build();
RedisConnectionFactory factory = stringRedisTemplate.getConnectionFactory();
RedisConnection rc = Objects.requireNonNull(factory).getConnection();
Cursor<byte[]> cursor = rc.scan(options);
List<String> result = new ArrayList<>();
while (cursor.hasNext()) {
result.add(new String(cursor.next()));
}
try {
RedisConnectionUtils.releaseConnection(rc, factory);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/**
* 分页查询 key
*
* @param patternKey key
* @param page 页码
* @param size 每页数目
* @return /
*/
public static List<String> findKeysForPage(String patternKey, int page, int size) {
ScanOptions options = ScanOptions.scanOptions().match(patternKey).build();
RedisConnectionFactory factory = stringRedisTemplate.getConnectionFactory();
RedisConnection rc = Objects.requireNonNull(factory).getConnection();
Cursor<byte[]> cursor = rc.scan(options);
List<String> result = new ArrayList<>(size);
int tmpIndex = 0;
int fromIndex = page * size;
int toIndex = page * size + size;
while (cursor.hasNext()) {
if (tmpIndex >= fromIndex && tmpIndex < toIndex) {
result.add(new String(cursor.next()));
tmpIndex++;
continue;
}
// 获取到满足条件的数据后,就可以退出了
if (tmpIndex >= toIndex) {
break;
}
tmpIndex++;
cursor.next();
}
try {
RedisConnectionUtils.releaseConnection(rc, factory);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return result;
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public static Boolean hasKey(String key) {
try {
return stringRedisTemplate.hasKey(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 删除缓存
*
* @param keys
*/
public static void del(String... keys) {
if (keys != null && keys.length > 0) {
if (keys.length == 1) {
Boolean result = stringRedisTemplate.delete(keys[0]);
log.debug("--------------------------------------------");
log.debug("删除缓存:" + keys[0] + ",结果:" + result);
} else {
Set<String> keySet = new HashSet<>();
for (String key : keys) {
Set<String> stringSet = stringRedisTemplate.keys(key);
if (Objects.nonNull(stringSet) && !stringSet.isEmpty()) {
keySet.addAll(stringSet);
}
}
Long count = stringRedisTemplate.delete(keySet);
log.debug("--------------------------------------------");
log.debug("成功删除缓存:" + keySet);
log.debug("缓存删除数量:" + count + "个");
}
log.debug("--------------------------------------------");
}
}
public static void del(List<String> keys) {
stringRedisTemplate.delete(keys);
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
private static String get(String key) {
return key == null ? null : stringRedisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public static Boolean set(String key, Object value) {
try {
stringRedisTemplate.opsForValue().set(key, objToStr(value));
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
public static String getStr(String key) {
return get(key, String.class);
}
public static <T> T get(String key, Class<T> tClass) {
String s = get(key);
return toBeanOrNull(s, tClass);
}
public static <T> List<T> mget(Collection<String> keys, Class<T> tClass) {
List<String> list = stringRedisTemplate.opsForValue().multiGet(keys);
if (Objects.isNull(list)) {
return new ArrayList<>();
}
return list.stream().map(o -> toBeanOrNull(o, tClass)).collect(Collectors.toList());
}
static <T> T toBeanOrNull(String json, Class<T> tClass) {
return json == null ? null : JsonUtils.toObj(json, tClass);
}
public static String objToStr(Object o) {
return JsonUtils.toStr(o);
}
public static <T> void mset(Map<String, T> map, long time) {
Map<String, String> collect = map.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, (e) -> objToStr(e.getValue())));
stringRedisTemplate.opsForValue().multiSet(collect);
map.forEach((key, value) -> {
expire(key, time);
});
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public static Boolean set(String key, Object value, long time) {
try {
if (time > 0) {
stringRedisTemplate.opsForValue().set(key, objToStr(value), time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间
* @param timeUnit 类型
* @return true成功 false 失败
*/
public static Boolean set(String key, Object value, long time, TimeUnit timeUnit) {
try {
if (time > 0) {
stringRedisTemplate.opsForValue().set(key, objToStr(value), time, timeUnit);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public static Object hget(String key, String item) {
return stringRedisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public static Map<Object, Object> hmget(String key) {
return stringRedisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public static Boolean hmset(String key, Map<String, Object> map) {
try {
stringRedisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public static Boolean hmset(String key, Map<String, Object> map, long time) {
try {
stringRedisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public static Boolean hset(String key, String item, Object value) {
try {
stringRedisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public static Boolean hset(String key, String item, Object value, long time) {
try {
stringRedisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public static void hdel(String key, Object... item) {
stringRedisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public static Boolean hHasKey(String key, String item) {
return stringRedisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public static Double hincr(String key, String item, double by) {
return stringRedisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public static Double hdecr(String key, String item, double by) {
return stringRedisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public static Set<String> sGet(String key) {
try {
return stringRedisTemplate.opsForSet().members(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public static Boolean sHasKey(String key, Object value) {
try {
return stringRedisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public static Long sSet(String key, Object... values) {
try {
String[] s = new String[values.length];
for (int i = 0; i < values.length; i++) {
s[i] = objToStr(values[i]);
}
return stringRedisTemplate.opsForSet().add(key, s);
} catch (Exception e) {
log.error(e.getMessage(), e);
return 0L;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public static Long sSetAndTime(String key, long time, Object... values) {
try {
String[] s = new String[values.length];
for (int i = 0; i < values.length; i++) {
s[i] = objToStr(values[i]);
}
Long count = stringRedisTemplate.opsForSet().add(key, s);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
log.error(e.getMessage(), e);
return 0L;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public static Long sGetSetSize(String key) {
try {
return stringRedisTemplate.opsForSet().size(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
return 0L;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public static Long setRemove(String key, Object... values) {
try {
return stringRedisTemplate.opsForSet().remove(key, values);
} catch (Exception e) {
log.error(e.getMessage(), e);
return 0L;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public static List<String> lGet(String key, long start, long end) {
try {
return stringRedisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
log.error(e.getMessage(), e);
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public static Long lGetListSize(String key) {
try {
return stringRedisTemplate.opsForList().size(key);
} catch (Exception e) {
log.error(e.getMessage(), e);
return 0L;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
* @return
*/
public static String lGetIndex(String key, long index) {
try {
return stringRedisTemplate.opsForList().index(key, index);
} catch (Exception e) {
log.error(e.getMessage(), e);
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public static Boolean lSet(String key, Object value) {
try {
stringRedisTemplate.opsForList().rightPush(key, objToStr(value));
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public static Boolean lSet(String key, Object value, long time) {
try {
stringRedisTemplate.opsForList().rightPush(key, objToStr(value));
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public static Boolean lSet(String key, List<Object> value) {
try {
List<String> list = new ArrayList<>();
for (Object item : value) {
list.add(objToStr(item));
}
stringRedisTemplate.opsForList().rightPushAll(key, list);
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public static Boolean lSet(String key, List<Object> value, long time) {
try {
List<String> list = new ArrayList<>();
for (Object item : value) {
list.add(objToStr(item));
}
stringRedisTemplate.opsForList().rightPushAll(key, list);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return /
*/
public static Boolean lUpdateIndex(String key, long index, Object value) {
try {
stringRedisTemplate.opsForList().set(key, index, objToStr(value));
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public static Long lRemove(String key, long count, Object value) {
try {
return stringRedisTemplate.opsForList().remove(key, count, value);
} catch (Exception e) {
log.error(e.getMessage(), e);
return 0L;
}
}
/**
* @param prefix 前缀
* @param ids id
*/
public void delByKeys(String prefix, Set<Long> ids) {
Set<String> keys = new HashSet<>();
for (Long id : ids) {
Set<String> stringSet = stringRedisTemplate.keys(prefix + id);
if (Objects.nonNull(stringSet) && !stringSet.isEmpty()) {
keys.addAll(stringSet);
}
}
Long count = stringRedisTemplate.delete(keys);
// 此处提示可自行删除
log.debug("--------------------------------------------");
log.debug("成功删除缓存:" + keys.toString());
log.debug("缓存删除数量:" + count + "个");
log.debug("--------------------------------------------");
}
/**------------------zSet相关操作--------------------------------*/
/**
* 添加元素,有序集合是按照元素的score值由小到大排列
*
* @param key
* @param value
* @param score
* @return
*/
public static Boolean zAdd(String key, String value, double score) {
return stringRedisTemplate.opsForZSet().add(key, value, score);
}
public static Boolean zAdd(String key, Object value, double score) {
return zAdd(key, value.toString(), score);
}
public static Boolean zIsMember(String key, Object value) {
return Objects.nonNull(stringRedisTemplate.opsForZSet().score(key, value.toString()));
}
/**
* @param key
* @param values
* @return
*/
public Long zAdd(String key, Set<TypedTuple<String>> values) {
return stringRedisTemplate.opsForZSet().add(key, values);
}
/**
* @param key
* @param values
* @return
*/
public static Long zRemove(String key, Object... values) {
return stringRedisTemplate.opsForZSet().remove(key, values);
}
public static Long zRemove(String key, Object value) {
return zRemove(key, value.toString());
}
public static Long zRemove(String key, String value) {
return stringRedisTemplate.opsForZSet().remove(key, value);
}
/**
* 增加元素的score值,并返回增加后的值
*
* @param key
* @param value
* @param delta
* @return
*/
public static Double zIncrementScore(String key, String value, double delta) {
return stringRedisTemplate.opsForZSet().incrementScore(key, value, delta);
}
/**
* 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
*
* @param key
* @param value
* @return 0表示第一位
*/
public static Long zRank(String key, Object value) {
return stringRedisTemplate.opsForZSet().rank(key, value);
}
/**
* 返回元素在集合的排名,按元素的score值由大到小排列
*
* @param key
* @param value
* @return
*/
public static Long zReverseRank(String key, Object value) {
return stringRedisTemplate.opsForZSet().reverseRank(key, value);
}
/**
* 获取集合的元素, 从小到大排序
*
* @param key
* @param start 开始位置
* @param end 结束位置, -1查询所有
* @return
*/
public static Set<String> zRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().range(key, start, end);
}
public static Set<String> zAll(String key) {
return stringRedisTemplate.opsForZSet().range(key, 0, -1);
}
/**
* 获取集合元素, 并且把score值也获取
*
* @param key
* @param start
* @param end
* @return
*/
public static Set<ZSetOperations.TypedTuple<String>> zRangeWithScores(String key, long start,
long end) {
return stringRedisTemplate.opsForZSet().rangeWithScores(key, start, end);
}
/**
* 根据Score值查询集合元素
*
* @param key
* @param min 最小值
* @param max 最大值
* @return
*/
public static Set<String> zRangeByScore(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().rangeByScore(key, min, max);
}
/**
* 根据Score值查询集合元素, 从小到大排序
*
* @param key
* @param min 最小值
* @param max 最大值
* @return
*/
public static Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
Double min, Double max) {
if (Objects.isNull(min)) {
min = Double.MIN_VALUE;
}
if (Objects.isNull(max)) {
max = Double.MAX_VALUE;
}
return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
}
/**
* @param key
* @param min
* @param max
* @param start
* @param end
* @return
*/
public static Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
double min, double max, long start, long end) {
return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
start, end);
}
/**
* 获取集合的元素, 从大到小排序
*
* @param key
* @param start
* @param end
* @return
*/
public static Set<String> zReverseRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().reverseRange(key, start, end);
}
// /**
// * 获取集合的元素, 从大到小排序, 并返回score值
// *
// * @param key
// * @param start
// * @param end
// * @return
// */
// public Set<TypedTuple<String>> zReverseRangeWithScores(String key,
// long start, long end) {
// return redisTemplate.opsForZSet().reverseRangeWithScores(key, start,
// end);
// }
/**
* 获取集合的元素, 从大到小排序, 并返回score值
*
* @param key
* @param pageSize
* @return
*/
public static Set<TypedTuple<String>> zReverseRangeWithScores(String key,
long pageSize) {
return stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, Double.MIN_VALUE,
Double.MAX_VALUE, 0, pageSize);
}
/**
* @param key
* @param max
* @param pageSize
* @return
*/
public static Set<TypedTuple<String>> zReverseRangeByScoreWithScores(String key,
double max, long pageSize) {
return stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, Double.MIN_VALUE, max,
1, pageSize);
}
// /**
// * 根据Score值查询集合元素, 从大到小排序
// *
// * @param key
// * @param min
// * @param max
// * @return
// */
// public Set<String> zReverseRangeByScore(String key, double min,
// double max) {
// return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
// }
// /**
// * 根据Score值查询集合元素, 从大到小排序
// *
// * @param key
// * @param min
// * @param max
// * @return
// */
// public Set<TypedTuple<String>> zReverseRangeByScoreWithScores(
// String key, double min, double max) {
// return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
// min, max);
// }
/**
* 根据score值获取集合元素数量
*
* @param key
* @param min
* @param max
* @return
*/
public static Long zCount(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().count(key, min, max);
}
/**
* 获取集合大小
*
* @param key
* @return
*/
public static Long zSize(String key) {
return stringRedisTemplate.opsForZSet().size(key);
}
/**
* 获取集合大小
*
* @param key
* @return
*/
public static Long zCard(String key) {
return stringRedisTemplate.opsForZSet().zCard(key);
}
/**
* 获取集合中value元素的score值
*
* @param key
* @param value
* @return
*/
public static Double zScore(String key, Object value) {
return stringRedisTemplate.opsForZSet().score(key, value);
}
/**
* 移除指定索引位置的成员
*
* @param key
* @param start
* @param end
* @return
*/
public static Long zRemoveRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().removeRange(key, start, end);
}
/**
* 根据指定的score值的范围来移除成员
*
* @param key
* @param min
* @param max
* @return
*/
public static Long zRemoveRangeByScore(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().removeRangeByScore(key, min, max);
}
/**
* 获取key和otherKey的并集并存储在destKey中
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public static Long zUnionAndStore(String key, String otherKey, String destKey) {
return stringRedisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
}
/**
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public static Long zUnionAndStore(String key, Collection<String> otherKeys,
String destKey) {
return stringRedisTemplate.opsForZSet()
.unionAndStore(key, otherKeys, destKey);
}
/**
* 交集
*
* @param key
* @param otherKey
* @param destKey
* @return
*/
public static Long zIntersectAndStore(String key, String otherKey,
String destKey) {
return stringRedisTemplate.opsForZSet().intersectAndStore(key, otherKey,
destKey);
}
/**
* 交集
*
* @param key
* @param otherKeys
* @param destKey
* @return
*/
public static Long zIntersectAndStore(String key, Collection<String> otherKeys,
String destKey) {
return stringRedisTemplate.opsForZSet().intersectAndStore(key, otherKeys,
destKey);
}
}
stringRedisTemplate
是通过@PostConstruct
在类初始化阶段从spring容器中拿到对象,设置进静态变量中。
这里还有个小设计
虽然我们用的是stringRedisTemplate
但是工具类支持设置object的值,以及取出任意类型对象的值,工具类里封装了方法会对object的值转成json。
public class JsonUtils {
private static final ObjectMapper jsonMapper = new ObjectMapper();
public static <T> T toObj(String str, Class<T> clz) {
try {
return jsonMapper.readValue(str, clz);
} catch (JsonProcessingException e) {
throw new UnsupportedOperationException(e);
}
}
public static <T> T toObj(String str, TypeReference<T> clz) {
try {
return jsonMapper.readValue(str, clz);
} catch (JsonProcessingException e) {
throw new UnsupportedOperationException(e);
}
}
public static <T> List<T> toList(String str, Class<T> clz) {
try {
return jsonMapper.readValue(str, new TypeReference<List<T>>() {
});
} catch (JsonProcessingException e) {
throw new UnsupportedOperationException(e);
}
}
public static JsonNode toJsonNode(String str) {
try {
return jsonMapper.readTree(str);
} catch (JsonProcessingException e) {
throw new UnsupportedOperationException(e);
}
}
public static <T> T nodeToValue(JsonNode node, Class<T> clz) {
try {
return jsonMapper.treeToValue(node, clz);
} catch (JsonProcessingException e) {
throw new UnsupportedOperationException(e);
}
}
public static String toStr(Object t) {
try {
return jsonMapper.writeValueAsString(t);
} catch (Exception e) {
throw new UnsupportedOperationException(e);
}
}
}
引入redisson
分布式锁是我们经常需要用的,因此需要引入redisson。
1、引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
</dependency>
2、配置类
对于单机redis的配置比较简单,就是配置一个redissonClinet对象,以后的使用也是注入这个对象来使用
@Configuration
public class RedissonConfig {
@Autowired
private RedisProperties redisProperties;
@Bean
public RedissonClient redissonClient() {
Config config = new Config();
config.useSingleServer()
.setAddress("redis://" + redisProperties.getHost() + ":" + redisProperties.getPort())
.setPassword(redisProperties.getPassword())
.setDatabase(redisProperties.getDatabase());
return Redisson.create(config);
}
}
3、代码实践
@Autowired
private RedissonClient redissonClient;
public <T> T executeWithLockThrows(String key, int waitTime, TimeUnit unit, SupplierThrow<T> supplier) throws Throwable {
RLock lock = redissonClient.getLock(key);
boolean lockSuccess = lock.tryLock(waitTime, unit);
if (!lockSuccess) {
throw new BusinessException(CommonErrorEnum.LOCK_LIMIT);
}
try {
return supplier.get();//执行锁内的代码逻辑
} finally {
lock.unlock();
}
}