package com.util;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisUtil {
private static Jedis jedis;
private static final String PREFIX = "ll_idea";
private static final Logger logger = LoggerFactory.getLogger(JedisUtil.class);
// Redis服务器IP
private static String ADDR_ARRAY = "127.0.0.1,192.168.241.132";// FileUtil.getPropertyValue("/properties/redis.properties",
// "server");
// Redis的端口号
private static int PORT = 6379;// FileUtil.getPropertyValueInt("/properties/redis.properties",
// "port");
// 访问密码
// private static String AUTH =
// FileUtil.getPropertyValue("/properties/redis.properties", "auth");
// 可用连接实例的最大数目，默认值为8；
// 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1000;// FileUtil.getPropertyValueInt("/properties/redis.properties",
// "max_active");;
// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 8;// FileUtil.getPropertyValueInt("/properties/redis.properties",
// "max_idle");;
// 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
private static int MAX_WAIT = -1;// FileUtil.getPropertyValueInt("/properties/redis.properties",
// "max_wait");;
// 超时时间 毫秒
private static int TIMEOUT = 100000;// FileUtil.getPropertyValueInt("/properties/redis.properties",
// "timeout");;
// 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static boolean TEST_ON_BORROW = true;// FileUtil.getPropertyValueBoolean("/properties/redis.properties",
// "test_on_borrow");;
private static JedisPool jedisPool = null;
/**
* 初始化Redis连接池
*/
private static void initialPool() {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR_ARRAY.split(",")[0], PORT, TIMEOUT);
} catch (Exception e) {
logger.error("First create JedisPool error : " + e);
try {
// 如果第一个IP异常，则访问第二个IP
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR_ARRAY.split(",")[1], PORT, TIMEOUT);
} catch (Exception e2) {
logger.error("Second create JedisPool error : " + e2);
}
}
}
/**
* 在多线程环境同步初始化
*/
private static synchronized void poolInit() {
if (jedisPool == null) {
initialPool();
}
}
/**
* 同步获取Jedis实例
*
* @return Jedis
*/
public synchronized static Jedis getJedis() {
if (jedisPool == null) {
poolInit();
}
Jedis jedis = null;
try {
if (jedisPool != null) {
jedis = jedisPool.getResource();
}
} catch (Exception e) {
logger.error("Get jedis error : " + e);
} finally {
returnResource(jedis);
}
return jedis;
}
/**
* 释放jedis资源 jedispool returnresource 废弃 用 colose代码 3.0
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null && jedisPool != null) {
jedis.close();
}
}
public static Jedis getJedis(String host_ip, int host_port) {
jedis = new Jedis(host_ip, host_port);
// jedis.auth("admin.123"); //开启密码验证（配置文件中为 requirepass root）的时候需要执行该方法
return jedis;
}
public static Jedis getDefaultJedis() {
// return getJedis(HOST_IP, HOST_PORT);//简装版
return getJedis();
}
/**
* 清空 redis 中的所有数据
*/
public static String flushRedis() {
logger.debug("flush redis data");
return getDefaultJedis().flushDB();
}
/**
* 根据 pattern 获取 redis 中的键
*/
public static Set<String> getKeysByPattern(String pattern) {
return getDefaultJedis().keys(pattern);
}
/**
* 获取 redis 中所有的键
*/
public static Set<String> getAllKeys() {
return getKeysByPattern("*");
}
/**
* 判断key是否存在redis中
*/
public static boolean exists(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().exists(PREFIX + key);
}
/**
* 从Redis中移除一个key
*/
public static void del(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
getDefaultJedis().del(PREFIX + key);
}
// ======================String 类型接口======================================
/**
* 存储字符串
*/
public static void setString(String key, String value, int expireTime) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
String finalKey = PREFIX + key;
getDefaultJedis().set(finalKey, value);
if (expireTime > 0) {
/**
* 如果设置了 expireTime， 那么这个 finalKey会在expireTime秒后过期,那么该键会被自动删除
* 这一功能配合出色的性能让Redis可以作为缓存系统来使用，成为了缓存系统Memcached的有力竞争者
*/
getDefaultJedis().expire(finalKey, expireTime);
}
}
/**
* 获取字符串
*/
public static String getString(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().get(PREFIX + key);
}
public static long setnx(String key, String value) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().setnx(PREFIX + key, value);
}
public static long expire(String key, int seconds) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().expire(PREFIX + key, seconds);
}
// ========================List类型接口==========================
/**
* 存储 List
*/
public static void pushList(String key, String value, String flag) throws Exception {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(flag)) {
logger.error("key or flag is null");
throw new Exception("key or flag is null");
}
/**
* key代表的是链表的名字 List是一个双端链表，lpush是往链表的头部插入一条数据，rpush是往尾部插入一条数据
*/
if (flag.equalsIgnoreCase("L")) {
getDefaultJedis().lpush(PREFIX + key, value);
} else if (flag.equalsIgnoreCase("R")) {
getDefaultJedis().rpush(PREFIX + key, value);
} else {
logger.error("unknown flag");
throw new Exception("unknown flag");
}
}
/**
* 获取 List 中的单个元素
*/
public static String popList(String key, String flag) throws Exception {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(flag)) {
logger.error("key or flag is null");
throw new Exception("key or flag is null");
}
if (flag.equalsIgnoreCase("L")) {
return getDefaultJedis().lpop(PREFIX + key);
} else if (flag.equalsIgnoreCase("R")) {
return getDefaultJedis().rpop(PREFIX + key);
} else {
logger.error("unknown flag");
throw new Exception("unknown flag");
}
}
/**
* 获取 List 中指定区间上的元素
*/
public static List<String> getAppointedList(String key, long start, long end) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().lrange(PREFIX + key, start, end);
}
/**
* 获取 List 上所有的元素
*/
public static List<String> getList(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().lrange(PREFIX + key, 0, -1);
}
/**
* 获取 List 的长度
*/
public static long getListLength(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().llen(PREFIX + key);
}
// =====================Set类型接口==================
/**
* 存储 Set : 单值存储
*/
public static void addValueToSet(String key, String value) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
getDefaultJedis().sadd(PREFIX + key, value);
}
/**
* 存储 Set : 多值存储
*/
public static void addListToSet(String key, List<String> values) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
for (String value : values) {
getDefaultJedis().sadd(PREFIX + key, value);
}
}
/**
* 删除 Set 中的某个元素
*/
public static void deleteElementInSet(String key, String value) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
getDefaultJedis().srem(PREFIX + key, value);
}
/**
* 获取 Set 中所有的成员
*/
public static Set<String> getSet(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().smembers(PREFIX + key);
}
/**
* 判断 value 是否属于 set
*/
public static boolean isExistInSet(String key, String value) throws Exception {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
logger.error("key or value is null");
throw new Exception("key or value is null");
}
return getDefaultJedis().sismember(PREFIX + key, value);
}
/**
* 获取 Set 中元素个数
*/
public static long getLengthOfSet(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().scard(PREFIX + key);
}
/**
* 取两个 Set 的交集
*/
public static Set<String> getSetInter(String key1, String key2) throws Exception {
if (StringUtils.isEmpty(key1) || StringUtils.isEmpty(key2)) {
logger.error("key1 or key2 is null");
throw new Exception("key1 or key2 is null");
}
return getDefaultJedis().sinter(PREFIX + key1, PREFIX + key2);
}
/**
* 取两个 Set 的并集
*/
public static Set<String> getSetUnion(String key1, String key2) throws Exception {
if (StringUtils.isEmpty(key1) || StringUtils.isEmpty(key2)) {
logger.error("key1 or key2 is null");
throw new Exception("key1 or key2 is null");
}
return getDefaultJedis().sunion(PREFIX + key1, PREFIX + key2);
}
/**
* 取两个 Set 的差集
*/
public static Set<String> getSetDiff(String key1, String key2) throws Exception {
if (StringUtils.isEmpty(key1) || StringUtils.isEmpty(key2)) {
logger.error("key1 or key2 is null");
throw new Exception("key1 or key2 is null");
}
return getDefaultJedis().sdiff(PREFIX + key1, PREFIX + key2);
}
// ==================================SortedSet类型接口
/**
* 存储有序集合 SortedSet
*/
public static void setSortedSet(String key, double weight, String value) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
getDefaultJedis().zadd(PREFIX + key, weight, value);
}
/**
* 获取有序集合指定区间上的元素
*/
public static Set<String> getAppointedSortedSet(String key, long start, long end) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().zrange(PREFIX + key, start, end);
}
/**
* 获取有序集合上的所有元素
*/
public static Set<String> getSortedSet(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().zrange(PREFIX + key, 0, -1);
}
/**
* 获取有序集合上某个权重区间上的元素
*/
public static long getLengthOfSortedSetByWeight(String key, double min, double max) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().zcount(PREFIX + key, min, max);
}
/**
* 删除有序集合上的元素
*/
public static void deleteElementInSortedSet(String key, String value) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
getDefaultJedis().zrem(PREFIX + key, value);
}
/**
* 获取有序集合中元素的个数
*/
public static long getLengthOfSortedSet(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().zcard(PREFIX + key);
}
/**
* 查看有序集合中元素的权重
*/
public static double getWeight(String key, String value) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().zscore(PREFIX + key, value);
}
// ========================hash 类型接口==============
/**
* 存储 HashMap
*/
public static void setHashMapByFieldAndValue(String key, String field, String value) throws Exception {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
logger.error("key or field is null");
throw new Exception("key or field is null");
}
getDefaultJedis().hset(PREFIX + key, field, value);
}
/**
* 存储 HashMap
*/
public static void setHashMapByMap(String key, Map<String, String> map) throws Exception {
if (StringUtils.isEmpty(key) || map == null) {
logger.error("key or map is null");
throw new Exception("key or map is null");
}
getDefaultJedis().hmset(PREFIX + key, map);
}
/**
* 删除 HashMap 中的键值对
*/
public static void deleteHashMapValueByField(String key, String field) throws Exception {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
logger.error("key or field is null");
throw new Exception("key or field is null");
}
getDefaultJedis().hdel(PREFIX + key, field);
}
/**
* 获取 HashMap 中键对应的值
*/
public static String getHashMapValueByField(String key, String field) throws Exception {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
logger.error("key or field is null");
throw new Exception("key or field is null");
}
return getDefaultJedis().hget(PREFIX + key, field);
}
/**
* 获取 HashMap 中所有的 key
*/
public static Set<String> getHashMapKeys(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().hkeys(PREFIX + key);
}
/**
* 获取 HashMap 中所有的值
*/
public static List<String> getHashMapValues(String key) throws Exception {
if (StringUtils.isEmpty(key)) {
logger.error("key is null");
throw new Exception("key is null");
}
return getDefaultJedis().hvals(PREFIX + key);
}
/**
* 判断 HashMap 中是否存在某一个键
*/
public static boolean isFieldExistsInHashMap(String key, String field) throws Exception {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(field)) {
logger.error("key or field is null");
throw new Exception("key or field is null");
}
return getDefaultJedis().hexists(PREFIX + key, field);
}
public static long lpush(String key, String value) {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
logger.error("key or field is null");
}
return getDefaultJedis().lpush(key, value);
}
public static long rpush(String key, String value) {
if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
logger.error("key or field is null");
}
return getDefaultJedis().rpush(key, value);
}
public static String lpop(String key) {
if (StringUtils.isEmpty(key)) {
logger.error("key or field is null");
}
return getDefaultJedis().lpop(key);
}
public static String rpop(String key) {
if (StringUtils.isEmpty(key)) {
logger.error("key or field is null");
}
return getDefaultJedis().rpop(key);
}
static {
getDefaultJedis().lpush("key1", "123");
getDefaultJedis().lpush("key1", "456");
getDefaultJedis().lpush("key1", "789");
getDefaultJedis().lpush("key1", "012");
}
public static void main(String[] args) throws Exception {
Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
//在添加集群节点的时候只需要添加一个，其余同一集群的节点会被自动加入
jedisClusterNodes.add(new HostAndPort("192.168.241.132", 7000));
JedisCluster jc = new JedisCluster(jedisClusterNodes);
jc.set("rediskey", "redisvalue_123");
String value = jc.get("rediskey");
System.out.println(value);
}
}
