redis工具类

最新推荐文章于 2019-07-15 21:02:13 发布
最新推荐文章于 2019-07-15 21:02:13 发布
阅读量121 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heihei_100/article/details/80688478
版权 
import java.util.List;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ziku.ms.youle.common.BasicEnums.ErrorCode;
import com.ziku.ms.youle.common.BasicEnums.RedisKeyPrefixEnum;
import com.ziku.ms.youle.exception.BizException;

import lombok.extern.slf4j.Slf4j;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.exceptions.JedisConnectionException;

@Slf4j
@Component
public class CacheKit {
   private List<JSONObject> resultList;

   @Autowired
   private JedisPool jedisPool;

   /**
    * 获取Jedis实例
    */
   public Jedis getJedis() {
      int timeoutCount = 0;
      while (true) {
         try {
            if (null != jedisPool) {
               return jedisPool.getResource();
            }
         } catch (Exception e) {
            if (e instanceof JedisConnectionException) {
               timeoutCount++;
               log.warn("getJedis timeoutCount={}", timeoutCount);
               if (timeoutCount > 3) {
                  break;
               }
            } else {
               log.warn("jedisInfo ... NumActive=" + jedisPool.getNumActive() + ", NumIdle=" + jedisPool.getNumIdle() + ", NumWaiters=" + jedisPool.getNumWaiters() + ", isClosed=" + jedisPool.isClosed());

               log.error("GetJedis error,", e);
               break;
            }
         }
         break;
      }
      return null;
   }
   
   /**
    * 
    * 获取缓存剩余有效时间 返回秒数
    * 
    * @Title getExpire
    * @Description TODO
    * @param key
    * @return Long
    */
   public Long getExpire(String key) {
      Jedis jedis = getJedis();
      int timeoutCount = 0;

      while (true) {
         if (null != jedis) {
            break;
         } else {
            timeoutCount++;
            jedis = getJedis();
            if (timeoutCount > 3) {
               break;
            }
         }
      }
      Long value = jedis.ttl(key);
      returnResource(jedis);
      return value;
   }

   /**
    * 
    * 获取缓存剩余有效时间 返回毫秒数
    * 
    * @Title getPExpire
    * @Description TODO
    * @param key
    * @return Long
    */
   public Long getPExpire(String key) {
      Jedis jedis = getJedis();
      int timeoutCount = 0;

      while (true) {
         if (null != jedis) {
            break;
         } else {
            timeoutCount++;
            jedis = getJedis();
            if (timeoutCount > 3) {
               break;
            }
         }
      }
      Long value = jedis.pttl(key);
      returnResource(jedis);
      return value;
   }

   /**
    * 释放Jedis资源
    * 
    * @param jedis
    */
   public void returnResource(Jedis jedis) {
      if (null != jedis) {
         jedis.close();
         // jedisPool.returnResourceObject(jedis);
      }
   }

   /**
    * 绝对获取方法（保证一定能够使用可用的连接获取到 目标数据） Jedis连接使用后放回
    * 
    * @param key
    * @return
    */
   public String safeGet(String key) {
      Jedis jedis = getJedis();
      int timeoutCount = 0;

      while (true) {
         if (null != jedis) {
            break;
         } else {
            timeoutCount++;
            jedis = getJedis();
            if (timeoutCount > 3) {
               break;
            }
         }
      }
      if (jedis == null) {
         return null;
      }

      String value = jedis.get(key);
      returnResource(jedis);
      return value;
   }

   /**
    * 绝对设置方法（保证一定能够使用可用的链接设置 数据） Jedis连接使用后返回连接池
    * 
    * @param key
    * @param time
    * @param value
    */
   public void safeSet(String key, int seconds, String value) {

      Jedis jedis = getJedis();
      int timeoutCount = 0;

      while (true) {
         if (null != jedis) {
            break;
         } else {
            jedis = getJedis();
            timeoutCount++;
            if (timeoutCount > 3) {
               break;
            }
         }
      }
      if (jedis == null) {
         return;
      }

      jedis.setex(key, seconds, value);
      returnResource(jedis);
   }

   /**
    * 绝对设置方法（保证一定能够使用可用的链接设置 数据） Jedis连接使用后返回连接池
    * 
    * @param key
    * @param time
    * @param value
    */
   public void safeSet(String key, long milliSeconds, String value) {

      Jedis jedis = getJedis();
      int timeoutCount = 0;

      while (true) {
         if (null != jedis) {
            break;
         } else {
            jedis = getJedis();
            timeoutCount++;
            if (timeoutCount > 3) {
               break;
            }
         }
      }
      if (jedis == null) {
         return;
      }

      jedis.psetex(key, milliSeconds, value);
      returnResource(jedis);
   }

