package com.product.datasource.service;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.google.common.collect.Maps;
|
import com.product.common.serialization.SerializationUtils;
|
import com.product.core.cache.util.CacheCommonUtil;
|
import com.product.core.exception.BaseException;
|
import com.product.datasource.config.ErrorCode;
|
import com.product.datasource.entity.DataBaseEntity;
|
import org.apache.commons.lang3.StringUtils;
|
import redis.clients.jedis.Jedis;
|
import redis.clients.jedis.JedisPool;
|
|
import java.nio.charset.Charset;
|
import java.nio.charset.StandardCharsets;
|
import java.util.Arrays;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* Copyright © 6c
|
*
|
* @Date 2022年07月14日 14:37
|
* @Author 6c
|
* @Description
|
*/
|
public class RedisService20220909 {
|
private Jedis jedis;
|
private String ip;
|
private int port;
|
private String password;
|
private int dbIndex;
|
public static final int CONNECTION_TIMEOUT = 60000;// 连接超时时间
|
public static final int SO_TIMEOUT = 60000;// 读取超时时间
|
private static JedisPool jedisPool;
|
|
public static void main(String[] args) throws InterruptedException {
|
test2();
|
}
|
|
public static void test2() throws InterruptedException {
|
DataBaseEntity dbe = new DataBaseEntity(5);
|
dbe.setIp("10.4.3.78");
|
dbe.setPort("6390");
|
RedisService20220909 redisService = new RedisService20220909(dbe);
|
|
String keyPrefix = "DC_STORE:tt_t_wip_*";
|
String[] keys = redisService.getKeys(keyPrefix);
|
if (keys != null) {
|
redisService.del(keys);
|
}
|
|
keyPrefix = "DC:tt_t_wip_*";
|
keys = redisService.getKeys(keyPrefix);
|
if (keys != null) {
|
redisService.del(keys);
|
}
|
redisService.close();
|
}
|
|
public RedisService20220909(DataBaseEntity dbe) {
|
try {
|
this.ip = dbe.getIp();
|
this.port = Integer.parseInt(dbe.getPort());
|
this.password = dbe.getPassWord();
|
this.dbIndex = StringUtils.isEmpty(dbe.getDbInstance()) ? 0 : Integer.parseInt(dbe.getDbInstance());
|
connect();
|
} catch (Exception e) {
|
throw new BaseException(ErrorCode.GET_REDIS_CONNECTION_FAIL);
|
}
|
}
|
|
/**
|
* 关闭redis连接
|
*/
|
public void close() {
|
if (jedis != null && jedis.isConnected()) {
|
jedis.close();
|
}
|
jedis = null;
|
}
|
|
/**
|
* 连接redis
|
*/
|
public void connect() {
|
if (jedis == null) {
|
try {
|
jedis = new Jedis(ip, port, CONNECTION_TIMEOUT, SO_TIMEOUT);
|
if (!StringUtils.isEmpty(password)) {
|
jedis.auth(password);
|
}
|
jedis.select(dbIndex);
|
jedis.connect();
|
} catch (Exception e) {
|
throw new BaseException(ErrorCode.GET_REDIS_CONNECTION_FAIL);
|
}
|
}
|
}
|
|
/*==================key-start==================*/
|
|
/**
|
* 模糊匹配key
|
*
|
* @param pattern 匹配正则表达式
|
* @return
|
*/
|
public String[] getKeys(String pattern) {
|
if (!StringUtils.isEmpty(pattern)) {
|
connect();
|
Set<byte[]> keyBytes = jedis.keys(pattern.getBytes(StandardCharsets.UTF_8));
|
if (!CollectionUtil.isEmpty(keyBytes)) {
|
return keyBytes.stream().map(item -> new String(item, StandardCharsets.UTF_8)).toArray(String[]::new);
|
}
|
}
|
return null;
|
}
|
|
|
/**
|
* 判定是否存在key
|
*
|
* @param key 关键字
|
* @return 是否存在
|
*/
|
public boolean exists(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return false;
|
}
|
connect();
|
return jedis.exists(key);
|
}
|
|
/**
|
* 删除key
|
*
|
* @param keys 关键字...
|
*/
|
public void del(String... keys) {
|
connect();
|
for (String key : keys) {
|
if (StringUtils.isEmpty(key)) {
|
continue;
|
}
|
jedis.del(key);
|
}
|
}
|
|
/**
|
* 设置超时时间
|
*
|
* @param key 关键字
|
* @param outTime 超时时间，单位：秒
|
* @param serializeFlag 是否序列化
|
* @return
|
*/
|
public boolean setOutTime(String key, int outTime, boolean serializeFlag) {
|
if (StringUtils.isEmpty(key)) {
|
return false;
|
}
|
connect();
|
Long result;
|
if (serializeFlag) {
|
result = jedis.expire(SerializationUtils.serialize(key), outTime);
|
} else {
|
result = jedis.expire(key, outTime);
|
}
|
return result != null && result == 1L;
|
}
|
public void setOutTime(String key, int minOutTime, int maxOutTime, boolean serializeFlag) {
|
if (StringUtils.isEmpty(key)) {
|
return;
|
}
|
if (maxOutTime < minOutTime || maxOutTime <= 0) {
|
return;
|
}
|
int outTime = (int) (Math.random() * (maxOutTime - minOutTime)) + minOutTime;
|
setOutTime(key, outTime,serializeFlag);
|
}
|
|
/**
|
* 移除超时时间
|
*
|
* @param key 关键字
|
*/
|
public void clearOutTime(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return;
|
}
|
connect();
|
jedis.persist(key);
|
}
|
|
/**
|
* 获取指定key的剩余过期时间
|
*
|
* @param key 关键字
|
* @return 剩余过期时间，单位：秒（特殊值如-2：没有这个key；-1：有key单没有设置过期时间，就是不过期）
|
*/
|
public Long getOutTime(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
connect();
|
return jedis.ttl(key);
|
}
|
|
/**
|
* 获取redis中的类型
|
*
|
* @param key 关键字
|
* @return redis的数据类型：String, hash, list, set, zset，若是key不存在，则返回"none"
|
*/
|
public String getType(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
connect();
|
return jedis.type(key);
|
}
|
/*==================key-final==================*/
|
|
/*==================string-start==================*/
|
/**
|
* 新增
|
* @param key 关键字
|
* @param value 值，非null
|
* @param serializeFlag 序列化标识
|
*/
|
public void set(String key, Object value, boolean serializeFlag) {
|
if (StringUtils.isEmpty(key)) {
|
return;
|
}
|
if (value == null) {
|
return;
|
}
|
connect();
|
if (!serializeFlag && value instanceof String) {
|
jedis.set(key, value.toString());
|
} else {
|
jedis.set(SerializationUtils.serialize(key), SerializationUtils.serialize(value));
|
}
|
}
|
|
/**
|
* 获取指定key的value
|
* @param key 关键字
|
* @param serializeFlag 序列化标识
|
* @return 值，不存在key会返回null
|
*/
|
public Object get(String key, boolean serializeFlag) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
connect();
|
if (serializeFlag) {
|
return jedis.get(SerializationUtils.serialize(key)) == null ? null : SerializationUtils.deserialize(jedis.get(SerializationUtils.serialize(key)));
|
} else {
|
return jedis.get(key);
|
}
|
}
|
/*==================string-final==================*/
|
|
/*==================hash-start==================*/
|
|
/**
|
* hash-新增
|
*
|
* @param key 关键字
|
* @param field 字段名
|
* @param value 字段值
|
*/
|
public void setHash(String key, String field, Object value) {
|
if (StringUtils.isEmpty(key)) {
|
return;
|
}
|
if (StringUtils.isEmpty(field)) {
|
return;
|
}
|
if (value == null) {
|
return;
|
}
|
connect();
|
jedis.hset(key.getBytes(StandardCharsets.UTF_8), field.getBytes(StandardCharsets.UTF_8), SerializationUtils.serialize(value));
|
}
|
|
/**
|
* hash-新增
|
*
|
* @param key 关键字
|
* @param map 内容Map
|
*/
|
public void setHash(String key, Map<String, Object> map) {
|
if (StringUtils.isEmpty(key)) {
|
return;
|
}
|
Map<byte[], byte[]> param = Maps.newHashMap();
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
|
param.put(entry.getKey().getBytes(StandardCharsets.UTF_8), SerializationUtils.serialize(entry.getValue()));
|
}
|
connect();
|
jedis.hmset(key.getBytes(StandardCharsets.UTF_8), param);
|
}
|
|
/**
|
* hash-判定是否存在
|
*
|
* @param key 关键字
|
* @param field 字段名
|
* @return 是否存在
|
*/
|
public boolean existsHash(String key, String field) {
|
if (StringUtils.isEmpty(key)) {
|
return false;
|
}
|
if (StringUtils.isEmpty(field)) {
|
return false;
|
}
|
connect();
|
return jedis.hexists(key.getBytes(StandardCharsets.UTF_8), field.getBytes(StandardCharsets.UTF_8));
|
}
|
|
/**
|
* hash-获取字段值
|
*
|
* @param key 关键字
|
* @param field 字段名
|
* @return 字段值
|
*/
|
public Object getHash(String key, String field) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
if (StringUtils.isEmpty(field)) {
|
return null;
|
}
|
connect();
|
return SerializationUtils.deserialize(jedis.hget(key.getBytes(StandardCharsets.UTF_8), field.getBytes(StandardCharsets.UTF_8)));
|
}
|
|
/**
|
* hash-获取所有字段内容集合
|
*
|
* @param key 关键字
|
* @return 所有字段内容集合
|
*/
|
public Map<String, Object> getHash(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
connect();
|
Map<byte[], byte[]> map = jedis.hgetAll(key.getBytes(StandardCharsets.UTF_8));
|
Map<String, Object> result = Maps.newHashMap();
|
Object field;
|
for (Map.Entry<byte[], byte[]> entry : map.entrySet()) {
|
field = StringUtils.toEncodedString(entry.getKey(), Charset.forName("UTF-8"));
|
result.put(field.toString(), SerializationUtils.deserialize(entry.getValue()));
|
}
|
return result;
|
}
|
|
/**
|
* hash-获取指定key的拥有的字段数
|
*
|
* @param key 关键字
|
* @return 拥有的字段数
|
*/
|
public Long getHashLength(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
connect();
|
return jedis.hlen(key.getBytes(StandardCharsets.UTF_8));
|
}
|
|
/**
|
* hash-获取指定key的字段名集合
|
*
|
* @param key 关键字
|
* @return 字段名集合
|
*/
|
public List<String> getHashFields(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
connect();
|
Set<byte[]> set = jedis.hkeys(key.getBytes(StandardCharsets.UTF_8));
|
if (set != null && set.size() > 0) {
|
return set.stream().collect(Collectors.toList()).stream().map(bytes -> StringUtils.toEncodedString(bytes, Charset.forName("UTF-8"))).collect(Collectors.toList());
|
}
|
return null;
|
}
|
|
/**
|
* hash-获取指定key的所有value集合
|
*
|
* @param key 关键字
|
* @return value集合
|
*/
|
public List<Object> getHashValues(String key) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
return getHashValues(key, Object.class);
|
}
|
|
/**
|
* hash-获取指定key的所有value集合
|
*
|
* @param key 关键字
|
* @return value集合
|
*/
|
public <T> List<T> getHashValues(String key, Class<T> t) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
connect();
|
return CacheCommonUtil.deserializeCollection(jedis.hvals(key.getBytes(StandardCharsets.UTF_8)), t);
|
}
|
|
/**
|
* hash-获取指定key的指定字段内容集合
|
*
|
* @param key 关键字
|
* @param fields 字段名集合
|
* @return 字段内容集合
|
*/
|
public List<Object> getHashAimFieldValues(String key, String... fields) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
return getHashAimFieldValues(key, Object.class, fields);
|
}
|
|
/**
|
* hash-获取指定key的指定字段内容集合
|
*
|
* @param key 关键字
|
* @param fields 字段名集合
|
* @return 字段内容集合
|
*/
|
public <T> List<T> getHashAimFieldValues(String key, Class<T> t, String... fields) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
byte[][] bytes = Arrays.stream(fields).map(field -> field.getBytes(StandardCharsets.UTF_8)).toArray(byte[][]::new);
|
connect();
|
return CacheCommonUtil.deserializeCollection(jedis.hmget(key.getBytes(StandardCharsets.UTF_8), bytes), t);
|
}
|
|
/**
|
* hash-删除
|
*
|
* @param key 关键字
|
* @param fields 字段名...
|
* @return 删除个数
|
*/
|
public Long delHash(String key, String... fields) {
|
if (StringUtils.isEmpty(key)) {
|
return null;
|
}
|
byte[][] bytes = Arrays.stream(fields).map(field -> field.getBytes(StandardCharsets.UTF_8)).toArray(byte[][]::new);
|
connect();
|
return jedis.hdel(key.getBytes(StandardCharsets.UTF_8), bytes);
|
}
|
/*==================hash-final==================*/
|
}
|
