redis集群使用Java工具类(Java jedis集群工具类)
package com.xiaomi.weather.vote.webservices.util.redisCache; import com.google.common.base.Strings;
import org.apache.log4j.Logger;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig; import java.io.InputStream;
import java.util.*; /**
* Created by mi on 16-12-22.
*/
public class RedisClusterClient {
private static final Logger logger = Logger.getLogger(RedisClusterClient.class);
private static String isOn = "true"; // 是否启用缓存
private static JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); // 配置信息
public JedisCluster jedisCluster = null;
Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>(); public static RedisClusterClient redisClusterClient = new RedisClusterClient(); public RedisClusterClient() {
init();
} public static RedisClusterClient getInsance() {
if (redisClusterClient != null) {
return redisClusterClient;
} else {
redisClusterClient = new RedisClusterClient();
return redisClusterClient;
}
} public boolean init() {
try {
// 读取配置文件
InputStream path = RedisClusterClient.class.getClassLoader().getResourceAsStream("cache.properties");
Properties pros = new Properties();
pros.load(path);
this.isOn = pros.getProperty("redis.onoff", "true");// 默认开启缓存
if (this.isOn.equals("false")) {// 未开启缓存
return false;
} //
String servers = pros.getProperty("redisMultiCluster.clusters", null);
if (Strings.isNullOrEmpty(servers)) {
logger.error("RedisJavaClient.servers 配置错误； in file:cache.properties");
this.isOn = "false";
return false;
}
String[] hostAndPorts = servers.split("\\|");
for (int i = 0; i < hostAndPorts.length; i++) {
String hostAndPort = hostAndPorts[i];
if (!hostAndPort.contains(":")) {
return false;
}
jedisClusterNodes.add(new HostAndPort(hostAndPort.split(":")[0], Integer.parseInt(hostAndPort.split(":")[1])));
}
try {
jedisPoolConfig.setMaxTotal(Integer.parseInt(pros.getProperty("redisMultiCluster.maxTotal", "8")));
jedisPoolConfig.setMaxIdle(Integer.parseInt(pros.getProperty("redisMultiCluster.maxIdle", "8")));
jedisPoolConfig.setMinIdle(Integer.parseInt(pros.getProperty("redisMultiCluster.minIdle", "0")));
jedisPoolConfig
.setBlockWhenExhausted(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.blockWhenExhausted", "true")));
jedisPoolConfig.setMaxWaitMillis(Integer.parseInt(pros.getProperty("redisMultiCluster.maxWaitMillis", "true")));
jedisPoolConfig.setTestOnBorrow(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnBorrow", "true")));
jedisPoolConfig.setTestOnCreate(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnCreate", "true")));
jedisPoolConfig.setTestOnReturn(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnReturn", "true")));
jedisPoolConfig.setTestWhileIdle(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testWhileIdle", "false"))); } catch (Exception e) {
logger.error("{未知异常}", e);
}
jedisCluster = new JedisCluster(jedisClusterNodes, jedisPoolConfig);
logger.info("缓存初始化成功");
path.close();
return true;
} catch (Exception e) {
logger.error("{缓存初始化错误}", e);
this.isOn = "false";
}
return false;
} public boolean setnx(String key, String value, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
Long setSuccess = jedisCluster.setnx(key, value);
if (setSuccess == 1) {
if (1 == jedisCluster.expire(key, expireTime)) {
return true;
} else {
this.deleteKey(key);
return false;
}
} else {
return false;
}
} catch (Exception e) {
logger.error("{}", e);
}
return false;
} public boolean set(String key, String value, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
jedisCluster.setex(key, expireTime, value);
return true;
} catch (Exception e) {
logger.error("{}", e);
}
return false;
} public String get(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return "";
}
try {
return jedisCluster.get(key);
} catch (Exception e) {
logger.error("{}", e);
}
return null;
} public <T> boolean setList(String key, List<T> list, Class<T> tClass, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
if (this.setnx(key + "Lock", "true", expireTime)) {
this.deleteKey(key);
for (T t : list) {
jedisCluster.rpush(key, SerializationDefine.Object2String(t));
}
if (1 == jedisCluster.expire(key, expireTime)) {
return true;
} else {
this.deleteKey(key);
return false;
}
}
return true;
} catch (Exception e) {
logger.error("{}", e);
}
return false;
} public <T> List<T> getList(String key, Class<T> tClass) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return null;
}
try {
List<T> tList = new ArrayList<T>();
List<String> strList = jedisCluster.lrange(key, 0L, -1L);
for (String str : strList) {
tList.add(SerializationDefine.String2Object(str, tClass));
} return tList.size() == 0 ? null : tList;
} catch (Exception e) {
logger.error("{}", e);
return null;
}
} public <T> boolean setMap(String key, Map<String, T> map, Class<T> tClass, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
Map<String, String> catchMap = new HashMap<String, String>();
if (this.setnx(key + "Lock", "true", expireTime)) {
this.deleteKey(key);
for (Map.Entry<String, T> entry : map.entrySet()) {
catchMap.put(entry.getKey(), SerializationDefine.Object2String(entry.getValue()));
}
jedisCluster.hmset(key, catchMap);
if (1 == jedisCluster.expire(key, expireTime)) {
return true;
} else {
this.deleteKey(key);
return false;
} }
return true;
} public <T> Map<String, T> getMap(String key, Class<T> tClass) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return null;
}
try {
Map<String, String> catchMap = jedisCluster.hgetAll(key);
Map<String, T> retMap = new HashMap<String, T>();
for (Map.Entry<String, String> entry : catchMap.entrySet()) {
retMap.put(entry.getKey(), SerializationDefine.String2Object(entry.getValue(), tClass));
}
return retMap;
} catch (Exception e) {
logger.error("{}", e);
return null;
} } public boolean deleteKey(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
if (1 == jedisCluster.del(key)) {
return true;
} else {
throw new Exception("redis异常，删除key失败：method = deleteKey; key = " + key);
}
} catch (Exception e) {
logger.error("{严重异常}", e);
} return false;
} /**
* 加1操作
*
* @param key
* @return
*/
public boolean incr(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
jedisCluster.incr(key);
return true;
} catch (Exception e) {
logger.error("{}", e);
return false;
}
} /**
* 减1操作
*
* @param key
* @return
*/
public boolean decr(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
jedisCluster.decr(key);
return true;
} catch (Exception e) {
logger.error("{}", e);
return false;
}
} /**
* 判断是否已缓存
*
* @param key
* @return
*/
public boolean isExist(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
return jedisCluster.exists(key);
} catch (Exception e) {
return false;
}
}
}
RedisClusterClient
说明，当redis连接不够用时，此setnx可能存在一些bug，即超时时间可能设置不成功！
所以当存在连接可能不够用的情况时，尽量不要使用setnx。
配置文件：
redis.onoff=true
redis.defaultExpireInSecond=900
redis.namespace=${cache_namespace}
redis.prefix=api-v3
RedisJavaClient.onoff=true
RedisJavaClient.servers=${redis_servers}
##==========================================================
redisMultiCluster.defaultExpireInSecond=900
redisMultiCluster.prefix=location-v3
redisMultiCluster.namespace=${cache_namespace}
redisMultiCluster.onoff=true
redisMultiCluster.clusters=${redis_clusters}
redisMultiCluster.route=route1:0|route2:1
redisMultiCluster.rule=com.xiaomi.weather.commons.cache.SubKeyRule
redisMultiCluster.startIndex=0
redisMultiCluster.endIndex=5 ##-------------连接池配置------------------
#最大连接数，最大资源空闲数目，最小资源空闲数目
redisMultiCluster.maxTotal=30
redisMultiCluster.maxIdle=30
redisMultiCluster.minIdle=10
#连接耗尽时，是否等待；等待时长(ms)
redisMultiCluster.blockWhenExhausted=true
redisMultiCluster.maxWaitMillis=500 #输出连接时是否检测空闲超时，回收连接检测，创建连接检测，输出连接检测，
redisMultiCluster.testWhileIdle=false
redisMultiCluster.testOnReturn=true
redisMultiCluster.testOnCreate=true
redisMultiCluster.testOnBorrow=true #(暂时不可用)资源耗尽时的处理措施0 - 抛异常，1 - 阻塞等待可用资源，2-强制创建新连接
redisMultiCluster.whenExhaustedAction=1
序列化类：
package com.xiaomi.weather.vote.webservices.util.redisCache; import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Preconditions; /**
* Created by mi on 16-12-22.
*/
public class SerializationDefine {
public static String Object2String(Object obj) {
Preconditions.checkArgument(obj != null, "序列化对象为null");
return JSONObject.toJSONString(obj);
} public static <T> T String2Object(String str, Class<T> tClass) {
return JSONObject.parseObject(str, tClass);
}
}
工具类第二版，修复删除key,而key不存在时报异常的bug；
package com.xiaomi.weather.vote.webservices.util.redisCache; import com.google.common.base.Strings;
import org.apache.log4j.Logger;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig; import java.io.InputStream;
import java.util.*; /**
* Created by mi on 16-12-22.
*/
public class RedisClusterClient {
private static final Logger logger = Logger.getLogger(RedisClusterClient.class);
private static String isOn = "true"; // 是否启用缓存
private static JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); // 配置信息
public JedisCluster jedisCluster = null;
Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>(); public static RedisClusterClient redisClusterClient = new RedisClusterClient(); public RedisClusterClient() {
init();
} public static RedisClusterClient getInsance() {
if (redisClusterClient != null) {
return redisClusterClient;
} else {
redisClusterClient = new RedisClusterClient();
return redisClusterClient;
}
} public boolean init() {
try {
// 读取配置文件
InputStream path = RedisClusterClient.class.getClassLoader().getResourceAsStream("cache.properties");
Properties pros = new Properties();
pros.load(path);
this.isOn = pros.getProperty("redis.onoff", "true");// 默认开启缓存
if (this.isOn.equals("false")) {// 未开启缓存
return false;
} //
String servers = pros.getProperty("redisMultiCluster.clusters", null);
if (Strings.isNullOrEmpty(servers)) {
logger.error("RedisJavaClient.servers 配置错误； in file:cache.properties");
this.isOn = "false";
return false;
}
String[] hostAndPorts = servers.split("\\|");
for (int i = 0; i < hostAndPorts.length; i++) {
String hostAndPort = hostAndPorts[i];
if (!hostAndPort.contains(":")) {
return false;
}
jedisClusterNodes.add(new HostAndPort(hostAndPort.split(":")[0], Integer.parseInt(hostAndPort.split(":")[1])));
}
try {
jedisPoolConfig.setMaxTotal(Integer.parseInt(pros.getProperty("redisMultiCluster.maxTotal", "8")));
jedisPoolConfig.setMaxIdle(Integer.parseInt(pros.getProperty("redisMultiCluster.maxIdle", "8")));
jedisPoolConfig.setMinIdle(Integer.parseInt(pros.getProperty("redisMultiCluster.minIdle", "0")));
jedisPoolConfig
.setBlockWhenExhausted(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.blockWhenExhausted", "true")));
jedisPoolConfig.setMaxWaitMillis(Integer.parseInt(pros.getProperty("redisMultiCluster.maxWaitMillis", "true")));
jedisPoolConfig.setTestOnBorrow(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnBorrow", "true")));
jedisPoolConfig.setTestOnCreate(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnCreate", "true")));
jedisPoolConfig.setTestOnReturn(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testOnReturn", "true")));
jedisPoolConfig.setTestWhileIdle(Boolean.parseBoolean(pros.getProperty("redisMultiCluster.testWhileIdle", "false"))); } catch (Exception e) {
logger.error("{未知异常}", e);
}
jedisCluster = new JedisCluster(jedisClusterNodes, jedisPoolConfig);
logger.info("缓存初始化成功");
path.close();
return true;
} catch (Exception e) {
logger.error("{缓存初始化错误}", e);
this.isOn = "false";
}
return false;
} public boolean setnx(String key, String value, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
Long setSuccess = jedisCluster.setnx(key, value);
if (setSuccess == 1) {//写入成功
if (1 == jedisCluster.expire(key, expireTime)) {
return true;
} else {
this.deleteKey(key);
return false;
}
} else {
return false;
}
} catch (Exception e) {
try {
this.deleteKey(key);
} catch (Exception ex) {
logger.error("删除key异常:key = " + key);
}
logger.error("{}", e);
}
return false;
} public boolean set(String key, String value, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
jedisCluster.setex(key, expireTime, value);
return true;
} catch (Exception e) {
logger.error("{}", e);
}
return false;
} public String get(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return "";
}
try {
return jedisCluster.get(key);
} catch (Exception e) {
logger.error("{}", e);
}
return null;
} public <T> boolean setList(String key, List<T> list, Class<T> tClass, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
if (this.setnx(key + "Lock", "true", expireTime)) {
this.deleteKey(key);
for (T t : list) {
jedisCluster.rpush(key, SerializationDefine.Object2String(t));
}
if (1 == jedisCluster.expire(key, expireTime)) {
return true;
} else {
this.deleteKey(key);
return false;
}
}
return true;
} catch (Exception e) {
logger.error("{}", e);
}
return false;
} public <T> List<T> getList(String key, Class<T> tClass) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return null;
}
try {
List<T> tList = new ArrayList<T>();
List<String> strList = jedisCluster.lrange(key, 0L, -1L);
for (String str : strList) {
tList.add(SerializationDefine.String2Object(str, tClass));
} return tList.size() == 0 ? null : tList;
} catch (Exception e) {
logger.error("{}", e);
return null;
}
} public <T> boolean setMap(String key, Map<String, T> map, Class<T> tClass, int expireTime) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
Map<String, String> catchMap = new HashMap<String, String>();
try {
if (this.setnx(key + "Lock", "true", expireTime)) {
this.deleteKey(key);
for (Map.Entry<String, T> entry : map.entrySet()) {
catchMap.put(entry.getKey(), SerializationDefine.Object2String(entry.getValue()));
}
jedisCluster.hmset(key, catchMap);
if (1 == jedisCluster.expire(key, expireTime)) {
return true;
} else {
this.deleteKey(key);
return false;
} }
} catch (Exception e) {
logger.error("{严重异常}", e);
}
return true;
} public <T> Map<String, T> getMap(String key, Class<T> tClass) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return null;
}
try {
Map<String, String> catchMap = jedisCluster.hgetAll(key);
Map<String, T> retMap = new HashMap<String, T>();
for (Map.Entry<String, String> entry : catchMap.entrySet()) {
retMap.put(entry.getKey(), SerializationDefine.String2Object(entry.getValue(), tClass));
}
return retMap;
} catch (Exception e) {
logger.error("{}", e);
return null;
} } public boolean deleteKey(String key) throws Exception {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
if (!this.isExist(key)) {//key不存在
return true;
}
if (1 == jedisCluster.del(key)) {
return true;
} else {
throw new Exception("redis异常，删除key失败：method = deleteKey; key = " + key);
}
} catch (Exception e) {
logger.error("{严重异常}", e);
throw new Exception("redis异常，删除key失败：method = deleteKey; key = " + key);
}
} /**
* 加1操作
*
* @param key
* @return
*/
public boolean incr(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
jedisCluster.incr(key);
return true;
} catch (Exception e) {
logger.error("{}", e);
return false;
}
} /**
* 减1操作
*
* @param key
* @return
*/
public boolean decr(String key) {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
jedisCluster.decr(key);
return true;
} catch (Exception e) {
logger.error("{}", e);
return false;
}
} /**
* 判断是否已缓存
*
* @param key
* @return
*/
public boolean isExist(String key) throws Exception {
if (!isOn.equals("true")) {
logger.info("缓存未开启");
return false;
}
try {
return jedisCluster.exists(key);
} catch (Exception e) {
logger.error("{严重异常}判断key是否存在发生异常... ... key = " + key, e);
throw new Exception("{严重异常}判断key是否存在发生异常... ...key = " + key);
}
} public static void main(String[] arges) {
try {
System.out.println(RedisClusterClient.getInsance().jedisCluster.del("panpanpan"));
} catch (Exception e) {
e.printStackTrace();
} }
}
redis集群使用Java工具类(Java jedis集群工具类)的更多相关文章
- 编写Spark的WordCount程序并提交到集群运行[含scala和java两个版本]
编写Spark的WordCount程序并提交到集群运行[含scala和java两个版本] 1. 开发环境 Jdk 1.7.0_72 Maven 3.2.1 Scala 2.10.6 Spark 1.6 ...
- 005-guava 集合-集合工具类-java.util.Collections中未包含的集合工具[Maps,Lists,Sets]，Iterables、Multisets、Multimaps、Tables
一.概述 工具类与特定集合接口的对应关系归纳如下: 集合接口 属于JDK还是Guava 对应的Guava工具类 Collection JDK Collections2:不要和java.util.Col ...
- Java集合框架（六）—— Collections工具类
操作集合的工具类Collections Java提供了一个操作Set.List和Map等集合的工具类:Collections,该工具类里提供了大量方法对集合元素进行排序.查询和修改等操作,还提供了将集 ...
- java调用kettle的job和transfer工具类
package com.woaiyitiaocai.util; import java.util.Map; import java.util.UUID; import org.apache.log4j ...
- Java学习笔记 -- Java定时调度工具Timer类
1 关于 (时间宝贵的小姐姐请跳过) 本教程是基于Java定时任务调度工具详解之Timer篇的学习笔记. 什么是定时任务调度 基于给定的时间点,给定的时间间隔或者给定的执行次数自动执行的任务. 在Ja ...
- JavaSE-基础语法(二)-系统类(java.lang.*)和工具类(java.util.*)
系统类(java.lang.*)和工具类(java.util.*) 一.系统类(java.lang.*) 这个包下包含java语言的核心类,如String.Math.System和Thread类等,使 ...
- Java+大数据开发——Hadoop集群环境搭建(一)
1集群简介 HADOOP集群具体来说包含两个集群:HDFS集群和YARN集群,两者逻辑上分离,但物理上常在一起 HDFS集群: 负责海量数据的存储,集群中的角色主要有 NameNode / DataN ...
- 反射工具类.提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class,被AOP过的真实类等工具函数.java
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.Validate; import org.ap ...
- 4 kafka集群部署及kafka生产者java客户端编程 + kafka消费者java客户端编程
本博文的主要内容有 kafka的单机模式部署 kafka的分布式模式部署 生产者java客户端编程 消费者java客户端编程 运行kafka ,需要依赖 zookeeper,你可以使用已有的 zo ...
- 开发工具、Object类(java基础知识十一)
1.常见开发工具介绍 * A:操作系统自带的记事本软件 * B:高级记事本软件 * C:集成开发环境 IDE * (Integrated Development Environment) * ...
随机推荐
- python cPickle和pickle 序列化
在Python中提供了两个模块:cPickle和pickle来实现序列化,前者是由C语言编写的,效率比后者高很多,一般编写程序的时候,采取的方案是先导入cPickle模块,如果此模块不存在,再导入pi ...
- C#安装，启动，停止，卸载Windows服务
public class OptionServices { //安装服务 public static void InstallService(string filep ...
- C# 如何判断系统是32位还是64位
摘自:http://www.cnblogs.com/tom-tong/archive/2012/03/12/2392173.html public static int GetOSBit() { tr ...
- [Spring Data MongoDB]学习笔记－－MongoTemplate查询操作
查询操作主要用到两个类:Query, Criteria 所有的find方法都需要一个query的object. 1. 直接通过json来查找,不过这种方式在代码中是不推荐的. BasicQuery q ...
- 《从零开始学Swift》学习笔记（Day 15）——请注意数字类型之间的转换
原创文章,欢迎转载.转载请注明:关东升的博客 在C.Objective-C和Java等其他语言中,整型之间有两种转换方法: 从小范围数到大范围数转换是自动的: 从大范围数到小范围数需要强制类型转换,有 ...
- C#快速整理代码格式
删除最后一个大括号,再添加.vs自动整理代码结构.
- jQuery 遍历 (each、map)
jQuery 遍历,意为“移动”,用于根据其相对于其他元素的关系来“查找”(或选取)HTML 元素.以某项选择开始,并沿着这个选择移动,直到抵达您期望的元素为止. jQuery 遍历函数 jQuery ...
- API网关性能比较：NGINX vs. ZUUL vs. Spring Cloud Gateway vs. Linkerd API 网关出现的原因
API网关性能比较:NGINX vs. ZUUL vs. Spring Cloud Gateway vs. Linkerd http://www.infoq.com/cn/articles/compa ...
- Docker Metasploit Framework
https://hub.docker.com/r/usertaken/metasploit-framework/ docker pull usertaken/metasploit-framework ...
- JavaScript数据结构与算法-列表练习
实现列表类 // 列表类 function List () { this.listSize = 0; // 列表的元素个数 this.pos = 0; // 列表的当前位置 this.dataStor ...