package com.gkhy.safePlatform.config.redis;
|
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.data.redis.connection.RedisClusterConnection;
|
import org.springframework.data.redis.connection.RedisClusterNode;
|
import org.springframework.data.redis.connection.RedisConnection;
|
import org.springframework.data.redis.connection.RedisConnectionFactory;
|
import org.springframework.data.redis.connection.jedis.JedisClusterConnection;
|
import org.springframework.data.redis.connection.jedis.JedisConnection;
|
import org.springframework.data.redis.core.*;
|
import org.springframework.stereotype.Repository;
|
|
import javax.annotation.Resource;
|
import java.io.Serializable;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* @Description: redis工具类
|
*/
|
|
@Repository("configRedisRepository")
|
@SuppressWarnings(value = { "unchecked", "rawtypes" })
|
public class RedisUtils {
|
|
|
@Resource
|
private RedisTemplate redisTemplate;
|
/**
|
* logger
|
*/
|
private final Logger logger = LoggerFactory.getLogger(this.getClass());
|
|
|
/**
|
* 写入缓存
|
* @param key
|
* @param value
|
* @return
|
*/
|
public boolean set(final String key, Object value) {
|
boolean result = false;
|
try {
|
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
|
operations.set(key, value);
|
result = true;
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return result;
|
}
|
/**
|
* 写入缓存设置时效时间
|
* @param key
|
* @param value
|
* @return
|
*/
|
public boolean set(final String key, Object value, Long expireTime ,TimeUnit timeUnit) {
|
boolean result = false;
|
try {
|
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
|
operations.set(key, value);
|
redisTemplate.expire(key, expireTime, timeUnit);
|
result = true;
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return result;
|
}
|
/**
|
* 批量删除对应的value
|
* @param keys
|
*/
|
public void remove(final String... keys) {
|
for (String key : keys) {
|
remove(key);
|
}
|
}
|
/**
|
* 批量删除key
|
* @param pattern
|
*/
|
public void removePattern(final String pattern) {
|
Set<Serializable> keys = redisTemplate.keys(pattern);
|
if (keys.size() > 0){
|
redisTemplate.delete(keys);
|
}
|
}
|
/**
|
* 删除对应的value
|
* @param key
|
*/
|
public void remove(final String key) {
|
if (exists(key)) {
|
redisTemplate.delete(key);
|
}
|
}
|
/**
|
* 判断缓存中是否有对应的value
|
* @param key
|
* @return
|
*/
|
public boolean exists(final String key) {
|
return redisTemplate.hasKey(key);
|
}
|
/**
|
* 读取缓存
|
* @param key
|
* @return
|
*/
|
public Object get(final String key) {
|
Object result = null;
|
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
|
result = operations.get(key);
|
return result;
|
}
|
/**
|
* 哈希 添加
|
* @param key
|
* @param hashKey
|
* @param value
|
*/
|
public void hmSet(String key, Object hashKey, Object value){
|
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
|
hash.put(key,hashKey,value);
|
}
|
/**
|
* 哈希获取数据
|
* @param key
|
* @param hashKey
|
* @return
|
*/
|
public Object hmGet(String key, Object hashKey){
|
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
|
return hash.get(key,hashKey);
|
}
|
/**
|
* 列表添加
|
* @param k
|
* @param v
|
*/
|
public void lPush(String k,Object v){
|
ListOperations<String, Object> list = redisTemplate.opsForList();
|
list.rightPush(k,v);
|
}
|
/**
|
* 列表获取
|
* @param k
|
* @param l
|
* @param l1
|
* @return
|
*/
|
public List<Object> lRange(String k, long l, long l1){
|
ListOperations<String, Object> list = redisTemplate.opsForList();
|
return list.range(k,l,l1);
|
}
|
/**
|
* 集合添加
|
* @param key
|
* @param value
|
*/
|
public void add(String key,Object value){
|
SetOperations<String, Object> set = redisTemplate.opsForSet();
|
set.add(key,value);
|
}
|
/**
|
* 集合获取
|
* @param key
|
* @return
|
*/
|
public Set<Object> setMembers(String key){
|
SetOperations<String, Object> set = redisTemplate.opsForSet();
|
return set.members(key);
|
}
|
/**
|
* 有序集合添加
|
* @param key
|
* @param value
|
* @param scoure
|
*/
|
public void zAdd(String key,Object value,double scoure){
|
ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
|
zset.add(key,value,scoure);
|
}
|
/**
|
* 有序集合获取
|
* @param key
|
* @param scoure
|
* @param scoure1
|
* @return
|
*/
|
public Set<Object> rangeByScore(String key,double scoure,double scoure1){
|
ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
|
return zset.rangeByScore(key, scoure, scoure1);
|
}
|
|
/**
|
* @Description: 获取过期时间 返回 秒
|
*/
|
|
public Long getExpireTime(String key) {
|
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
|
}
|
|
|
/**
|
* @Description: 重置key 的 过期时间
|
*/
|
public void resetKeyExpireTime(String key, Long seconds) {
|
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
|
}
|
|
public Set<String> scanMatch(String matchKey) {
|
Set<String> keys = new HashSet();
|
RedisConnectionFactory connectionFactory = redisTemplate.getConnectionFactory();
|
RedisConnection redisConnection = connectionFactory.getConnection();
|
Cursor<byte[]> scan = null;
|
if(redisConnection instanceof JedisClusterConnection){
|
RedisClusterConnection clusterConnection = connectionFactory.getClusterConnection();
|
Iterable<RedisClusterNode> redisClusterNodes = clusterConnection.clusterGetNodes();
|
Iterator<RedisClusterNode> iterator = redisClusterNodes.iterator();
|
while (iterator.hasNext()) {
|
RedisClusterNode next = iterator.next();
|
scan = clusterConnection.scan(next, ScanOptions.scanOptions().match(matchKey).count(Integer.MAX_VALUE).build());
|
while (scan.hasNext()) {
|
keys.add(new String(scan.next()));
|
}
|
scan.close();
|
}
|
return keys;
|
}
|
if(redisConnection instanceof JedisConnection){
|
scan = redisConnection.scan(ScanOptions.scanOptions().match(matchKey).count(Integer.MAX_VALUE).build());
|
while (scan.hasNext()){
|
//找到一次就添加一次
|
keys.add(new String(scan.next()));
|
}
|
scan.close();
|
return keys;
|
}
|
|
return keys;
|
}
|
|
}
|
