@Service
public class RedisService {
@Autowired
private RedissonClient redissonClient;
@Resource
private RedisTemplate<String, Object> redisTemplate;
/**
* 建议使用redisson的加锁 释放锁
*/
/**
* 释放锁成功返回值
*/
private static final Long RELEASE_LOCK_SUCCESS_RESULT = 1L;
private static final String RELEASE_LOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
/**
* 模糊查询 获取key集合
*
* @param key
* @return
*/
public Iterator<String> getKeys(String key) {
Iterable<String> keysByPattern = redissonClient.getKeys().getKeysByPattern(key);
Iterator<String> iterator = keysByPattern.iterator();
return iterator;
}
/**
* 获取list信息
*
* @param key
* @param clazz
* @param <T>
* @return
*/
public <T> List<T> getList(String key, Class<T> clazz) {
RList<T> list = redissonClient.getList(key);
List<T> ts = list.readAll();
return ts;
}
/**
* 添加所有 list信息
*
* @param key
* @param data
* @param clazz 泛型 （需要实现Serializable接口）
* @param timeToLive 过期时间 单位（秒）
* @param <T>
* @return
*/
public <T> boolean setList(String key, List<T> data, Class<T> clazz, Long timeToLive) {
RList<T> list = redissonClient.getList(key);
list.clear();
boolean b = list.addAll(data);
list.expire(timeToLive, TimeUnit.SECONDS);
return b;
}
/**
* 添加所有 list信息
*
* @param key
* @param data
* @param clazz 泛型 （需要实现Serializable接口）
* @param <T>
* @return
*/
public <T> boolean setList(String key, List<T> data, Class<T> clazz) {
RList<T> list = redissonClient.getList(key);
list.clear();
boolean b = list.addAll(data);
return b;
}
/**
* 追加list
*
* @param key
* @param data
* @param clazz 泛型 （需要实现Serializable接口）
* @param <T>
* @return
*/
public <T> boolean addList(String key, T data, Class<T> clazz) {
RList<T> list = redissonClient.getList(key);
boolean b = list.add(data);
return b;
}
/**
* 追加所有list
*
* @param key
* @param data
* @param clazz
* @param <T>
* @return
*/
public <T> boolean addAllList(String key, List<T> data, Class<T> clazz) {
RList<T> list = redissonClient.getList(key);
boolean b = list.addAll(data);
return b;
}
/**
* 添加String
*
* @param key
* @param data
*/
public void setString(String key, String data) {
RBucket<String> bucket = redissonClient.getBucket(key, new StringCodec());
bucket.set(data);
}
/**
* 添加String 失效时间
*
* @param key
* @param data
* @param timeToLive
*/
public void setString(String key, String data, Long timeToLive) {
RBucket<String> bucket = redissonClient.getBucket(key, new StringCodec());
bucket.set(data);
bucket.expire(timeToLive, TimeUnit.SECONDS);
}
/**
* 删除redis
*
* @param key
*/
public void delete(String key) {
RBucket<String> bucket = redissonClient.getBucket(key, new StringCodec());
bucket.delete();
}
/**
* 获取String
*
* @param key
*/
public String getString(String key) {
RBucket<String> bucket = redissonClient.getBucket(key, new StringCodec());
String s = bucket.get();
return s;
}
/**
* 插入对象
*
* @param <T>
* @param key
* @param t
* @param timeToLive
*/
public <T> void setBucket(String key, T t, Long timeToLive) {
RBucket<Object> bucket = redissonClient.getBucket(key);
bucket.set(t);
bucket.expire(timeToLive, TimeUnit.SECONDS);
}
/**
* 插入对象
*
* @param key
* @param t
* @param clazz
* @param <T>
*/
public <T> void setBucket(String key, T t, Class<T> clazz) {
RBucket<Object> bucket = redissonClient.getBucket(key);
bucket.set(t);
}
/**
* 获取对象
*
* @param key
* @param <T>
* @return
*/
public <T> T getBucket(String key, Class<T> clazz) {
RBucket<T> bucket = redissonClient.getBucket(key);
T t = bucket.get();
return t;
}
/**
* 判断key值或内容是否存在
*
* @param key
* @return
*/
public boolean hasKey(String key) {
RBucket<String> bucket = redissonClient.getBucket(key, new StringCodec());
if (bucket.isExists()) {
return true;
} else {
return false;
}
}
/**
* 添加map
*
* @param name
* @param key
* @param value
* @param <T>
*/
public <T> void putMap(String name, String key, T value) {
RMap<String, T> map = redissonClient.getMap(name);
map.put(key, value);
}
/**
* 添加map
*
* @param name
* @param key
* @param value
* @param timeToLive
* @param <T>
*/
public <T> void putMap(String name, String key, T value, Long timeToLive) {
RMap<String, T> map = redissonClient.getMap(name);
map.put(key, value);
map.expire(timeToLive, TimeUnit.SECONDS);
}
/**
* 获取map
*
* @param name
* @param key
* @param <T>
* @return
*/
public <T> T getMap(String name, String key) {
RMap<String, T> map = redissonClient.getMap(name);
T t = map.get(key);
return t;
}
/**
* 获取增量
*
* @return
*/
public Long incrementAndGet(String key) {
return redissonClient.getAtomicLong(key).incrementAndGet();
}
/*
*//**
* 与 tryLock 相对应，用作释放锁
*
* @param lockKey
* @param clientId
* @return
*//*
public Boolean releaseLock(String lockKey, String clientId) {
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<Long>(RELEASE_LOCK_SCRIPT, Long.class);
Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), clientId);
return Objects.equals(result, RELEASE_LOCK_SUCCESS_RESULT);
}
*//**
* 该加锁方法仅针对单实例 Redis 可实现分布式加锁
* 对于 Redis 集群则无法使用
* <p>
* 支持重复，线程安全
* 建议使用Redisson加锁
* @param lockKey 加锁键
* @param clientId 加锁客户端唯一标识(采用UUID)
* @param seconds 锁过期时间
* @return
*//*
public Boolean tryLock(String lockKey, String clientId, long seconds) {
Boolean ret = redisTemplate.opsForValue().setIfAbsent(lockKey, clientId, seconds, TimeUnit.SECONDS);
return ret;
}*/
/***
* 尝试直接加锁
* @param key
* @return
*/
public boolean tryLock(String key) {
RLock lock = redissonClient.getLock(key);
return lock.tryLock();
}
/**
* 尝试加锁
*
* @param key
* @param leaseTime 加锁时间
* @return
*/
public boolean tryLock(String key, Long leaseTime) {
Boolean result = false;
try {
RLock lock = redissonClient.getLock(key);
result = lock.tryLock(0, leaseTime, TimeUnit.SECONDS);
} catch (InterruptedException e) {
return false;
}
return result;
}
/**
* 尝试加锁
*
* @param key
* @param waitTime 等待时间
* @param leaseTime 加锁时间
* @return
*/
public boolean tryLock(String key, Long waitTime, Long leaseTime) {
Boolean result = false;
try {
RLock lock = redissonClient.getLock(key);
result = lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
} catch (InterruptedException e) {
return false;
}
return result;
}
/**
* 释放锁
*
* @param key
*/
public void unLock(String key) {
try {
RLock lock = redissonClient.getLock(key);
lock.unlock();
} catch (Exception e) {
e.printStackTrace();
}
}
}