jredis 工具_Redis工具类

packagenet.wwwyibu.filter;importjava.io.IOException;importjava.net.InetAddress;importjava.net.UnknownHostException;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjava.util.Set;importorg.apache.log4j.Logger;importorg.json.JSONException;importnet.sf.json.JSONObject;importnet.sf.json.JsonConfig;importnet.sf.json.util.PropertySetStrategy;importredis.clients.jedis.Jedis;importredis.clients.jedis.JedisPool;importredis.clients.jedis.JedisPoolConfig;importredis.clients.jedis.JedisShardInfo;importredis.clients.jedis.ShardedJedis;importredis.clients.jedis.ShardedJedisPool;importredis.clients.jedis.Tuple;/***@author马家立

*@version创建时间：2020-7-29 16:54:56

* @Description:TODO Redis工具类

* @Description:TODO 菜鸟教程--https://www.runoob.com/redis/redis-tutorial.html* @Description:TODO w3cschool教程--https://www.w3cschool.cn/redis/redis-commands.html

*/

public classRedisUtil {private static Logger log = Logger.getLogger(RedisUtil.class);/*** --获取redis的ip*/

private static String redisIp =getRedisIp();/*** --非切片客户端链接*/

privateJedis jedis;/*** --非切片链接池*/

privateJedisPool jedisPool;/*** --切片客户端链接*/

privateShardedJedis shardedJedis;/*** --切片客户端链接池*/

privateShardedJedisPool shardedJedisPool;/*** --构造函数*/

publicRedisUtil() {

initialJedisPool();

initialShardedJedisPool();

}publicJedis getJedis() {if (jedis == null) {

initialJedisPool();

}returnjedis;

}public voidsetJedis(Jedis jedis) {this.jedis =jedis;

}publicShardedJedis getShardedJedis() {if (shardedJedis == null) {

initialShardedJedisPool();

}returnshardedJedis;

}public voidsetShardedJedis(ShardedJedis shardedJedis) {this.shardedJedis =shardedJedis;

}/*** @Title:getIp

* @Description:TODO 获取redis的ip

*@author:马家立

* @date:2020-7-29 17:00:51

*@returnString*/

staticString getRedisIp() {try{returnInetAddress.getLocalHost().getHostAddress();

}catch(UnknownHostException e) {

e.printStackTrace();

}return "127.0.0.1";

}/*** @Title:initialJedisPool

* @Description:TODO 初始化非切片客户端链接

*@author:马家立

* @date:2020-7-30 16:39:05 void*/

private voidinitialJedisPool() {//Jedis连接池配置

JedisPoolConfig config = newJedisPoolConfig();/*** --控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；

* --最大连接数：如果赋值为-1，则表示不限制；如果pool已经分配了maxActive(最大连接数)个jedis实例，则此时pool的状态为exhausted(耗尽)。*/config.setMaxActive(300);//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。

config.setMaxIdle(100);//设置最大阻塞时间：表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；

config.setMaxWait(1000 * 5);//在borrow(引入)一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

config.setTestOnBorrow(false);

jedisPool= new JedisPool(config, redisIp, 6379);

setJedis(jedisPool.getResource());

}/*** @Title:initialShardedJedisPool

* @Description:TODO 初始化切片客户端链接

*@author:马家立

* @date:2020-7-30 16:39:29 void*/

private voidinitialShardedJedisPool() {//Jedis连接池配置

JedisPoolConfig config = newJedisPoolConfig();/*** --控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；

* --最大连接数：如果赋值为-1，则表示不限制；如果pool已经分配了maxActive(最大连接数)个jedis实例，则此时pool的状态为exhausted(耗尽)。*/config.setMaxActive(300);//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。

config.setMaxIdle(100);//设置最大阻塞时间：表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；

config.setMaxWait(1000 * 5);//在borrow(引入)一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

config.setTestOnBorrow(false);//slave链接

List shards = new ArrayList();

shards.add(new JedisShardInfo(redisIp, 6379));

shardedJedisPool= newShardedJedisPool(config, shards);

setShardedJedis(shardedJedisPool.getResource());

}/*** @Title:jedisMethod

* @Description:TODO jedis相关方法

*@author:马家立

* @date:2020-7-30 16:53:10 void*/

public voidjedisMethod() {

jedis=getJedis();//清空链接数据

jedis.flushDB();

jedis.echo("foo");//交集

System.out.println(jedis.sinter("" + "", "sets2"));//并集

System.out.println(jedis.sunion("sets1", "sets2"));//差集

System.out.println(jedis.sdiff("sets1", "sets2"));

System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2", "mset3", "mvalue3", "mset4", "mvalue4"));

System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4"));

System.out.println(jedis.del(new String[] {"foo", "foo1", "foo3"}));

}/*** @Description:TODO String类型开始*/

voidString_Type_Start() {}/*** @Title:set

* @Description:TODO 储存某个Key和值

*@author:马家立

* @date:2020-7-28 15:07:56

*@paramKey--存储的key

*@paramvalue--存储的值

*@returnboolean*/

public booleanset(String Key, String value) {try{

getShardedJedis().set(Key, value);//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(getShardedJedis());return true;

}catch(Exception e) {

e.printStackTrace();//否则调用returnResource()返回正常链接

shardedJedisPool.returnResource(getShardedJedis());return false;

}

}/*** @Title:setex

* @Description:TODO 存储某个Key和值并设置超时时间

*@author:马家立

* @date:2020-7-28 15:06:25

*@paramKey--存储的key

*@paramtime--超时时间(秒)

*@paramvalue--存储的值

*@returnboolean*/

public boolean setex(String Key, inttime, String value) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

jedis.setex(Key, time, value);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:expire

* @Description:TODO 设置 key 的过期时间，key 过期后将不再可用。单位以秒计。

*@author:马家立

* @date:2020-7-29 16:46:39

*@paramKey

*@paramtime

*@returnboolean*/

public boolean expire(String Key, inttime) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();//设置成功返回 1 。 当 key 不存在或者不能为 key 设置过期时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的过期时间)返回 0 。

jedis.expire(Key, time);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:setObject

* @Description:TODO 存储某个Key和Object对象值

*@author:马家立

* @date:2020-7-28 15:14:12

*@paramkey--存储的key

*@paramvalue--存储的Object对象值

*@returnboolean*/

public booleansetObject(String key, Object value) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

log.info("set = " + key + " 转化前 value=" +value);

String objectJson= "";if ((value instanceof String) || (value instanceof JSONObject)) {//如果传进来的是String或者JSONObject，不进行转换

objectJson = value + "";

}else {//是普通对象，进行beanToJson转化

JSONObject jsonObject =JSONObject.fromObject(value);

objectJson=jsonObject.toString();

}

log.info("Inkeys = " + key + " 转化后InValue=" +objectJson);

jedis=getShardedJedis();

jedis.set(key, objectJson);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.info("setObject缓存方法出错");

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:get

* @Description:TODO 获取某个key的value

*@author:马家立

* @date:2020-7-28 15:03:05

*@paramKey--redis存储的key

*@returnString*/

publicString get(String Key) {

String end= null;

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

end=jedis.get(Key);returnend;

}catch(Exception e) {

error= true;

e.printStackTrace();return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:getObject

* @Description:TODO 获取某个key的对象value

*@author:马家立

* @date:2020-7-28 15:16:32

*@paramkey----存储的key

*@paramclas--该key对应的对象值

*@returnObject*/

publicObject getObject(String key, Class clas) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

String value=jedis.get(key);//根据json字符串解析class对象

returnjsonToBean(value, clas);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.info("getObject缓存方法出错");

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:del

* @Description:TODO 删除某个key

*@author:马家立

* @date:2020-7-28 18:07:36

*@paramKey--被删除的key

*@returnboolean*/

public booleandel(String Key) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

jedis.del(Key);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:exists

* @Description:TODO 判断某个key是否存在

*@author:马家立

* @date:2020-7-28 18:08:44

*@paramkey--要判断的key

*@returnboolean*/

public booleanexists(String key) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();returnjedis.exists(key);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:existsttl

* @Description:TODO 给定 key 的剩余生存时间(单位:s)

*@author:马家立

* @date:2020-7-29 16:08:14

*@paramkey

*@returnLong*/

publicLong existsttl(String key) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

Long i=jedis.ttl(key);returni;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return -1L;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Description:TODO Hash类型开始*/

voidHash_Type_Start() {}/*** @Title:setHash

* @Description:TODO 储存某个Key和hash对象值

*@author:马家立

* @date:2020-7-28 15:28:36

*@paramkey--存储的key

*@parammap--存储的hash对象值

*@returnboolean*/

public boolean setHash(String key, Mapmap) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

jedis.hmset(key, map);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.info("setHash缓存方法出错");

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:setHashKey

* @Description:TODO 储存某个Key中hash对象值中的key值:如果哈希表不存在，创建一个新的哈希表并进行 HSET操作；如果字段已经存在于哈希表中，旧值将被覆盖。

*@author:马家立

* @date:2020-7-28 15:29:56

*@paramkey--存储的hash的key

*@paraminkey--hash对象中的key

*@paramvalue--hash对象中的key对应存储的值

*@returnboolean*/

public booleansetHashKey(String key, String inkey, String value) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();//如果字段是哈希表中的一个新建字段，并且值设置成功，返回 1 。 如果哈希表中域字段已经存在且旧值已被新值覆盖，返回 0

jedis.hset(key, inkey, value);//jedis.disconnect();

return true;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.info("setHash缓存方法出错");

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:hget

* @Description:TODO 读取某个hash表中的某个key所对应的value值

*@author:马家立

* @date:2020-7-28 17:58:03

*@paramkey--存储的hash的key

*@paraminkey--hash中的key

*@returnString*/

publicString hget(String key, String inkey) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();returnjedis.hget(key, inkey);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:hkeys

* @Description:TODO 获取哈希表中的key

*@author:马家立

* @date:2020-7-28 18:00:44

*@paramkey--存储的hash的key

*@returnSet*/

public Sethkeys(String key) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();returnjedis.hkeys(key);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:hgetAll

* @Description:TODO 获取哈希表中，所有的字段和值。

*@author:马家立

* @date:2020-7-29 16:33:24

*@paramkey

*@returnMap*/

public MaphgetAll(String key) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();returnjedis.hgetAll(key);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:delHash

* @Description:TODO 删除哈希表 key中的一个或多个指定字段，不存在的字段将被忽略

*@author:马家立

* @date:2020-7-28 15:48:32

*@paramkey--存储的hash的key

*@paraminkey--hash中的key

*@returnboolean*/

public booleandelHash(String key, String inkey) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

jedis.hdel(key, inkey);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Description:TODO List类型开始*/

voidList_Type_Start() {}/*** @Title:lpush

* @Description:TODO 将一个或多个值插入到列表头部。 如果 key不存在，一个空列表会被创建并执行 LPUSH 操作。 当 key存在但不是列表类型时，返回一个错误。

*@author:马家立

* @date:2020-7-29 16:16:34

*@paramKey

*@paramvalue

*@returnboolean*/

public booleanlpush(String Key, String value) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();//value可为数组

jedis.lpush(Key, value);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/***

* @Title:rpush

* @Description:TODO 将一个或多个值插入到列表的尾部(最右边)。如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。

*@author:马家立

* @date:2020-7-29 16:34:58

*@paramkey

*@paramvalue

*@returnboolean*/

public booleanrpush(String key, String value) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

jedis.rpush(key, value);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:lpop

* @Description:TODO 移除并返回列表的第一个元素

*@author:马家立

* @date:2020-7-29 16:39:22

*@paramkey

*@returnString 列表的第一个元素。 当列表 key 不存在时，返回 nil*/

publicString lpop(String key) {

String value= null;

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

value=jedis.lpop(key);returnvalue;

}catch(Exception e) {

error= true;

e.printStackTrace(); log.error(e.getMessage(), e);returnvalue;

}finally{if(jedis!=null){if(shardedJedisPool!=null){if(error){//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else{//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:rpop

* @Description:TODO 移除并返回列表的最后一个元素

*@author:马家立

* @date:2020-7-29 16:39:22

*@paramkey

*@returnString 列表的最后一个元素。 当列表 key 不存在时，返回 nil*/

publicString rpop(String key) {

String value= null;

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

value=jedis.rpop(key);returnvalue;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);returnvalue;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:lrem

* @Description:TODO 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。

* @Description:TODO COUNT 的值可以是以下几种：

* @Description:TODO count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。

* @Description:TODO count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。

* @Description:TODO count = 0 : 移除表中所有与 VALUE 相等的值。

*@author:马家立

* @date:2020-7-29 16:27:09

*@paramKey

*@paramvalue

*@returnString*/

public String lrem(String Key, intcount, String value) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

jedis.lrem(Key, count, value);return "0";

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return "-1";

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:lrange

* @Description:TODO 读取某个key并以并返回start~end区间中的list数据

*@author:马家立

* @date:2020-7-29 16:19:08

*@paramKey

*@paramstart

*@paramend

*@returnList*/

public List lrange(String Key, int start, intend) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();//若jedis.lrange(Key, 0, -1)则返回list所有数据

returnjedis.lrange(Key, start, end);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:ltrim

* @Description:TODO 保留指定区间内的元素，不在指定区间之内的元素都将被删除。

*@author:马家立

* @date:2020-7-29 16:23:39

*@paramKey

*@paramstart

*@paramend

*@returnboolean*/

public boolean ltrim(String Key, int start, intend) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();/*** -- 若jedis.lrange(Key, 0, -1)则返回list所有数据 --若命令执行成功时，返回 ok 。*/

return "ok".equals(jedis.ltrim(Key, start, end)) ? true : false;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:getListSize

* @Description:TODO 获取List的长度

*@author:马家立

* @date:2020-7-29 15:36:44

*@paramkey

*@returnlong*/

public longgetListSize(String key) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

long length = 0L;try{

jedis=getShardedJedis();

length=jedis.llen(key);returnlength;

}catch(Exception e) {

error= true;

log.error("llen error", e);returnlength;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:queueExists

* @Description:TODO 判断队列是否存在

*@author:马家立

* @date:2020-7-29 16:06:49

*@paramname

*@returnboolean*/

public booleanqueueExists(String name) {if(exists(name)) {//key存在，获得长度

return getListSize(name) > 0 ? true : false;

}return false;

}/*** @Description:TODO Set类型开始*/

voidSet_Type_Start() {}/*** @Description:TODO Sorted Set类型开始*/

voidSortedSet_Type_Start() {}/*** @Title:zadd

* @Description:TODO 储存一个对象到Sorted-Sets

*@author:马家立

* @date:2020-7-28 16:02:54

*@paramkey--存储的Set集合的key

*@paramscore--分数

*@parammember--成员

*@returnboolean*/

public boolean zadd(String key, doublescore, String member) {

log.info("zadd--------key:" + key + ",score:" + score + ",member:" +member);

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

Long end=jedis.zadd(key, score, member);

log.info("zadd--------end jedis.zadd:" +end);return true;

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return false;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}//jedis.disconnect();

}

}

}/*** @Title:zrevrangeWithScores

* @Description:TODO 从小到大取出Sorted-Sets

*@author:马家立

* @date:2020-7-28 16:06:31

*@paramkey--存储的Set集合的key

*@paramstart--开始分值

*@paramend--结束分值

*@returnSet*/

public Set zrevrangeWithScores(String key, int start, intend) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();//jedis.zrevrangeWithScores(key, 0, -1);0,-1:返回所有

returnjedis.zrevrangeWithScores(key, start, end);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:zrangeWithScores

* @Description:TODO 从大到小取出Sorted-Sets

*@author:马家立

* @date:2020-7-28 16:43:27

*@paramkey--存储的Set集合的key

*@paramstart--开始分值

*@paramend--结束分值

*@returnSet*/

public Set zrangeWithScores(String key, int start, intend) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();//jedis.zrangeWithScores(key, 0, -1);0,-1:返回所有

returnjedis.zrangeWithScores(key, start, end);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:zrange

* @Description:TODO 从小到大取出Sorted-Sets

*@author:马家立

* @date:2020-7-28 17:53:21

*@paramkey--存储的Set集合的key

*@paramstart--开始分值

*@paramend--结束分值

*@returnSet*/

public Set zrange(String key, int start, intend) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();returnjedis.zrange(key, start, end);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:zrangeByScore

* @Description:TODO 返回所有符合条件start < score <= end的成员；

*@author:马家立

* @date:2020-7-28 17:54:04

*@paramkey--存储的Set集合的key

*@paramstart--开始分值

*@paramend--结束分值

*@returnSet*/

public SetzrangeByScore(String key, Double start, Double end) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();returnjedis.zrangeByScore(key, start, end);

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return null;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:zrem

* @Description:TODO 从Sorted-Sets中移除的一个或多个成员，不存在的成员将被忽略。

*@author:马家立

* @date:2020-7-28 18:02:12

*@paramkey--存储的Set集合的key

*@paraminkey--Set集合中的key

*@returnString*/

publicString zrem(String key, String inkey) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();//被成功移除的成员的数量，不包括被忽略的成员。

System.out.println(jedis.zrem(key, inkey));return "0";

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return "-1";

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:zremrangebyscore

* @Description:TODO 从Sorted-Sets 中移除指定分数(score)区间内的所有成员

*@author:马家立

* @date:2020-7-28 18:05:39

*@paramkey--存储的Set集合的key

*@paramstart--开始分值

*@paramend--结束分值

*@returnString*/

publicString zremrangebyscore(String Key, Double start, Double end) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

try{

jedis=getShardedJedis();

System.out.println(jedis.zremrangeByScore(Key, start, end));return "0";

}catch(Exception e) {

error= true;

e.printStackTrace();

log.error(e.getMessage(), e);return "-1";

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}//jedis.disconnect();

}

}/*** @Title:getsortedSetSize

* @Description:TODO 获取Sorted Set的长度

*@author:马家立

* @date:2020-7-29 16:01:52

*@paramkey--获取SortedSet集合的key

*@returnlong*/

public longgetSortedSetSize(String key) {

ShardedJedis jedis= null;boolean error = false;//标记缓存操作过程是否出现异常

long length = 0L;try{

jedis=getShardedJedis();

length=jedis.zcard(key);returnlength;

}catch(Exception e) {

error= true;

log.error("llen error", e);returnlength;

}finally{if (jedis != null) {if (shardedJedisPool != null) {if (error) {//如果操作过程出现异常，调用returnBrokenResource()返回有问题的链接

shardedJedisPool.returnBrokenResource(jedis);

}else {//否则调用returnResource()正常返回链接

shardedJedisPool.returnResource(jedis);

}

}

}

}

}/*** @Title:jsonToBean

* @Description:TODO 根据json字符串解析class对象

*@author:马家立

* @date:2020-7-28 15:18:36

*@paramjsonString--json字符串

*@paramclas--class对象

*@returnObject*/

public static Object jsonToBean(String jsonString, Class>clas) {

JSONObject jo=JSONObject.fromObject(jsonString);

JsonConfig cfg= newJsonConfig();

Map classMap = new HashMap();

cfg.setClassMap(classMap);

cfg.setRootClass(clas);

cfg.setPropertySetStrategy(PropertySetStrategy.DEFAULT);returnJSONObject.toBean(jo, cfg);

}public static void main(String[] args) throwsJSONException, IOException {//RedisUtil redis = new RedisUtil();//redis.setHashKey("yayaya", "1", "haha");//redis.setHashKey("yayaya", "2", "hehe");//redis.setHashKey("yayaya", "3", "lala");// //redis.expire("yayaya", 10);//Set hgets = redis.hkeys("yayaya");//for (String string : hgets) {//String value = redis.hget("yayaya", string);//System.out.println("string:" + string + ",value:" + value);//}

List values = new ArrayList();

String[] ss= values.toArray(newString[values.size()]);

}

}