package com.qianwen.core.redis.cache;
|
|
import java.time.Duration;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.Date;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.concurrent.TimeUnit;
|
import java.util.function.Supplier;
|
import com.qianwen.core.tool.utils.CollectionUtil;
|
import org.springframework.data.redis.core.DefaultTypedTuple;
|
import org.springframework.data.redis.core.HashOperations;
|
import org.springframework.data.redis.core.ListOperations;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.data.redis.core.SetOperations;
|
import org.springframework.data.redis.core.ValueOperations;
|
import org.springframework.data.redis.core.ZSetOperations;
|
import org.springframework.lang.Nullable;
|
import org.springframework.util.Assert;
|
|
public class BladeRedis {
|
private final RedisTemplate<String, Object> redisTemplate;
|
private final ValueOperations<String, Object> valueOps;
|
private final HashOperations<String, Object, Object> hashOps;
|
private final ListOperations<String, Object> listOps;
|
private final SetOperations<String, Object> setOps;
|
private final ZSetOperations<String, Object> zSetOps;
|
|
public RedisTemplate<String, Object> getRedisTemplate() {
|
return this.redisTemplate;
|
}
|
|
public ValueOperations<String, Object> getValueOps() {
|
return this.valueOps;
|
}
|
|
public HashOperations<String, Object, Object> getHashOps() {
|
return this.hashOps;
|
}
|
|
public ListOperations<String, Object> getListOps() {
|
return this.listOps;
|
}
|
|
public SetOperations<String, Object> getSetOps() {
|
return this.setOps;
|
}
|
|
public ZSetOperations<String, Object> getZSetOps() {
|
return this.zSetOps;
|
}
|
|
public BladeRedis(RedisTemplate<String, Object> redisTemplate) {
|
this.redisTemplate = redisTemplate;
|
Assert.notNull(redisTemplate, "redisTemplate is null");
|
this.valueOps = redisTemplate.opsForValue();
|
this.hashOps = redisTemplate.opsForHash();
|
this.listOps = redisTemplate.opsForList();
|
this.setOps = redisTemplate.opsForSet();
|
this.zSetOps = redisTemplate.opsForZSet();
|
}
|
|
public void set(CacheKey cacheKey, Object value) {
|
String key = cacheKey.getKey();
|
Duration expire = cacheKey.getExpire();
|
if (expire == null) {
|
set(key, value);
|
} else {
|
setEx(key, value, expire);
|
}
|
}
|
|
public void set(String key, Object value) {
|
this.valueOps.set(key, value);
|
}
|
|
public void setEx(String key, Object value, Duration timeout) {
|
this.valueOps.set(key, value, timeout);
|
}
|
|
public void setEx(String key, Object value, Long seconds) {
|
this.valueOps.set(key, value, seconds.longValue(), TimeUnit.SECONDS);
|
}
|
|
@Nullable
|
public <T> T get(String key) {
|
return (T) this.valueOps.get(key);
|
}
|
|
@Nullable
|
public <T> T get(String key, Supplier<T> loader) {
|
T value = (T) get(key);
|
if (value != null) {
|
return value;
|
}
|
T value2 = loader.get();
|
if (value2 == null) {
|
return null;
|
}
|
set(key, value2);
|
return value2;
|
}
|
|
@Nullable
|
public <T> T get(CacheKey cacheKey) {
|
return (T) this.valueOps.get(cacheKey.getKey());
|
}
|
|
@Nullable
|
public <T> T get(CacheKey cacheKey, Supplier<T> loader) {
|
String key = cacheKey.getKey();
|
T value = (T) get(key);
|
if (value != null) {
|
return value;
|
}
|
T value2 = loader.get();
|
if (value2 == null) {
|
return null;
|
}
|
set(cacheKey, value2);
|
return value2;
|
}
|
|
public Boolean del(String key) {
|
return this.redisTemplate.delete(key);
|
}
|
|
public Boolean del(CacheKey key) {
|
return this.redisTemplate.delete(key.getKey());
|
}
|
|
public Long del(String... keys) {
|
return del(Arrays.asList(keys));
|
}
|
|
public Long del(Collection<String> keys) {
|
return this.redisTemplate.delete(keys);
|
}
|
|
public Set<String> keys(String pattern) {
|
return this.redisTemplate.keys(pattern);
|
}
|
|
public void mSet(Object... keysValues) {
|
this.valueOps.multiSet(CollectionUtil.toMap(keysValues));
|
}
|
|
public List<Object> mGet(String... keys) {
|
return mGet(Arrays.asList(keys));
|
}
|
|
public List<Object> mGet(Collection<String> keys) {
|
return this.valueOps.multiGet(keys);
|
}
|
|
public Long decr(String key) {
|
return this.valueOps.decrement(key);
|
}
|
|
public Long decrBy(String key, long longValue) {
|
return this.valueOps.decrement(key, longValue);
|
}
|
|
public Long incr(String key) {
|
return this.valueOps.increment(key);
|
}
|
|
public Long incrBy(String key, long longValue) {
|
return this.valueOps.increment(key, longValue);
|
}
|
|
public Long getCounter(String key) {
|
return Long.valueOf(String.valueOf(this.valueOps.get(key)));
|
}
|
|
public Boolean exists(String key) {
|
return this.redisTemplate.hasKey(key);
|
}
|
|
public String randomKey() {
|
return (String) this.redisTemplate.randomKey();
|
}
|
|
public void rename(String oldkey, String newkey) {
|
this.redisTemplate.rename(oldkey, newkey);
|
}
|
|
public Boolean move(String key, int dbIndex) {
|
return this.redisTemplate.move(key, dbIndex);
|
}
|
|
/**
|
* 设置指定key的超市时间
|
* @param key redisKey
|
* @param seconds 秒数
|
* @return
|
*/
|
public Boolean expire(String key, long seconds) {
|
return this.redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
|
}
|
|
public Boolean expire(String key, Duration timeout) {
|
return expire(key, timeout.getSeconds());
|
}
|
|
public Boolean expireAt(String key, Date date) {
|
return this.redisTemplate.expireAt(key, date);
|
}
|
|
public Boolean expireAt(String key, long unixTime) {
|
return expireAt(key, new Date(unixTime));
|
}
|
|
public Boolean pexpire(String key, long milliseconds) {
|
return this.redisTemplate.expire(key, milliseconds, TimeUnit.MILLISECONDS);
|
}
|
|
public <T> T getSet(String key, Object value) {
|
return (T) this.valueOps.getAndSet(key, value);
|
}
|
|
public Boolean persist(String key) {
|
return this.redisTemplate.persist(key);
|
}
|
|
public String type(String key) {
|
return this.redisTemplate.type(key).code();
|
}
|
|
public Long ttl(String key) {
|
return this.redisTemplate.getExpire(key);
|
}
|
|
public Long pttl(String key) {
|
return this.redisTemplate.getExpire(key, TimeUnit.MILLISECONDS);
|
}
|
|
public void hSet(String key, Object field, Object value) {
|
this.hashOps.put(key, field, value);
|
}
|
|
public void hMset(String key, Map<Object, Object> hash) {
|
this.hashOps.putAll(key, hash);
|
}
|
|
public <T> T hGet(String key, Object field) {
|
return (T) this.hashOps.get(key, field);
|
}
|
|
public List hmGet(String key, Object... fields) {
|
return hmGet(key, Arrays.asList(fields));
|
}
|
|
public List hmGet(String key, Collection<Object> hashKeys) {
|
return this.hashOps.multiGet(key, hashKeys);
|
}
|
|
public Long hDel(String key, Object... fields) {
|
return this.hashOps.delete(key, fields);
|
}
|
|
public Boolean hExists(String key, Object field) {
|
return this.hashOps.hasKey(key, field);
|
}
|
|
public Map hGetAll(String key) {
|
return this.hashOps.entries(key);
|
}
|
|
public List hVals(String key) {
|
return this.hashOps.values(key);
|
}
|
|
public Set<Object> hKeys(String key) {
|
return this.hashOps.keys(key);
|
}
|
|
public Long hLen(String key) {
|
return this.hashOps.size(key);
|
}
|
|
public Long hIncrBy(String key, Object field, long value) {
|
return this.hashOps.increment(key, field, value);
|
}
|
|
public Double hIncrByFloat(String key, Object field, double value) {
|
return this.hashOps.increment(key, field, value);
|
}
|
|
public <T> T lIndex(String key, long index) {
|
return (T) this.listOps.index(key, index);
|
}
|
|
public Long lLen(String key) {
|
return this.listOps.size(key);
|
}
|
|
public <T> T lPop(String key) {
|
return (T) this.listOps.leftPop(key);
|
}
|
|
public Long lPush(String key, Object... values) {
|
return this.listOps.leftPush(key, values);
|
}
|
|
public void lSet(String key, long index, Object value) {
|
this.listOps.set(key, index, value);
|
}
|
|
public Long lRem(String key, long count, Object value) {
|
return this.listOps.remove(key, count, value);
|
}
|
|
public List lRange(String key, long start, long end) {
|
return this.listOps.range(key, start, end);
|
}
|
|
public void lTrim(String key, long start, long end) {
|
this.listOps.trim(key, start, end);
|
}
|
|
public <T> T rPop(String key) {
|
return (T) this.listOps.rightPop(key);
|
}
|
|
public Long rPush(String key, Object... values) {
|
return this.listOps.rightPush(key, values);
|
}
|
|
public <T> T rPopLPush(String srcKey, String dstKey) {
|
return (T) this.listOps.rightPopAndLeftPush(srcKey, dstKey);
|
}
|
|
public Long sAdd(String key, Object... members) {
|
return this.setOps.add(key, members);
|
}
|
|
public <T> T sPop(String key) {
|
return (T) this.setOps.pop(key);
|
}
|
|
public Set sMembers(String key) {
|
return this.setOps.members(key);
|
}
|
|
public boolean sIsMember(String key, Object member) {
|
return this.setOps.isMember(key, member).booleanValue();
|
}
|
|
public Set sInter(String key, String otherKey) {
|
return this.setOps.intersect(key, otherKey);
|
}
|
|
public Set sInter(String key, Collection<String> otherKeys) {
|
return this.setOps.intersect(key, otherKeys);
|
}
|
|
public <T> T sRandMember(String key) {
|
return (T) this.setOps.randomMember(key);
|
}
|
|
public List sRandMember(String key, int count) {
|
return this.setOps.randomMembers(key, count);
|
}
|
|
public Long sRem(String key, Object... members) {
|
return this.setOps.remove(key, members);
|
}
|
|
public Set sUnion(String key, String otherKey) {
|
return this.setOps.union(key, otherKey);
|
}
|
|
public Set sUnion(String key, Collection<String> otherKeys) {
|
return this.setOps.union(key, otherKeys);
|
}
|
|
public Set sDiff(String key, String otherKey) {
|
return this.setOps.difference(key, otherKey);
|
}
|
|
public Set sDiff(String key, Collection<String> otherKeys) {
|
return this.setOps.difference(key, otherKeys);
|
}
|
|
public Boolean zAdd(String key, Object member, double score) {
|
return this.zSetOps.add(key, member, score);
|
}
|
|
public Long zAdd(String key, Map<Object, Double> scoreMembers) {
|
Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
|
scoreMembers.forEach((k, v) -> tuples.add(new DefaultTypedTuple(k, v)));
|
return this.zSetOps.add(key, tuples);
|
}
|
|
public Long zCard(String key) {
|
return this.zSetOps.zCard(key);
|
}
|
|
public Long zCount(String key, double min, double max) {
|
return this.zSetOps.count(key, min, max);
|
}
|
|
public Double zIncrBy(String key, Object member, double score) {
|
return this.zSetOps.incrementScore(key, member, score);
|
}
|
|
public Set zRange(String key, long start, long end) {
|
return this.zSetOps.range(key, start, end);
|
}
|
|
public Set zRevrange(String key, long start, long end) {
|
return this.zSetOps.reverseRange(key, start, end);
|
}
|
|
public Set zRangeByScore(String key, double min, double max) {
|
return this.zSetOps.rangeByScore(key, min, max);
|
}
|
|
public Long zRank(String key, Object member) {
|
return this.zSetOps.rank(key, member);
|
}
|
|
public Long zRevrank(String key, Object member) {
|
return this.zSetOps.reverseRank(key, member);
|
}
|
|
public Long zRem(String key, Object... members) {
|
return this.zSetOps.remove(key, members);
|
}
|
|
public Double zScore(String key, Object member) {
|
return this.zSetOps.score(key, member);
|
}
|
}
|