   /**
    * 绝对删除方法（保证删除绝对有效） Jedis连接使用后返回连接池</span>
    * 
    * @param key
    */
   public void safeDel(String key) {
      Jedis jedis = getJedis();
      while (true) {
         if (null != jedis) {
            break;
         } else {
            jedis = getJedis();
         }
      }
      jedis.del(key);
      returnResource(jedis);
   }

   /** 自定义的一些 get set del 方法，方便使用 **/
   public JSONObject getByCache(String key) {
      String result = safeGet(key);
      if (result != null) {
         return (JSONObject) JSONObject.parse(result);
      }
      return null;

   }

   public String getByCacheToString(String key) {
      String result = safeGet(key);
      if (result != null) {
         return result;
      }
      return null;

   }

   public List<JSONObject> getArrayByCache(String key) {
      String result = safeGet(key);
      if (result != null) {
         resultList = JSONArray.parseArray(result, JSONObject.class);
         return resultList;
      }
      return null;
   }

   public JSONArray getJSONArrayByCache(String key) {
      String result = safeGet(key);
      if (result != null) {
         return JSONArray.parseArray(result);
      }
      return null;
   }

   public void setByCache(String key, String s) {
      safeSet(key, 86400, s);
   }

   public void setByCacheOneHour(String key, String s) {
      safeSet(key, 3600, s);
   }

   public void setByCacheOneHour(String key, List<JSONObject> json) {
      safeSet(key, 86400, JSONObject.toJSONString(json));
      resultList = json;
   }

   public void setByCache(String key, JSONObject json) {
      safeSet(key, 86400, JSONObject.toJSONString(json));
   }

   public void setByCache(String key, List<JSONObject> list) {
      safeSet(key, 86400, JSONObject.toJSONString(list));
      resultList = list;
   }

   public void setByCache(String key, JSONArray array) {
      safeSet(key, 86400, JSONArray.toJSONString(array));
   }

   public void setByCacheCusTime(String key, String s, int time) {
      safeSet(key, time, s);
   }

   public void delByCache(String key) {
      if (null != safeGet(key)) {
         safeDel(key);
      }
   }

   // public JSONObject toJSON(DBObject db) {
   // return (JSONObject) JSONObject.toJSON(db);
   // }
   //
   // public List<JSONObject> toJSON(List<DBObject> list) {
   // List<JSONObject> json = new ArrayList<>();
   // for (DBObject aList : list) {
   // json.add((JSONObject) JSONObject.toJSON(aList));
   // }
   // return json;
   // }

   public boolean notNull() {
      return resultList != null && resultList.size() > 0;
   }

   public List<JSONObject> getResult() {
      return resultList;
   }

   public Set<String> keys(String key) {
      Jedis jedis = getJedis();
      int timeoutCount = 0;

      while (true) {
         if (null != jedis) {
            break;
         } else {
            timeoutCount++;
            jedis = getJedis();
            if (timeoutCount > 3) {
               break;
            }
         }
      }
      if (jedis == null) {
         return null;
      }
      Set<String> value = jedis.keys(key + "*");
      returnResource(jedis);
      return value;
   }

   /**
    * 
    * @Title generateOperationLock
    * @Description TODO 用户操作重复提交锁
    * @param redisKeyPrefixEnum
    * @param suffix
    * @param milliSeconds
    * @return void
    */
   public void generateOperationLock(RedisKeyPrefixEnum redisKeyPrefixEnum, String suffix, Long milliSeconds) {
      if (milliSeconds == null) {
         milliSeconds = (long) 500;
      }
      if (StringUtils.isEmpty(suffix)) {
         throw new BizException("-1", "参数错误");
      }
      String key = redisKeyPrefixEnum + suffix;
      Object obj = this.safeGet(key);
      if (obj != null && obj.toString().equalsIgnoreCase("locked")) {
         throw new BizException(ErrorCode.OPERATION_FREQUENTLY);
      }
      this.safeSet(key, milliSeconds, "locked");
   }

   /**
    * 获取缓存数据。<br>
    * 如果key不存在，则返回null
    * 
    * @param redisKeyPrefixEnum
    * @param suffix
    * @return
    * @throws Exception
    */
   private String getCacheData(RedisKeyPrefixEnum redisKeyPrefixEnum, String suffix) {
      if (StringUtils.isEmpty(suffix)) {
         throw new BizException("-1", "参数错误");
      }
      String key = redisKeyPrefixEnum.getKey() + suffix;
      Object obj = this.safeGet(key);
      if (obj != null) {
         return obj.toString();
      }
      return null;
   }

