package com.vincent.rsf.server.common.service;
|
|
import com.vincent.rsf.common.utils.Serialize;
|
import com.vincent.rsf.server.common.config.RedisProperties;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import redis.clients.jedis.Jedis;
|
import redis.clients.jedis.JedisPool;
|
import redis.clients.jedis.JedisPoolConfig;
|
|
import java.util.Date;
|
import java.util.Set;
|
|
/**
|
* redis tools
|
* Created by vincent on 2023-03-13
|
*/
|
@Slf4j
|
@Service
|
public class RedisService {
|
|
private static final String LINK = ".";
|
private static final long MIN_DEGRADE_WINDOW_MS = 30000L;
|
|
protected volatile JedisPool pool;
|
|
Integer index = 0;
|
|
public volatile Boolean initialize = true;
|
|
private volatile long degradedUntilMillis = 0L;
|
|
@Autowired
|
private RedisProperties redisProperties;
|
|
public synchronized JedisPool getPool() {
|
if (this.pool == null) {
|
JedisPoolConfig config = new JedisPoolConfig();
|
config.setTestOnBorrow(false);
|
this.index = redisProperties.getIndex();
|
this.pool = new JedisPool(config,
|
redisProperties.getHost(),
|
redisProperties.getPort(),
|
redisProperties.getTimeout(),
|
redisProperties.getPassword()
|
);
|
}
|
return this.pool;
|
}
|
|
public Jedis getJedis() {
|
if (isDegradedNow()) {
|
return null;
|
}
|
try {
|
Jedis jedis = this.getPool().getResource();
|
if (this.index != jedis.getDB()) {
|
jedis.select(this.index);
|
}
|
markRecovered();
|
return jedis;
|
} catch (Exception e) {
|
markUnavailable(e);
|
}
|
return null;
|
}
|
|
// key - object ----------------------------------------------------------------------------------------------------------
|
|
public String set(String flag, String key, Object value) {
|
if (value == null) {
|
this.delete(flag, key);
|
return null;
|
}
|
return execute(null, jedis -> jedis.set((flag + LINK + key).getBytes(), Serialize.serialize(value)));
|
}
|
|
public String set(String flag, String key, Object value, Integer seconds) {
|
if (value == null) {
|
this.delete(flag, key);
|
return null;
|
}
|
return execute(null, jedis -> jedis.setex((flag + LINK + key).getBytes(), seconds, Serialize.serialize(value)));
|
}
|
|
public <T> T get(String flag, String key) {
|
return execute(null, jedis -> {
|
byte[] bytes = jedis.get((flag + LINK + key).getBytes());
|
if (bytes == null || bytes.length == 0) {
|
return null;
|
}
|
return (T) Serialize.unSerialize(bytes);
|
});
|
}
|
|
public Long delete(String flag, String key) {
|
return execute(null, jedis -> jedis.del((flag + LINK + key).getBytes()));
|
}
|
|
public Long clear(String flag) {
|
this.setValue(flag, "CLEARING", "true");
|
return execute(null, jedis -> {
|
Object returnValue = jedis.eval("local keys = redis.call('keys', ARGV[1]) for i=1,#keys,1000 do redis.call('del', unpack(keys, i, math.min(i+4999, #keys))) end return #keys", 0, flag + LINK + "*");
|
return Long.parseLong(String.valueOf(returnValue));
|
});
|
}
|
|
// 为已存在的key设置过期时间 - 秒
|
public void setExpire(String flag, String key, int seconds) {
|
executeVoid(jedis -> jedis.expire((flag + LINK + key).getBytes(), seconds));
|
}
|
|
// 为已存在的key设置过期时间 - 具体到时间戳 （秒）
|
public void setExpireAt(String flag, String key, Date toTime) {
|
executeVoid(jedis -> jedis.expireAt((flag + LINK + key).getBytes(), toTime.getTime() / 1000));
|
}
|
|
// 获取过期剩余时间（秒） ttl == -1 没有设置过期时间； ttl == -2 key不存在
|
public Long getExpire(String flag, String key) {
|
return execute(null, jedis -> jedis.ttl((flag + LINK + key).getBytes()));
|
}
|
|
|
// key - string ----------------------------------------------------------------------------------------------------------
|
|
public String setValue(String flag, String key, String value) {
|
return execute(null, jedis -> jedis.set(flag + LINK + key, value));
|
}
|
|
public String setValue(String flag, String key, String value, Integer seconds) {
|
return execute(null, jedis -> jedis.setex(flag + LINK + key, seconds, value));
|
}
|
|
public String getValue(String flag, String key) {
|
return execute(null, jedis -> jedis.get(flag + LINK + key));
|
}
|
|
public Long deleteValue(String flag, String... key) {
|
return execute(null, jedis -> {
|
String[] keys = new String[key.length];
|
for (int i = 0; i < key.length; i++) {
|
keys[i] = flag + LINK + key[i];
|
}
|
return jedis.del(keys);
|
});
|
}
|
|
public Long clearValue(String flag) {
|
this.setValue(flag, "CLEARING", "true");
|
return execute(null, jedis -> {
|
Object returnValue = jedis.eval("return redis.call('del', unpack(redis.call('keys', ARGV[1])))", 0, flag + LINK + "*");
|
return Long.parseLong(String.valueOf(returnValue));
|
});
|
}
|
|
public void setValueExpire(String flag, String key, int seconds) {
|
executeVoid(jedis -> jedis.expire((flag + LINK + key).getBytes(), seconds));
|
}
|
|
public void setValueExpireAt(String flag, String key, Date atTime) {
|
executeVoid(jedis -> jedis.expireAt((flag + LINK + key).getBytes(), atTime.getTime() / 1000));
|
}
|
|
|
// hash ----------------------------------------------------------------------------------------------------------
|
|
public Long setMap(String name, String key, Object value) {
|
if (value == null) {
|
deleteMap(name, key);
|
return null;
|
}
|
return execute(null, jedis -> jedis.hset(name.getBytes(), key.getBytes(), Serialize.serialize(value)));
|
}
|
|
public <T> T getMap(String name, String key) {
|
return execute(null, jedis -> {
|
byte[] bytes = jedis.hget(name.getBytes(), key.getBytes());
|
if (bytes == null || bytes.length == 0) {
|
return null;
|
}
|
return (T) Serialize.unSerialize(bytes);
|
});
|
}
|
|
public Set<String> getMapKeys(String name) {
|
return execute(null, jedis -> jedis.hkeys(name));
|
}
|
|
public Long deleteMap(String name, String... key) {
|
return execute(null, jedis -> {
|
String[] keys = new String[key.length];
|
System.arraycopy(key, 0, keys, 0, key.length);
|
return jedis.hdel(name, keys);
|
});
|
}
|
|
public Long clearMap(String name) {
|
return execute(null, jedis -> jedis.del(name));
|
}
|
|
public void setMapExpire(String name, int seconds) {
|
executeVoid(jedis -> jedis.expire(name.getBytes(), seconds));
|
}
|
|
public void setMapExpireAt(String name, Date atTime) {
|
executeVoid(jedis -> jedis.expireAt(name.getBytes(), atTime.getTime() / 1000));
|
}
|
|
|
// mq ----------------------------------------------------------------------------------------------------------
|
|
// 列表末尾添加元素
|
public Long push(String name, Object value) {
|
if (value == null) {
|
return null;
|
}
|
return execute(null, jedis -> jedis.rpush(name.getBytes(), Serialize.serialize(value)));
|
}
|
|
// 获取列表头部元素 && 删除
|
public <T> T pop(String name) {
|
return execute(null, jedis -> {
|
byte[] bytes = jedis.lpop(name.getBytes());
|
if (bytes == null || bytes.length == 0) {
|
return null;
|
}
|
return (T) Serialize.unSerialize(bytes);
|
});
|
}
|
|
// 删除
|
public Long deleteList(String name) {
|
return execute(null, jedis -> jedis.del(name));
|
}
|
|
public void setListExpire(String name, int seconds) {
|
executeVoid(jedis -> jedis.expire(name.getBytes(), seconds));
|
}
|
|
public void setListExpireAt(String name, Date atTime) {
|
executeVoid(jedis -> jedis.expireAt(name.getBytes(), atTime.getTime() / 1000));
|
}
|
|
// count ----------------------------------------------------------------------------------------------------------
|
|
public Long incr(String key) {
|
return execute(null, jedis -> jedis.incr("COUNT." + key));
|
}
|
|
public Long decr(String key) {
|
return execute(null, jedis -> jedis.decr("COUNT." + key));
|
}
|
|
private boolean isDegradedNow() {
|
return !Boolean.TRUE.equals(this.initialize) && System.currentTimeMillis() < this.degradedUntilMillis;
|
}
|
|
private void markRecovered() {
|
if (Boolean.TRUE.equals(this.initialize)) {
|
return;
|
}
|
synchronized (this) {
|
if (Boolean.TRUE.equals(this.initialize)) {
|
return;
|
}
|
this.initialize = true;
|
this.degradedUntilMillis = 0L;
|
log.info("Redis recovered, degrade mode cleared.");
|
}
|
}
|
|
private void markUnavailable(Exception e) {
|
long now = System.currentTimeMillis();
|
long nextRetryAt = now + getDegradeWindowMillis();
|
boolean shouldLog = Boolean.TRUE.equals(this.initialize) || now >= this.degradedUntilMillis;
|
synchronized (this) {
|
this.initialize = false;
|
this.degradedUntilMillis = nextRetryAt;
|
}
|
if (shouldLog) {
|
log.warn("Redis unavailable, degrade mode enabled until {}. message={}", new Date(nextRetryAt), e.getMessage());
|
}
|
}
|
|
private long getDegradeWindowMillis() {
|
return Math.max((long) redisProperties.getTimeout() * 2L, MIN_DEGRADE_WINDOW_MS);
|
}
|
|
private <T> T execute(T fallbackValue, RedisCallback<T> callback) {
|
if (isDegradedNow()) {
|
return fallbackValue;
|
}
|
Jedis jedis = getJedis();
|
if (jedis == null) {
|
return fallbackValue;
|
}
|
try (jedis) {
|
return callback.doWithJedis(jedis);
|
} catch (Exception e) {
|
markUnavailable(e);
|
return fallbackValue;
|
}
|
}
|
|
private void executeVoid(RedisVoidCallback callback) {
|
execute(null, jedis -> {
|
callback.doWithJedis(jedis);
|
return null;
|
});
|
}
|
|
@FunctionalInterface
|
private interface RedisCallback<T> {
|
T doWithJedis(Jedis jedis) throws Exception;
|
}
|
|
@FunctionalInterface
|
private interface RedisVoidCallback {
|
void doWithJedis(Jedis jedis) throws Exception;
|
}
|
}
|
