Redis客户端之Spring整合Jedis

最新推荐文章于 2024-08-12 10:57:28 发布
最新推荐文章于 2024-08-12 10:57:28 发布
阅读量1.3k 收藏
点赞数
分类专栏： redis Java开发 文章标签： redis spring整合
1.下载相关jar包，并引入工程：
jedis-2.4.2.jar
commons-pool2-2.0.jar
2.将以下XML配置引入spring

  1. <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
  2.         <constructor-arg index="0" ref="jedisPoolConfig"/>
  3.         <constructor-arg index="1">
  4.             <list>
  5.                  <bean name="slaver" class="redis.clients.jedis.JedisShardInfo">
  6.                     <constructor-arg index="0" value="${redis.slaver.host}"/>
  7.                     <constructor-arg index="1" value="${redis.slaver.port}" type="int"/>
  8.                 </bean>
  9.                  <bean name="master" class="redis.clients.jedis.JedisShardInfo">
  10.                     <constructor-arg index="0" value="${redis.master.host}"/>
  11.                     <constructor-arg index="1" value="${redis.master.port}" type="int"/>
  12.                 </bean>
  13.             </list>
  14.         </constructor-arg>
  15.     </bean>

  17.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  18.         <property name="maxTotal" value="2048" />
  19.         <property name="maxIdle" value="200" />
  20.         <property name="numTestsPerEvictionRun" value="1024"/>
  21.         <property name="timeBetweenEvictionRunsMillis" value="30000" />
  22.         <property name="minEvictableIdleTimeMillis" value="-1" />
  23.         <property name="softMinEvictableIdleTimeMillis" value="10000" />
  24.         <property name="maxWaitMillis" value="1500"/>
  25.         <property name="testOnBorrow" value="true" />
  26.         <property name="testWhileIdle" value="true"/>
  27.         <property name="testOnReturn" value="false"/>
  28.         <property name="jmxEnabled" value="true"/>
  29.         <property name="jmxNamePrefix" value="youyuan"/>
  30.         <property name="blockWhenExhausted" value="false"/>
  31.     </bean>