   /**
    * 生成缓存数据。<br>
    * 如果key存在，则不生成，直接返回
    * 
    * @param redisKeyPrefixEnum
    * @param suffix
    * @param value
    * @param seconds
    * @return
    * @throws Exception
    */
   private String generateCacheData(RedisKeyPrefixEnum redisKeyPrefixEnum, String suffix, String value, Integer seconds) {
      if (seconds == null) {
         seconds = 7200;
      }
      if (StringUtils.isEmpty(suffix)) {
         throw new BizException("-1", "参数错误");
      }
      String key = redisKeyPrefixEnum.getKey() + suffix;
      Object obj = this.safeGet(key);
      if (obj != null) {
         return obj.toString();
      }
      this.safeSet(key, seconds, value);
      return value;
   }

   public String generateWechartAccessToken(RedisKeyPrefixEnum redisKeyPrefixEnum, String suffix, String value, Integer seconds) {
      if (seconds == null) {
         seconds = 7200;
      }
      return this.generateCacheData(redisKeyPrefixEnum, suffix, value, seconds);
   }

   public String getWechartAccessToken(RedisKeyPrefixEnum redisKeyPrefixEnum, String suffix) {
      return this.getCacheData(redisKeyPrefixEnum, suffix);
   }
}
heihei_100
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis通用工具类
T`
10-21 1万+
public class RedisUtil { private static final Logger LOGGER = Logger.getLogger(RedisUtil.class); private static JedisPool pool = null; private static RedisUtil ru = new RedisUtil();
Redis工具类
09-27
在Java开发中，为了方便地操作Redis，通常会封装一个Redis工具类，提高代码的复用性和易用性。本篇文章将深入探讨标题为"Redis工具类"的知识点，包括`valueOperations`和`RedisTemplate`的使用，以及它们在`Redis...
redis utils 工具类
07-08
Redis Utils工具类是Java开发中常见的一种封装，用于简化与Redis数据库的交互操作。Redis是一种高性能的键值存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。在Java开发中，为了提高代码的可读性和复用...
最详细的redis
12-09
里面包括两个解压文件和一个安装程序，解压文件直接解压，通过终端运行redis-server.exe和redis.conf来启动redis，安装程序为redis的图形界面系统，点击安装，安装完成后connect，填写localhost和post来连接redis。
java的redis工具类
weixin_30239339的博客
04-09 111
package com.mracale.sell.utils; /** * @Auther: Mracale */ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import ...
RedisUtil工具类
奋斗不息
07-15 615
转载： https://github.com/whvcse/RedisUtil 这已经很全了，先记录一下，然后实践一下
Redis进阶实践之九 独立封装的RedisClient客户端工具类（转载9）
dichi4045的博客
02-07 143
一、引言 今天开始有关Redis学习的第九篇文章了，以后肯定会大量系统使用Redis作为缓存介质，为了更好的更好的Redis，自己写了两个工具类，但是这两个工具类，没有提供一致的接口，是为了使用的独立性。测试已经完毕，可以正常访问Windows和Linux版本上的Redis服务，各种操作也没问题。今天就把主要代码贴出来，因为有一部分是需要配置文件的，我自己独立写了一套配置系统...
【Redis】Java之Redis工具类（转）
qq_33872233的博客
05-18 228
我就不介绍Redis是什么了。 (一个月前写的工具类，一直忘记分享了，算是比较全的Java-Redis工具类) 直接上代码吧。先给出在spring 中配置Redis的代码。你在其他类用的时候，直接用注解自动注入就可以了。##访问地址 redis.host=127.0.0.1 ##访问端口 redis.port=6379 ##注意，如果没有password，此处不设置值，但这一项要保留 redis....
开发手记---JAVA数据库连接池
Bing_GoGo技术博客
09-09 1973
作用: 在数据库存取中,数据库连接池是不可缺少的,它可以提高连接利用率 减少连接等待,对于提高数据存储性能会有不小的作用. 原理: 连接池相当于连接的集合,在连接池初始化时先实例化一定数量的空闲连接 等待用户使用,用户使用完连接再将其返回连接池,这样就免去了最耗时的 创建连接的开销在没有空闲连接的情况下,连接池将自动生成连接再分配给 用户请求.   实例: package sh
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值