devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot实践之---集成Redis_spring.redis.pool.testonborrow

作者：从前慢现在也慢 | 2024-02-28 16:14:47

赞

踩

spring.redis.pool.testonborrow

1.引入依赖

build.gradle中加入

  1. 	//redis
  2. 	compile('org.springframework.data:spring-data-redis:1.8.0.RELEASE')
  3. 	compile('redis.clients:jedis:2.9.0')

2.配置Redis参数

application.properties中加入

  1. #redis
  2. spring.redis.host=172.16.3.72
  3. spring.redis.port=6379
  4. spring.redis.password=
  5. spring.redis.timeout=5000
  6. spring.redis.pool.max-active=1500
  7. spring.redis.pool.max-idle=20
  8. spring.redis.pool.max-wait=5
  9. spring.redis.pool.testOnBorrow=true
  10. spring.redis.pool.testOnReturn=true

3.编写Redis操作工具类

  1. import com.alibaba.fastjson.JSONObject;
  2. import com.my.web.enums.ERedisDomain;
  3. import com.my.web.exception.RedisException;
  4. import redis.clients.jedis.Jedis;
  5. import redis.clients.jedis.JedisPool;
  6. import redis.clients.jedis.JedisPoolConfig;
  7.  
  8. import java.util.*;
  9.  
  10. /**
  11.  * Description: 该类主要用于提供操作Redis连接池缓存的工具
  12.  **/
  13. public class RedisUtils {
  14.  
  15.     /** jedis连接池 */
  16.     private static JedisPool pool;
  17.  
  18.     /**
  19.      * 初始化redis连接
  20.      */
  21.     static  {
  22.         if (pool == null) {
  23.             // 创建jedis池配置实例
  24.             JedisPoolConfig config = new JedisPoolConfig();
  25.             String hostIP = PropertyReaderUtils.getProValue("spring.redis.host"); //Redis主机IP
  26.             Integer hostPort = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.port")); //Redis主机端口
  27.             Integer maxActive = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.max-active"));
  28.             Integer maxIdle = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.max-idle"));
  29.             Long maxWait = Long.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.max-wait"));
  30.             Boolean testOnBorrow = Boolean.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.testOnBorrow"));
  31.             Boolean testOnReturn = Boolean.valueOf(PropertyReaderUtils.getProValue("spring.redis.pool.testOnReturn"));
  32.             int timeout = Integer.valueOf(PropertyReaderUtils.getProValue("spring.redis.timeout"));
  33.             //设置池配置项值
  34.             config.setMaxTotal(maxActive);
  35.             config.setMaxIdle(maxIdle);
  36.             config.setMaxWaitMillis(maxWait);
  37.             config.setTestOnBorrow(testOnBorrow);
  38.             config.setTestOnReturn(testOnReturn);
  39.             //根据配置实例化jedis池
  40.             pool = new JedisPool(config, hostIP, hostPort, timeout);
  41.         }
  42.     }
  43.  
  44.     /**
  45.      * 添加单个Redis缓存
  46.      *
  47.      * @param domain Redis分组
  48.      * @param key Redis的组内key
  49.      * @param value Redis的组内value
  50.      * @return boolean 是否添加成功
  51.      */
  52.     public static boolean save(ERedisDomain domain, String key, Object value) {
  53.         Jedis jedis = null;
  54.         long result = 0l;
  55.         try {
  56.             jedis = getJedis();
  57.             result = jedis.hset(domain.getKey(), key, JSONObject.toJSONString(value));
  58.         } catch (Exception e) {
  59.             throw new RedisException("unable to save key " + key + " in domain " + domain.getKey(), e);
  60.         } finally {
  61.             if (null != jedis)
  62.                 jedis.close(); // 释放资源还给连接池
  63.         }
  64.         return (result == 1) ? true : false;
  65.     }
  66.  
  67.     /**
  68.      * 添加单个Redis缓存
  69.      *
  70.      * @param domain Redis分组
  71.      * @param key Redis的组内key
  72.      * @param valueJson Redis的组内value(JSON格式)
  73.      * @return boolean 是否添加成功
  74.      */
  75.     public static boolean save(ERedisDomain domain, String key, String valueJson) {
  76.         Jedis jedis = null;
  77.         long result = 0l;
  78.         try {
  79.             jedis = getJedis();
  80.             result = jedis.hset(domain.getKey(), key, valueJson);
  81.         } catch (Exception e) {
  82.             throw new RedisException("unable to save key " + key + " in domain " + domain.getKey(), e);
  83.         } finally {
  84.             close(jedis);// 释放资源还给连接池
  85.         }
  86.         return (result == 1) ? true : false;
  87.     }
  88.  
  89.     /**
  90.      * 批量添加Redis缓存
  91.      *
  92.      * @param domain Redis分组
  93.      * @param data Redis缓存数据
  94.      * @return boolean 是否添加成功
  95.      */
  96.     public static boolean batchSave(ERedisDomain domain, Map<String, Object> data) {
  97.         Jedis jedis = null;
  98.         String result = "fail";
  99.         try {
  100.             jedis = getJedis();
  101.             Map<String, String> jsonData = new HashMap<>(); //json格式的数据
  102.             for (String key : data.keySet()) {
  103.                 jsonData.put(key, JSONObject.toJSONString(data.get(key)));
  104.             }
  105.             result = jedis.hmset(domain.getKey(), jsonData);
  106.         } catch (Exception e) {
  107.             throw new RedisException("unable to batch save keys " + data.keySet() + " in domain " + domain.getKey(), e);
  108.         } finally {
  109.             close(jedis);// 释放资源还给连接池
  110.         }
  111.         return ("OK".equalsIgnoreCase(result)) ? true : false;
  112.     }
  113.  
  114.     /**
  115.      * 批量添加Redis缓存
  116.      *
  117.      * @param domain Redis分组
  118.      * @param data Redis缓存数据（值为json格式）
  119.      * @return boolean 是否添加成功
  120.      */
  121.     public static boolean batchSaveJson(ERedisDomain domain, Map<String, String> data) {
  122.         Jedis jedis = null;
  123.         String result = "fail";
  124.         try {
  125.             jedis = getJedis();
  126.             result = jedis.hmset(domain.getKey(), data);
  127.         } catch (Exception e) {
  128.             throw new RedisException("unable to batch save keys " + data.keySet() + " in domain " + domain.getKey(), e);
  129.         } finally {
  130.             close(jedis);// 释放资源还给连接池
  131.         }
  132.         return ("OK".equalsIgnoreCase(result)) ? true : false;
  133.     }
  134.  
  135.     /**
  136.      * 获取指定Redis组内的所有缓存数据
  137.      *
  138.      * @param domain Redis分组
  139.      * @return Map 缓存数据，值为json格式
  140.      */
  141.     public static Map<String, String> get(ERedisDomain domain) {
  142.         Jedis jedis = null;
  143.         Map<String, String> maps = null;
  144.         try {
  145.             jedis = getJedis();
  146.             maps = jedis.hgetAll(domain.getKey());
  147.         } catch (Exception e) {
  148.             throw new RedisException("unable to get data from domain " + domain.getKey(), e);
  149.         } finally {
  150.             close(jedis);// 释放资源还给连接池
  151.         }
  152.         return maps;
  153.     }
  154.  
  155.     /**
  156.      * 获取指定Redis组内的所有缓存数据
  157.      *
  158.      * @param domain Redis分组
  159.      * @param clazz 缓存对象的类型
  160.      * @return Map 缓存数据
  161.      */
  162.     public static <T> Map<String, T> get(ERedisDomain domain, Class<T> clazz) {
  163.         Jedis jedis = null;
  164.         Map<String, T> resultMap = new HashMap<>(); //初始化返回结果
  165.         try {
  166.             jedis = getJedis();
  167.             Map<String, String> data = jedis.hgetAll(domain.getKey()); //json格式的缓存结果
  168.             for (String key : data.keySet()) {
  169.                 JSONObject jsonCacheObj = JSONObject.parseObject(data.get(key));
  170.                 T cacheData = JSONObject.toJavaObject(jsonCacheObj, clazz);
  171.                 resultMap.put(key, cacheData);
  172.             }
  173.         } catch (Exception e) {
  174.             throw new RedisException("unable to get data from domain " + domain.getKey(), e);
  175.         } finally {
  176.             close(jedis);// 释放资源还给连接池
  177.         }
  178.         return resultMap;
  179.     }
  180.  
  181.     /**
  182.      * 获取单个缓存对象
  183.      *
  184.      * @param domain Redis分组
  185.      * @param key 缓存对象的key
  186.      * @return String json格式的缓存对象
  187.      */
  188.     public static String get(ERedisDomain domain, String key) {
  189.         Jedis jedis = null;
  190.         String retureValue = null;
  191.         try {
  192.             jedis = getJedis();
  193.             retureValue = jedis.hget(domain.getKey(), key);
  194.         } catch (Exception e) {
  195.             throw new RedisException("unable to get key " + key + " in domain " + domain.getKey(), e);
  196.         } finally {
  197.             close(jedis);// 释放资源还给连接池
  198.         }
  199.         return retureValue;
  200.     }
  201.  
  202.     /**
  203.      * 获取单个缓存对象
  204.      *
  205.      * @param domain Redis分组
  206.      * @param key 缓存对象的key
  207.      * @param clazz 缓存对象的类型
  208.      * @return T 缓存对象
  209.      */
  210.     public static <T> T get(ERedisDomain domain, String key, Class<T> clazz) {
  211.         Jedis jedis = null;
  212.         T retureObj = null;
  213.         try {
  214.             jedis = getJedis();
  215.             String jsonData = jedis.hget(domain.getKey(), key);
  216.             JSONObject jsonCacheObj = JSONObject.parseObject(jsonData);
  217.             retureObj = JSONObject.toJavaObject(jsonCacheObj, clazz);
  218.         } catch (Exception e) {
  219.             throw new RedisException("unable to get key " + key + " in domain " + domain.getKey(), e);
  220.         } finally {
  221.             close(jedis);// 释放资源还给连接池
  222.         }
  223.         return retureObj;
  224.     }
  225.  
  226.     /**
  227.      * 删除给定Redis分组的所有缓存
  228.      *
  229.      * @param domain Redis分组
  230.      * @return boolean 是否删除成功
  231.      */
  232.     public static boolean delete(ERedisDomain domain) {
  233.         Jedis jedis = null;
  234.         long result = 0l;
  235.         try {
  236.             jedis = getJedis();
  237.             result = jedis.del(domain.getKey());
  238.         } catch (Exception e) {
  239.             throw new RedisException("unable to delete data in domain " + domain.getKey(), e);
  240.         } finally {
  241.             close(jedis);// 释放资源还给连接池
  242.         }
  243.         return (result == 1) ? true : false;
  244.     }
  245.  
  246.     /**
  247.      * 删除缓存
  248.      *
  249.      * @param domain 缓存所属分组
  250.      * @param keys 缓存对象的key
  251.      * @return boolean 是否删除成功
  252.      */
  253.     public static boolean delete(ERedisDomain domain, String... keys) {
  254.         Jedis jedis = null;
  255.         long result = 0l;
  256.         try {
  257.             jedis = getJedis();
  258.             result = jedis.hdel(domain.getKey(), keys);
  259.         } catch (Exception e) {
  260.             throw new RedisException("unable to delete keys " + keys + " in domain " + domain.getKey(), e);
  261.         } finally {
  262.             close(jedis);// 释放资源还给连接池
  263.         }
  264.         return (result == 1) ? true : false;
  265.     }
  266.  
  267.     /**
  268.      * 获取给定分组的所有Redis缓存对象
  269.      *
  270.      * @param domain Redis分组
  271.      * @return List json格式的缓存对象列表
  272.      */
  273.     public static List<String> getValues(ERedisDomain domain) {
  274.         Jedis jedis = null;
  275.         List<String> retureList = null;
  276.         try {
  277.             jedis = getJedis();
  278.             retureList = jedis.hvals(domain.getKey());
  279.         } catch (Exception e) {
  280.             throw new RedisException("unable to delete data in domain " + domain.getKey(), e);
  281.         } finally {
  282.             close(jedis);// 释放资源还给连接池
  283.         }
  284.         return retureList;
  285.     }
  286.  
  287.     /**
  288.      * 获取给定分组的所有Redis缓存对象
  289.      *
  290.      * @param domain Redis分组
  291.      * @param clazz 缓存对象类型
  292.      * @return List 缓存对象列表
  293.      */
  294.     public static <T> List<T> getValues(ERedisDomain domain, Class<T> clazz) {
  295.         Jedis jedis = null;
  296.         List<T> result = new ArrayList<>(); //初始化返回结果
  297.         try {
  298.             jedis = getJedis();
  299.             List<String> cacheObjs = jedis.hvals(domain.getKey());
  300.             for (String cache : cacheObjs) {
  301.                 JSONObject jsonCacheObj = JSONObject.parseObject(cache);
  302.                 result.add(JSONObject.toJavaObject(jsonCacheObj, clazz));
  303.             }
  304.         } catch (Exception e) {
  305.             throw new RedisException("unable to get data in domain " + domain.getKey(), e);
  306.         } finally {
  307.             close(jedis);// 释放资源还给连接池
  308.         }
  309.         return result;
  310.     }
  311.  
  312.     /**
  313.      * 获取给定分组的所有Redis缓存key
  314.      *
  315.      * @param domain Redis分组
  316.      * @return Set 缓存key集
  317.      */
  318.     public static Set<String> getKeys(ERedisDomain domain) {
  319.         Jedis jedis = null;
  320.         Set<String> retureSet = null;
  321.         try {
  322.             jedis = getJedis();
  323.             retureSet = jedis.hkeys(domain.getKey());
  324.         } catch (Exception e) {
  325.             throw new RedisException("unable to get keys in domain " + domain.getKey(), e);
  326.         } finally {
  327.             close(jedis);// 释放资源还给连接池
  328.         }
  329.         return retureSet;
  330.     }
  331.  
  332.  
  333.     /**
  334.      * 获取Jedis实例
  335.      *
  336.      * @return
  337.      */
  338.     private synchronized static Jedis getJedis() {
  339.         if (pool != null) {
  340.             return pool.getResource();
  341.         } else {
  342.             return null;
  343.         }
  344.     }
  345.  
  346.     /**
  347.      * 释放jedis资源
  348.      *
  349.      * @param jedis
  350.      */
  351.     private static void close(final Jedis jedis) {
  352.         if (jedis != null) {
  353.             jedis.close();
  354.         }
  355.     }
  356. }

4.实际使用

  1. //取值        
  2. Set<String> loginTokens = RedisUtils.getKeys(ERedisDomain.TOKEN_LOGIN_USER);
  3. //存值
  4.  RedisUtils.save(ERedisDomain.USER_REQUEST_TIME, userID, currentTimeMillis);

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/160076
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号