复制代码
3.将
[size=1em]shardedJedisPool注入相关的类中即可使用
  1. @Resource
  2.     private ShardedJedisPool shardedJedisPool;


  5.     /**
  6.      * 设置一个key的过期时间（单位：秒）
  7.      * @param key key值
  8.      * @param seconds 多少秒后过期
  9.      * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间
  10.      */
  11.     public long expire(String key, int seconds) {
  12.         if (key==null || key.equals("")) {
  13.             return 0;
  14.         }

  16.         ShardedJedis shardedJedis = null;
  17.         try {
  18.             shardedJedis = shardedJedisPool.getResource();
  19.             return shardedJedis.expire(key, seconds);
  20.         } catch (Exception ex) {
  21.             logger.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);
  22.             returnBrokenResource(shardedJedis);
  23.         } finally {
  24.             returnResource(shardedJedis);
  25.         }
  26.         return 0;
  27.     }

  29.     /**
  30.      * 设置一个key在某个时间点过期
  31.      * @param key key值
  32.      * @param unixTimestamp unix时间戳，从1970-01-01 00:00:00开始到现在的秒数
  33.      * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间
  34.      */
  35.     public long expireAt(String key, int unixTimestamp) {
  36.         if (key==null || key.equals("")) {
  37.             return 0;
  38.         }

  40.         ShardedJedis shardedJedis = null;
  41.         try {
  42.             shardedJedis = shardedJedisPool.getResource();
  43.             return shardedJedis.expireAt(key, unixTimestamp);
  44.         } catch (Exception ex) {
  45.             logger.error("EXPIRE error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);
  46.             returnBrokenResource(shardedJedis);
  47.         } finally {
  48.             returnResource(shardedJedis);
  49.         }
  50.         return 0;
  51.     }

  53.     /**
  54.      * 截断一个List
  55.      * @param key 列表key
  56.      * @param start 开始位置 从0开始
  57.      * @param end 结束位置
  58.      * @return 状态码
  59.      */
  60.     public String trimList(String key, long start, long end) {
  61.         if (key == null || key.equals("")) {
  62.             return "-";
  63.         }
  64.         ShardedJedis shardedJedis = null;
  65.         try {
  66.             shardedJedis = shardedJedisPool.getResource();
  67.             return shardedJedis.ltrim(key, start, end);
  68.         } catch (Exception ex) {
  69.             logger.error("LTRIM 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);
  70.             returnBrokenResource(shardedJedis);
  71.         } finally {
  72.             returnResource(shardedJedis);
  73.         }
  74.         return "-";
  75.     }
  76.     /**
  77.      * 检查Set长度
  78.      * @param key
  79.      * @return
  80.      */
  81.     public long countSet(String key){
  82.             if(key == null ){
  83.                     return 0;
  84.             }
  85.             ShardedJedis shardedJedis = null;
  86.         try {
  87.             shardedJedis = shardedJedisPool.getResource();
  88.             return shardedJedis.scard(key);
  89.         } catch (Exception ex) {
  90.             logger.error("countSet error.", ex);
  91.             returnBrokenResource(shardedJedis);
  92.         } finally {
  93.             returnResource(shardedJedis);
  94.         }
  95.             return 0;
  96.     }
  97.     /**
  98.      * 添加到Set中（同时设置过期时间）
  99.      * @param key key值
  100.      * @param seconds 过期时间 单位s
  101.      * @param value
  102.      * @return
  103.      */
  104.     public boolean addSet(String key,int seconds, String... value) {
  105.             boolean result = addSet(key, value);
  106.             if(result){
  107.                     long i = expire(key, seconds);
  108.                     return i==1;
  109.             }
  110.             return false;
  111.     }
  112.     /**
  113.      * 添加到Set中
  114.      * @param key
  115.      * @param value
  116.      * @return
  117.      */
  118.     public boolean addSet(String key, String... value) {
  119.             if(key == null || value == null){
  120.                     return false;
  121.             }
  122.             ShardedJedis shardedJedis = null;
  123.         try {
  124.             shardedJedis = shardedJedisPool.getResource();
  125.             shardedJedis.sadd(key, value);
  126.             return true;
  127.         } catch (Exception ex) {
  128.             logger.error("setList error.", ex);
  129.             returnBrokenResource(shardedJedis);
  130.         } finally {
  131.             returnResource(shardedJedis);
  132.         }
  133.         return false;
  134.     }

  136.     
  137.     /**
  138.      * @param key
  139.      * @param value
  140.      * @return 判断值是否包含在set中
  141.      */
  142.     public boolean containsInSet(String key, String value) {
  143.             if(key == null || value == null){
  144.                     return false;
  145.             }
  146.             ShardedJedis shardedJedis = null;
  147.         try {
  148.             shardedJedis = shardedJedisPool.getResource();
  149.             return shardedJedis.sismember(key, value);
  150.         } catch (Exception ex) {
  151.             logger.error("setList error.", ex);
  152.             returnBrokenResource(shardedJedis);
  153.         } finally {
  154.             returnResource(shardedJedis);
  155.         }
  156.         return false;
  157.     }
  158.     /**
  159.      * 获取Set
  160.      * @param key
  161.      * @return
  162.      */
  163.     public  Set<String> getSet(String key){
  164.             ShardedJedis shardedJedis = null;
  165.         try {
  166.             shardedJedis = shardedJedisPool.getResource();
  167.             return shardedJedis.smembers(key);
  168.         } catch (Exception ex) {
  169.             logger.error("getList error.", ex);
  170.             returnBrokenResource(shardedJedis);
  171.         } finally {
  172.             returnResource(shardedJedis);
  173.         }
  174.         return null;
  175.     }

  177.     /**
  178.      * 从set中删除value
  179.      * @param key
  180.      * @return
  181.      */
  182.     public  boolean removeSetValue(String key,String... value){
  183.             ShardedJedis shardedJedis = null;
  184.         try {
  185.             shardedJedis = shardedJedisPool.getResource();
  186.             shardedJedis.srem(key, value);
  187.             return true;
  188.         } catch (Exception ex) {
  189.             logger.error("getList error.", ex);
  190.             returnBrokenResource(shardedJedis);
  191.         } finally {
  192.             returnResource(shardedJedis);
  193.         }
  194.         return false;
  195.     }
  196.     
  197.     
  198.     
  199.     /**
  200.      * 从list中删除value 默认count 1
  201.      * @param key
  202.      * @param values 值list
  203.      * @return
  204.      */
  205.     public  int removeListValue(String key,List<String> values){
  206.             return removeListValue(key, 1, values);
  207.     }
  208.     /**
  209.      * 从list中删除value
  210.      * @param key
  211.      * @param count 
  212.      * @param values 值list
  213.      * @return
  214.      */
  215.     public  int removeListValue(String key,long count,List<String> values){
  216.             int result = 0;
  217.             if(values != null && values.size()>0){
  218.                     for(String value : values){
  219.                             if(removeListValue(key, count, value)){
  220.                                     result++;
  221.                             }
  222.                     }
  223.             }
  224.             return result;
  225.     }
  226.     /**
  227.      *  从list中删除value
  228.      * @param key
  229.      * @param count 要删除个数
  230.      * @param value
  231.      * @return
  232.      */
  233.     public  boolean removeListValue(String key,long count,String value){
  234.             ShardedJedis shardedJedis = null;
  235.         try {
  236.             shardedJedis = shardedJedisPool.getResource();
  237.             shardedJedis.lrem(key, count, value);
  238.             return true;
  239.         } catch (Exception ex) {
  240.             logger.error("getList error.", ex);
  241.             returnBrokenResource(shardedJedis);
  242.         } finally {
  243.             returnResource(shardedJedis);
  244.         }
  245.             return false;
  246.     }
  247.     
  248.     /**
  249.      * 截取List
  250.      * @param key 
  251.      * @param start 起始位置
  252.      * @param end 结束位置
  253.      * @return
  254.      */
  255.     public List<String> rangeList(String key, long start, long end) {
  256.         if (key == null || key.equals("")) {
  257.             return null;
  258.         }
  259.         ShardedJedis shardedJedis = null;
  260.         try {
  261.             shardedJedis = shardedJedisPool.getResource();
  262.             return shardedJedis.lrange(key, start, end);
  263.         } catch (Exception ex) {
  264.             logger.error("rangeList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);
  265.             returnBrokenResource(shardedJedis);
  266.         } finally {
  267.             returnResource(shardedJedis);
  268.         }
  269.         return null;
  270.     }
  271.     
  272.     /**
  273.      * 检查List长度
  274.      * @param key
  275.      * @return
  276.      */
  277.     public long countList(String key){
  278.             if(key == null ){
  279.                     return 0;
  280.             }
  281.             ShardedJedis shardedJedis = null;
  282.         try {
  283.             shardedJedis = shardedJedisPool.getResource();
  284.             return shardedJedis.llen(key);
  285.         } catch (Exception ex) {
  286.             logger.error("countList error.", ex);
  287.             returnBrokenResource(shardedJedis);
  288.         } finally {
  289.             returnResource(shardedJedis);
  290.         }
  291.             return 0;
  292.     }
  293.     
  294.     /**
  295.      * 添加到List中（同时设置过期时间）
  296.      * @param key key值
  297.      * @param seconds 过期时间 单位s
  298.      * @param value 
  299.      * @return 
  300.      */
  301.     public boolean addList(String key,int seconds, String... value){
  302.             boolean result = addList(key, value);
  303.             if(result){
  304.                     long i = expire(key, seconds);
  305.                     return i==1;
  306.             }
  307.             return false;
  308.     }
  309.     /**
  310.      * 添加到List
  311.      * @param key
  312.      * @param value
  313.      * @return
  314.      */
  315.     public boolean addList(String key, String... value) {
  316.             if(key == null || value == null){
  317.                     return false;
  318.             }
  319.             ShardedJedis shardedJedis = null;
  320.         try {
  321.             shardedJedis = shardedJedisPool.getResource();
  322.             shardedJedis.lpush(key, value);
  323.             return true;
  324.         } catch (Exception ex) {
  325.             logger.error("setList error.", ex);
  326.             returnBrokenResource(shardedJedis);
  327.         } finally {
  328.             returnResource(shardedJedis);
  329.         }
  330.         return false;
  331.     }
  332.     /**
  333.      * 添加到List(只新增)
  334.      * @param key
  335.      * @param value
  336.      * @return
  337.      */
  338.     public boolean addList(String key, List<String> list) {
  339.             if(key == null || list == null || list.size() == 0){
  340.                     return false;
  341.             }
  342.             for(String value : list){
  343.                     addList(key, value);
  344.             }
  345.         return true;
  346.     }
  347.     
  348.     /**
  349.      * 获取List
  350.      * @param key
  351.      * @return
  352.      */
  353.     public  List<String> getList(String key){
  354.             ShardedJedis shardedJedis = null;
  355.         try {
  356.             shardedJedis = shardedJedisPool.getResource();
  357.             return shardedJedis.lrange(key, 0, -1);
  358.         } catch (Exception ex) {
  359.             logger.error("getList error.", ex);
  360.             returnBrokenResource(shardedJedis);
  361.         } finally {
  362.             returnResource(shardedJedis);
  363.         }
  364.         return null;
  365.     }
  366.     /**
  367.      * 设置HashSet对象
  368.      *
  369.      * @param domain 域名
  370.      * @param key    键值
  371.      * @param value  Json String or String value
  372.      * @return
  373.      */
  374.     public boolean setHSet(String domain, String key, String value) {
  375.         if (value == null) return false;
  376.         ShardedJedis shardedJedis = null;
  377.         try {
  378.             shardedJedis = shardedJedisPool.getResource();
  379.             shardedJedis.hset(domain, key, value);
  380.             return true;
  381.         } catch (Exception ex) {
  382.             logger.error("setHSet error.", ex);
  383.             returnBrokenResource(shardedJedis);
  384.         } finally {
  385.             returnResource(shardedJedis);
  386.         }
  387.         return false;
  388.     }

  390.     /**
  391.      * 获得HashSet对象
  392.      *
  393.      * @param domain 域名
  394.      * @param key    键值
  395.      * @return Json String or String value
  396.      */
  397.     public String getHSet(String domain, String key) {
  398.         ShardedJedis shardedJedis = null;
  399.         try {
  400.             shardedJedis = shardedJedisPool.getResource();
  401.             return shardedJedis.hget(domain, key);
  402.         } catch (Exception ex) {
  403.             logger.error("getHSet error.", ex);
  404.             returnBrokenResource(shardedJedis);
  405.         } finally {
  406.             returnResource(shardedJedis);
  407.         }
  408.         return null;
  409.     }

  411.     /**
  412.      * 删除HashSet对象
  413.      *
  414.      * @param domain 域名
  415.      * @param key    键值
  416.      * @return 删除的记录数
  417.      */
  418.     public long delHSet(String domain, String key) {
  419.         ShardedJedis shardedJedis = null;
  420.         long count = 0;
  421.         try {
  422.             shardedJedis = shardedJedisPool.getResource();
  423.             count = shardedJedis.hdel(domain, key);
  424.         } catch (Exception ex) {
  425.             logger.error("delHSet error.", ex);
  426.             returnBrokenResource(shardedJedis);
  427.         } finally {
  428.             returnResource(shardedJedis);
  429.         }
  430.         return count;
  431.     }

  433.     /**
  434.      * 删除HashSet对象
  435.      *
  436.      * @param domain 域名
  437.      * @param key    键值
  438.      * @return 删除的记录数
  439.      */
  440.     public long delHSet(String domain, String... key) {
  441.         ShardedJedis shardedJedis = null;
  442.         long count = 0;
  443.         try {
  444.             shardedJedis = shardedJedisPool.getResource();
  445.             count = shardedJedis.hdel(domain, key);
  446.         } catch (Exception ex) {
  447.             logger.error("delHSet error.", ex);
  448.             returnBrokenResource(shardedJedis);
  449.         } finally {
  450.             returnResource(shardedJedis);
  451.         }
  452.         return count;
  453.     }

  455.     /**
  456.      * 判断key是否存在
  457.      *
  458.      * @param domain 域名
  459.      * @param key    键值
  460.      * @return
  461.      */
  462.     public boolean existsHSet(String domain, String key) {
  463.         ShardedJedis shardedJedis = null;
  464.         boolean isExist = false;
  465.         try {
  466.             shardedJedis = shardedJedisPool.getResource();
  467.             isExist = shardedJedis.hexists(domain, key);
  468.         } catch (Exception ex) {
  469.             logger.error("existsHSet error.", ex);
  470.             returnBrokenResource(shardedJedis);
  471.         } finally {
  472.             returnResource(shardedJedis);
  473.         }
  474.         return isExist;
  475.     }

  477.     /**
  478.      * 全局扫描hset
  479.      *
  480.      * @param match field匹配模式
  481.      * @return
  482.      */
  483.     public List<Map.Entry<String, String>> scanHSet(String domain, String match) {
  484.         ShardedJedis shardedJedis = null;
  485.         try {
  486.             int cursor = 0;
  487.             shardedJedis = shardedJedisPool.getResource();
  488.             ScanParams scanParams = new ScanParams();
  489.             scanParams.match(match);
  490.             Jedis jedis = shardedJedis.getShard(domain);
  491.             ScanResult<Map.Entry<String, String>> scanResult;
  492.             List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();
  493.             do {
  494.                 scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams);
  495.                 list.addAll(scanResult.getResult());
  496.                 cursor = Integer.parseInt(scanResult.getStringCursor());
  497.             } while (cursor > 0);
  498.             return list;
  499.         } catch (Exception ex) {
  500.             logger.error("scanHSet error.", ex);
  501.             returnBrokenResource(shardedJedis);
  502.         } finally {
  503.             returnResource(shardedJedis);
  504.         }
  505.         return null;
  506.     }


  509.     /**
  510.      * 返回 domain 指定的哈希集中所有字段的value值
  511.      *
  512.      * @param domain
  513.      * @return
  514.      */

  516.     public List<String> hvals(String domain) {
  517.         ShardedJedis shardedJedis = null;
  518.         List<String> retList = null;
  519.         try {
  520.             shardedJedis = shardedJedisPool.getResource();
  521.             retList = shardedJedis.hvals(domain);
  522.         } catch (Exception ex) {
  523.             logger.error("hvals error.", ex);
  524.             returnBrokenResource(shardedJedis);
  525.         } finally {
  526.             returnResource(shardedJedis);
  527.         }
  528.         return retList;
  529.     }

  531.     /**
  532.      * 返回 domain 指定的哈希集中所有字段的key值
  533.      *
  534.      * @param domain
  535.      * @return
  536.      */

  538.     public Set<String> hkeys(String domain) {
  539.         ShardedJedis shardedJedis = null;
  540.         Set<String> retList = null;
  541.         try {
  542.             shardedJedis = shardedJedisPool.getResource();
  543.             retList = shardedJedis.hkeys(domain);
  544.         } catch (Exception ex) {
  545.             logger.error("hkeys error.", ex);
  546.             returnBrokenResource(shardedJedis);
  547.         } finally {
  548.             returnResource(shardedJedis);
  549.         }
  550.         return retList;
  551.     }

  553.     /**
  554.      * 返回 domain 指定的哈希key值总数
  555.      *
  556.      * @param domain
  557.      * @return
  558.      */
  559.     public long lenHset(String domain) {
  560.         ShardedJedis shardedJedis = null;
  561.         long retList = 0;
  562.         try {
  563.             shardedJedis = shardedJedisPool.getResource();
  564.             retList = shardedJedis.hlen(domain);
  565.         } catch (Exception ex) {
  566.             logger.error("hkeys error.", ex);
  567.             returnBrokenResource(shardedJedis);
  568.         } finally {
  569.             returnResource(shardedJedis);
  570.         }
  571.         return retList;
  572.     }

  574.     /**
  575.      * 设置排序集合
  576.      *
  577.      * @param key
  578.      * @param score
  579.      * @param value
  580.      * @return
  581.      */
  582.     public boolean setSortedSet(String key, long score, String value) {
  583.         ShardedJedis shardedJedis = null;
  584.         try {
  585.             shardedJedis = shardedJedisPool.getResource();
  586.             shardedJedis.zadd(key, score, value);
  587.             return true;
  588.         } catch (Exception ex) {
  589.             logger.error("setSortedSet error.", ex);
  590.             returnBrokenResource(shardedJedis);
  591.         } finally {
  592.             returnResource(shardedJedis);
  593.         }
  594.         return false;
  595.     }

  597.     /**
  598.      * 获得排序集合
  599.      *
  600.      * @param key
  601.      * @param startScore
  602.      * @param endScore
  603.      * @param orderByDesc
  604.      * @return
  605.      */
  606.     public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {
  607.         ShardedJedis shardedJedis = null;
  608.         try {
  609.             shardedJedis = shardedJedisPool.getResource();
  610.             if (orderByDesc) {
  611.                 return shardedJedis.zrevrangeByScore(key, endScore, startScore);
  612.             } else {
  613.                 return shardedJedis.zrangeByScore(key, startScore, endScore);
  614.             }
  615.         } catch (Exception ex) {
  616.             logger.error("getSoredSet error.", ex);
  617.             returnBrokenResource(shardedJedis);
  618.         } finally {
  619.             returnResource(shardedJedis);
  620.         }
  621.         return null;
  622.     }

  624.     /**
  625.      * 计算排序长度
  626.      *
  627.      * @param key
  628.      * @param startScore
  629.      * @param endScore
  630.      * @return
  631.      */
  632.     public long countSoredSet(String key, long startScore, long endScore) {
  633.         ShardedJedis shardedJedis = null;
  634.         try {
  635.             shardedJedis = shardedJedisPool.getResource();
  636.             Long count = shardedJedis.zcount(key, startScore, endScore);
  637.             return count == null ? 0L : count;
  638.         } catch (Exception ex) {
  639.             logger.error("countSoredSet error.", ex);
  640.             returnBrokenResource(shardedJedis);
  641.         } finally {
  642.             returnResource(shardedJedis);
  643.         }
  644.         return 0L;
  645.     }

  647.     /**
  648.      * 删除排序集合
  649.      *
  650.      * @param key
  651.      * @param value
  652.      * @return
  653.      */
  654.     public boolean delSortedSet(String key, String value) {
  655.         ShardedJedis shardedJedis = null;
  656.         try {
  657.             shardedJedis = shardedJedisPool.getResource();
  658.             long count = shardedJedis.zrem(key, value);
  659.             return count > 0;
  660.         } catch (Exception ex) {
  661.             logger.error("delSortedSet error.", ex);
  662.             returnBrokenResource(shardedJedis);
  663.         } finally {
  664.             returnResource(shardedJedis);
  665.         }
  666.         return false;
  667.     }

  669.     /**
  670.      * 获得排序集合
  671.      *
  672.      * @param key
  673.      * @param startRange
  674.      * @param endRange
  675.      * @param orderByDesc
  676.      * @return
  677.      */
  678.     public Set<String> getSoredSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {
  679.         ShardedJedis shardedJedis = null;
  680.         try {
  681.             shardedJedis = shardedJedisPool.getResource();
  682.             if (orderByDesc) {
  683.                 return shardedJedis.zrevrange(key, startRange, endRange);
  684.             } else {
  685.                 return shardedJedis.zrange(key, startRange, endRange);
  686.             }
  687.         } catch (Exception ex) {
  688.             logger.error("getSoredSetByRange error.", ex);
  689.             returnBrokenResource(shardedJedis);
  690.         } finally {
  691.             returnResource(shardedJedis);
  692.         }
  693.         return null;
  694.     }

  696.     /**
  697.      * 获得排序打分
  698.      *
  699.      * @param key
  700.      * @return
  701.      */
  702.     public Double getScore(String key, String member) {
  703.         ShardedJedis shardedJedis = null;
  704.         try {
  705.             shardedJedis = shardedJedisPool.getResource();
  706.             return shardedJedis.zscore(key, member);
  707.         } catch (Exception ex) {
  708.             logger.error("getSoredSet error.", ex);
  709.             returnBrokenResource(shardedJedis);
  710.         } finally {
  711.             returnResource(shardedJedis);
  712.         }
  713.         return null;
  714.     }

  716.     public boolean set(String key, String value, int second) {
  717.         ShardedJedis shardedJedis = null;
  718.         try {
  719.             shardedJedis = shardedJedisPool.getResource();
  720.             shardedJedis.setex(key, second, value);
  721.             return true;
  722.         } catch (Exception ex) {
  723.             logger.error("set error.", ex);
  724.             returnBrokenResource(shardedJedis);
  725.         } finally {
  726.             returnResource(shardedJedis);
  727.         }
  728.         return false;
  729.     }

  731.     public boolean set(String key, String value) {
  732.         ShardedJedis shardedJedis = null;
  733.         try {
  734.             shardedJedis = shardedJedisPool.getResource();
  735.             shardedJedis.set(key, value);
  736.             return true;
  737.         } catch (Exception ex) {
  738.             logger.error("set error.", ex);
  739.             returnBrokenResource(shardedJedis);
  740.         } finally {
  741.             returnResource(shardedJedis);
  742.         }
  743.         return false;
  744.     }

  746.     public String get(String key, String defaultValue) {
  747.         ShardedJedis shardedJedis = null;
  748.         try {
  749.             shardedJedis = shardedJedisPool.getResource();
  750.             return shardedJedis.get(key) == null?defaultValue:shardedJedis.get(key);
  751.         } catch (Exception ex) {
  752.             logger.error("get error.", ex);
  753.             returnBrokenResource(shardedJedis);
  754.         } finally {
  755.             returnResource(shardedJedis);
  756.         }
  757.         return defaultValue;
  758.     }

  760.     public boolean del(String key) {
  761.         ShardedJedis shardedJedis = null;
  762.         try {
  763.             shardedJedis = shardedJedisPool.getResource();
  764.             shardedJedis.del(key);
  765.             return true;
  766.         } catch (Exception ex) {
  767.             logger.error("del error.", ex);
  768.             returnBrokenResource(shardedJedis);
  769.         } finally {
  770.             returnResource(shardedJedis);
  771.         }
  772.         return false;
  773.     }

  775.     public long incr(String key) {
  776.         ShardedJedis shardedJedis = null;
  777.         try {
  778.             shardedJedis = shardedJedisPool.getResource();
  779.             return shardedJedis.incr(key);
  780.         } catch (Exception ex) {
  781.             logger.error("incr error.", ex);
  782.             returnBrokenResource(shardedJedis);
  783.         } finally {
  784.             returnResource(shardedJedis);
  785.         }
  786.         return 0;
  787.     }

  789.     public long decr(String key) {
  790.         ShardedJedis shardedJedis = null;
  791.         try {
  792.             shardedJedis = shardedJedisPool.getResource();
  793.             return shardedJedis.decr(key);
  794.         } catch (Exception ex) {
  795.             logger.error("incr error.", ex);
  796.             returnBrokenResource(shardedJedis);
  797.         } finally {
  798.             returnResource(shardedJedis);
  799.         }
  800.         return 0;
  801.     }



  805.     private void returnBrokenResource(ShardedJedis shardedJedis) {
  806.         try {
  807.             shardedJedisPool.returnBrokenResource(shardedJedis);
  808.         } catch (Exception e) {
  809.             logger.error("returnBrokenResource error.", e);
  810.         }
  811.     }

  813.     private void returnResource(ShardedJedis shardedJedis) {
  814.         try {
  815.             shardedJedisPool.returnResource(shardedJedis);
  816.         } catch (Exception e) {
  817.             logger.error("returnResource error.", e);
  818.         }
  819.     }
复制代码
菜鸟笔记
关注
专栏目录
Redis的Java客户端:SpringDataRedis
qq_52077925的博客
08-06 271
Redis学习笔记。
springboot整合redis，用spring-data-redis2.0的同时用jedis
热门推荐
wobupeiai的博客
07-14 1万+
最新版本的spring-data-redis很烦，很多以前用起来很方便的方法过时了。下面是2.0这个版本的搭建过程： 首先要了解这个版本         （1）spring-data-redis是默认是用lettuce的,要用jedis需要单独出来配置           （2）JedisConnectionFactory的所有set方法全部过时。         （3）基本配置（hos...
spring整合redis案例（jedis）
04-11
spring4使用jedis整合redis，教程见博客地址:https://blog.csdn.net/zhou870498/article/details/79904475
redis 学习笔记(5)-Spring与Jedis的集成
weixin_33728268的博客
11-21 129
首先不得不服Spring这个宇宙无敌的开源框架，几乎整合了所有流行的其它框架，http://projects.spring.io/spring-data/ 从这上面看，当下流行的redis、solr、hadoop、mongoDB、couchBase... 全都收入囊中。对于redis整合而言，主要用到的是spring-data-redis 使用步骤： 一、pom添加依赖项 ...
Spring 框架下的 Redis 操作：让你的应用性能飙升！
最新发布
求你们看我的博客
08-12 305
上篇博客我们讲述了使用Jedis操作Redis，那么如何在Spring中操作Redis？
redis连接池配置
lianbancai的博客
09-15 2956
该值 且 空闲连接>最大空闲连接数 时直接释放 --> destroy-method="close">
Spring整合jedis
guinailu的博客
12-05 545
Spring整合jedis - 配置jedis连接池 &lt;!-- 连接池配置 --&gt; &lt;bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"&gt; &lt;!-- 最大连接数 --&gt; &lt;property name="maxTotal" value="30"
Spring整合Jedis
weixin_44096325的博客
03-08 576
Spring直接整合Jedis 第1步，引入Jedis的依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> ...
redis客户端连接、spring boot整合、分布式锁.zip
03-23
在本项目中，我们关注的是 Redis 的客户端连接、Spring Boot 整合以及分布式锁的实现。 首先，Redis 客户端连接是与 Redis 服务器进行交互的基础。常见的 Redis 客户端库有 Jedis 和 Lettuce。Jedis 是一个用 Java ...
redis客户端选型-Jedis、lettuce、Redisson
a5569449的博客
06-25 5911
1.背景 研发部门对于客户端选型比较广泛和随意，依赖的分支也不统一，感觉就像百度到一个就直接用，或者是有一个功能满足就换，没有考虑到其他组的使用情况以及集中维护。 另外一个是如果作为公司pom脚手架的基本组成部分，需要考虑统一成一个还是多个并存的问题，现在有两个考量：如果性能不是大问题，建议统一集中为一个就行; 如果需要多个并存，至少不能多于2个客户端。 2.比较 官方推荐的java客户端只有Jedis、lettuce、Redisson，所以这次分析只针对这三个进行。 2.1.概述 Jedis: re
spring整合jedis
qq_15421685的博客
09-29 931
最近项目中要用到redis的分布式锁，参考了网上整合jedis的资料，但运行时候会各种报错。重新整理下复制直接可用。 maven导入相关包： <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> 新建 classpath:
玩转 SpringBoot 2.x 之 快速集成 Jedis客户端（普通版）
12-22
前言 Java 开发 一般会选择 Jedis 客户端来进行 Redis 相关的操作，本文通过SpringBoot 项目带你快速上手 Jedis 相关的操作。 Redis 安装 请参考：带你学 Redis：Redis安装（二） 代码案例 基础配置操作 引入 jedis 客户端的依赖，具体代码如下： redis.clients jedis 添加 Jedis 客户端配置类，将JedisPoolConfig和 JedisPool 注入Spring的上下文中。具体代码如下： @Configuration public class JedisConfig { @Value("${redis
Spring 集成 Jedis
harvey的博客
09-23 539
1.创建maven 项目，引入jedis及spring依赖包 <dependencies> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version>
spring 整合jedis
zxc.blog
02-03 203
 刚开始整合的是redis，连不上，试了下jedis，控制台报错，host没setter，看源码，JedisPool没host字段，只能通过构造注入，用的ssm框架。 我连的Windows的redis，还加了密码。#redis.properties redis.maxIdle=30 redis.minIdle=10 redis.maxWaitMillis=3000 redis.testOnBorr...
nested exception is java.lang.NoClassDefFoundError: com/taotao/pojo/TbContentExample$Criteria] with
真正的大师永远怀着一颗学徒的心
06-05 1004
java.lang.NoSuchMethodError
Spring 整合 Jedis
Eden 的博客
08-13 162
当后台管理系统，修改内容之后需要通知redis把修改的内容对应的分类id的key删除。配置文件增加 项目启动创建单例的dao对象。添加 jedis dao 对象。把缓存添加到业务逻辑。
Spring整合Redis：配置文件详解与Jedis连接池设置
这里创建了一个名为`jedisPoolConfig`的Bean，它的类型是`JedisPoolConfig`，这是Redis客户端库提供的一个连接池配置类。这个配置类允许我们设置连接池的容量和行为。 1. `maxTotal`属性：这是一个整数值，表示连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值