Redis 工具类 java 实现的redis 工具类

最近了解了一下非关系型数据库 redis

会使用简单的命令 在自己本地电脑

使用时必须先启动服务器端 在启动客户端

redis 简介

Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。

基本介绍

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类keyvalue存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。[1]

java 实现的redis 工具类

1.加入jar包

2.代码

 . package redis.utils;
 2.
 3. import java.util.List;
 4. import java.util.Map;
 5. import java.util.Set;
 6.
 7. //import org.apache.log4j.Logger;
 8.
 9.
 10. import redis.clients.jedis.Jedis;
 11. import redis.clients.jedis.JedisPool;
 12. import redis.clients.jedis.JedisPoolConfig;
 13. import redis.clients.jedis.SortingParams;
 14. import redis.clients.jedis.BinaryClient.LIST_POSITION;
 15. import redis.clients.util.SafeEncoder;
 16.
 17. /**
 18.  * @author Mr.hu
 19.  * @version crateTime：2013-10-30 下午5:41:30
 20.  * Class Explain:JedisUtil
 21.  */
 22. public class JedisUtil {
 23.
 24.      //private Logger log = Logger.getLogger(this.getClass());
 25.      /**缓存生存时间 */
 26.      private final int expire = 60000;
 27.      /** 操作Key的方法 */
 28.      public Keys KEYS;
 29.      /** 对存储结构为String类型的操作 */
 30.      public Strings STRINGS;
 31.      /** 对存储结构为List类型的操作 */
 32.      public Lists LISTS;
 33.      /** 对存储结构为Set类型的操作 */
 34.      public Sets SETS;
 35.      /** 对存储结构为HashMap类型的操作 */
 36.      public Hash HASH;
 37.      /** 对存储结构为Set(排序的)类型的操作 */
 38.      public SortSet SORTSET;
 39.      private static JedisPool jedisPool = null;
 40.
 41.      private JedisUtil() {
 42.
 43.      }
 44.      static {
 45.             JedisPoolConfig config = new JedisPoolConfig();
 46.             //控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
 47.             //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
 48.             config.setMaxTotal(500);
 49.             //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
 50.             config.setMaxIdle(5);
 51.             //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
 52.             config.setMaxWaitMillis(1000 * 100);
 53.             //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
 54.             config.setTestOnBorrow(true);
 55.
 56.             //redis如果设置了密码：
 57.             /*jedisPool = new JedisPool(config, JRedisPoolConfig.REDIS_IP,
 58.                     JRedisPoolConfig.REDIS_PORT,
 59.                     10000,JRedisPoolConfig.REDIS_PASSWORD);    */
 60.
 61.             //redis未设置了密码：
 62.            jedisPool = new JedisPool(config, "172.30.37.73",6379);
 63.        }
 64.
 65.     public JedisPool getPool() {
 66.         return jedisPool;
 67.     }
 68.
 69.      /**
 70.       * 从jedis连接池中获取获取jedis对象
 71.       * @return
 72.       */
 73.      public Jedis getJedis() {
 74.          return jedisPool.getResource();
 75.     }
 76.
 77.
 78.      private static final JedisUtil jedisUtil = new JedisUtil();
 79.
 80.
 81.     /**
 82.      * 获取JedisUtil实例
 83.      * @return
 84.      */
 85.     public static JedisUtil getInstance() {
 86.         return jedisUtil;
 87.     }
 88.
 89.     /**
 90.      * 回收jedis(放到finally中)
 91.      * @param jedis
 92.      */
 93.     public void returnJedis(Jedis jedis) {
 94.         if (null != jedis && null != jedisPool) {
 95.             jedisPool.returnResource(jedis);
 96.         }
 97.     }
 98.
 99.     /**
 100.      * 销毁连接(放到catch中)
 101.      * @param pool
 102.      * @param jedis
 103.      */
 104.     public static void returnBrokenResource(Jedis jedis) {
 105.         if (null != jedis && null != jedisPool) {
 106.             jedisPool.returnResource(jedis);
 107.         }
 108.     }
 109.
 110.
 111.     /**
 112.      * 设置过期时间
 113.      * @author ruan 2013-4-11
 114.      * @param key
 115.      * @param seconds
 116.      */
 117.     public void expire(String key, int seconds) {
 118.         if (seconds <= 0) {
 119.             return;
 120.         }
 121.         Jedis jedis = getJedis();
 122.         jedis.expire(key, seconds);
 123.         returnJedis(jedis);
 124.     }
 125.
 126.     /**
 127.      * 设置默认过期时间
 128.      * @author ruan 2013-4-11
 129.      * @param key
 130.      */
 131.     public void expire(String key) {
 132.         expire(key, expire);
 133.     }
 134.
 135.
 136.     //*******************************************Keys*******************************************//
 137.     public class Keys {
 138.
 139.         /**
 140.          * 清空所有key
 141.          */
 142.         public String flushAll() {
 143.             Jedis jedis = getJedis();
 144.             String stata = jedis.flushAll();
 145.             returnJedis(jedis);
 146.             return stata;
 147.         }
 148.
 149.         /**
 150.          * 更改key
 151.          * @param String oldkey
 152.          * @param String  newkey
 153.          * @return 状态码
 154.          * */
 155.         public String rename(String oldkey, String newkey) {
 156.             return rename(SafeEncoder.encode(oldkey),
 157.                     SafeEncoder.encode(newkey));
 158.         }
 159.
 160.         /**
 161.          * 更改key,仅当新key不存在时才执行
 162.          * @param String oldkey
 163.          * @param String newkey
 164.          * @return 状态码
 165.          * */
 166.         public long renamenx(String oldkey, String newkey) {
 167.             Jedis jedis = getJedis();
 168.             long status = jedis.renamenx(oldkey, newkey);
 169.             returnJedis(jedis);
 170.             return status;
 171.         }
 172.
 173.         /**
 174.          * 更改key
 175.          * @param String oldkey
 176.          * @param String newkey
 177.          * @return 状态码
 178.          * */
 179.         public String rename(byte[] oldkey, byte[] newkey) {
 180.             Jedis jedis = getJedis();
 181.             String status = jedis.rename(oldkey, newkey);
 182.             returnJedis(jedis);
 183.             return status;
 184.         }
 185.
 186.         /**
 187.          * 设置key的过期时间，以秒为单位
 188.          * @param String key
 189.          * @param 时间,已秒为单位
 190.          * @return 影响的记录数
 191.          * */
 192.         public long expired(String key, int seconds) {
 193.             Jedis jedis = getJedis();
 194.             long count = jedis.expire(key, seconds);
 195.             returnJedis(jedis);
 196.             return count;
 197.         }
 198.
 199.         /**
 200.          * 设置key的过期时间,它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00，格里高利历）的偏移量。
 201.          * @param String key
 202.          * @param 时间,已秒为单位
 203.          * @return 影响的记录数
 204.          * */
 205.         public long expireAt(String key, long timestamp) {
 206.             Jedis jedis = getJedis();
 207.             long count = jedis.expireAt(key, timestamp);
 208.             returnJedis(jedis);
 209.             return count;
 210.         }
 211.
 212.         /**
 213.          * 查询key的过期时间
 214.          * @param String key
 215.          * @return 以秒为单位的时间表示
 216.          * */
 217.         public long ttl(String key) {
 218.             //ShardedJedis sjedis = getShardedJedis();
 219.             Jedis sjedis=getJedis();
 220.             long len = sjedis.ttl(key);
 221.             returnJedis(sjedis);
 222.             return len;
 223.         }
 224.
 225.         /**
 226.          * 取消对key过期时间的设置
 227.          * @param key
 228.          * @return 影响的记录数
 229.          * */
 230.         public long persist(String key) {
 231.             Jedis jedis = getJedis();
 232.             long count = jedis.persist(key);
 233.             returnJedis(jedis);
 234.             return count;
 235.         }
 236.
 237.         /**
 238.          * 删除keys对应的记录,可以是多个key
 239.          * @param String  ... keys
 240.          * @return 删除的记录数
 241.          * */
 242.         public long del(String... keys) {
 243.             Jedis jedis = getJedis();
 244.             long count = jedis.del(keys);
 245.             returnJedis(jedis);
 246.             return count;
 247.         }
 248.
 249.         /**
 250.          * 删除keys对应的记录,可以是多个key
 251.          * @param String .. keys
 252.          * @return 删除的记录数
 253.          * */
 254.         public long del(byte[]... keys) {
 255.             Jedis jedis = getJedis();
 256.             long count = jedis.del(keys);
 257.             returnJedis(jedis);
 258.             return count;
 259.         }
 260.
 261.         /**
 262.          * 判断key是否存在
 263.          * @param String key
 264.          * @return boolean
 265.          * */
 266.         public boolean exists(String key) {
 267.             //ShardedJedis sjedis = getShardedJedis();
 268.             Jedis sjedis=getJedis();
 269.             boolean exis = sjedis.exists(key);
 270.             returnJedis(sjedis);
 271.             return exis;
 272.         }
 273.
 274.         /**
 275.          * 对List,Set,SortSet进行排序,如果集合数据较大应避免使用这个方法
 276.          * @param String key
 277.          * @return List<String> 集合的全部记录
 278.          * **/
 279.         public List<String> sort(String key) {
 280.             //ShardedJedis sjedis = getShardedJedis();
 281.             Jedis sjedis=getJedis();
 282.             List<String> list = sjedis.sort(key);
 283.             returnJedis(sjedis);
 284.             return list;
 285.         }
 286.
 287.         /**
 288.          * 对List,Set,SortSet进行排序或limit
 289.          * @param String key
 290.          * @param SortingParams parame 定义排序类型或limit的起止位置.
 291.          * @return List<String> 全部或部分记录
 292.          * **/
 293.         public List<String> sort(String key, SortingParams parame) {
 294.             //ShardedJedis sjedis = getShardedJedis();
 295.             Jedis sjedis=getJedis();
 296.             List<String> list = sjedis.sort(key, parame);
 297.             returnJedis(sjedis);
 298.             return list;
 299.         }
 300.
 301.         /**
 302.          * 返回指定key存储的类型
 303.          * @param String key
 304.          * @return String string|list|set|zset|hash
 305.          * **/
 306.         public String type(String key) {
 307.             //ShardedJedis sjedis = getShardedJedis();
 308.             Jedis sjedis=getJedis();
 309.             String type = sjedis.type(key);
 310.             returnJedis(sjedis);
 311.             return type;
 312.         }
 313.
 314.         /**
 315.          * 查找所有匹配给定的模式的键
 316.          * @param String  key的表达式,*表示多个，？表示一个
 317.          * */
 318.         public Set<String> keys(String pattern) {
 319.             Jedis jedis = getJedis();
 320.             Set<String> set = jedis.keys(pattern);
 321.             returnJedis(jedis);
 322.             return set;
 323.         }
 324.     }
 325.
 326.     //*******************************************Sets*******************************************//
 327.     public class Sets {
 328.
 329.         /**
 330.          * 向Set添加一条记录，如果member已存在返回0,否则返回1
 331.          * @param String  key
 332.          * @param String member
 333.          * @return 操作码,0或1
 334.          * */
 335.         public long sadd(String key, String member) {
 336.             Jedis jedis = getJedis();
 337.             long s = jedis.sadd(key, member);
 338.             returnJedis(jedis);
 339.             return s;
 340.         }
 341.
 342.         public long sadd(byte[] key, byte[] member) {
 343.             Jedis jedis = getJedis();
 344.             long s = jedis.sadd(key, member);
 345.             returnJedis(jedis);
 346.             return s;
 347.         }
 348.
 349.         /**
 350.          * 获取给定key中元素个数
 351.          * @param String key
 352.          * @return 元素个数
 353.          * */
 354.         public long scard(String key) {
 355.             //ShardedJedis sjedis = getShardedJedis();
 356.             Jedis sjedis = getJedis();
 357.             long len = sjedis.scard(key);
 358.             returnJedis(sjedis);
 359.             return len;
 360.         }
 361.
 362.         /**
 363.          * 返回从第一组和所有的给定集合之间的差异的成员
 364.          * @param String ... keys
 365.          * @return 差异的成员集合
 366.          * */
 367.         public Set<String> sdiff(String... keys) {
 368.             Jedis jedis = getJedis();
 369.             Set<String> set = jedis.sdiff(keys);
 370.             returnJedis(jedis);
 371.             return set;
 372.         }
 373.
 374.         /**
 375.          * 这个命令等于sdiff,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。
 376.          * @param String newkey 新结果集的key
 377.          * @param String ... keys 比较的集合
 378.          * @return 新集合中的记录数
 379.          * **/
 380.         public long sdiffstore(String newkey, String... keys) {
 381.             Jedis jedis = getJedis();
 382.             long s = jedis.sdiffstore(newkey, keys);
 383.             returnJedis(jedis);
 384.             return s;
 385.         }
 386.
 387.         /**
 388.          * 返回给定集合交集的成员,如果其中一个集合为不存在或为空，则返回空Set
 389.          * @param String ... keys
 390.          * @return 交集成员的集合
 391.          * **/
 392.         public Set<String> sinter(String... keys) {
 393.             Jedis jedis = getJedis();
 394.             Set<String> set = jedis.sinter(keys);
 395.             returnJedis(jedis);
 396.             return set;
 397.         }
 398.
 399.         /**
 400.          * 这个命令等于sinter,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。
 401.          * @param String  newkey 新结果集的key
 402.          * @param String ... keys 比较的集合
 403.          * @return 新集合中的记录数
 404.          * **/
 405.         public long sinterstore(String newkey, String... keys) {
 406.             Jedis jedis = getJedis();
 407.             long s = jedis.sinterstore(newkey, keys);
 408.             returnJedis(jedis);
 409.             return s;
 410.         }
 411.
 412.         /**
 413.          * 确定一个给定的值是否存在
 414.          * @param String  key
 415.          * @param String member 要判断的值
 416.          * @return 存在返回1，不存在返回0
 417.          * **/
 418.         public boolean sismember(String key, String member) {
 419.             //ShardedJedis sjedis = getShardedJedis();
 420.             Jedis sjedis = getJedis();
 421.             boolean s = sjedis.sismember(key, member);
 422.             returnJedis(sjedis);
 423.             return s;
 424.         }
 425.
 426.         /**
 427.          * 返回集合中的所有成员
 428.          * @param String  key
 429.          * @return 成员集合
 430.          * */
 431.         public Set<String> smembers(String key) {
 432.             //ShardedJedis sjedis = getShardedJedis();
 433.             Jedis sjedis = getJedis();
 434.             Set<String> set = sjedis.smembers(key);
 435.             returnJedis(sjedis);
 436.             return set;
 437.         }
 438.
 439.         public Set<byte[]> smembers(byte[] key) {
 440.             //ShardedJedis sjedis = getShardedJedis();
 441.             Jedis sjedis = getJedis();
 442.             Set<byte[]> set = sjedis.smembers(key);
 443.             returnJedis(sjedis);
 444.             return set;
 445.         }
 446.
 447.         /**
 448.          * 将成员从源集合移出放入目标集合 <br/>
 449.          * 如果源集合不存在或不包哈指定成员，不进行任何操作，返回0<br/>
 450.          * 否则该成员从源集合上删除，并添加到目标集合，如果目标集合中成员已存在，则只在源集合进行删除
 451.          * @param String  srckey 源集合
 452.          * @param String dstkey 目标集合
 453.          * @param String member 源集合中的成员
 454.          * @return 状态码，1成功，0失败
 455.          * */
 456.         public long smove(String srckey, String dstkey, String member) {
 457.             Jedis jedis = getJedis();
 458.             long s = jedis.smove(srckey, dstkey, member);
 459.             returnJedis(jedis);
 460.             return s;
 461.         }
 462.
 463.         /**
 464.          * 从集合中删除成员
 465.          * @param String  key
 466.          * @return 被删除的成员
 467.          * */
 468.         public String spop(String key) {
 469.             Jedis jedis = getJedis();
 470.             String s = jedis.spop(key);
 471.             returnJedis(jedis);
 472.             return s;
 473.         }
 474.
 475.         /**
 476.          * 从集合中删除指定成员
 477.          * @param String key
 478.          * @param String  member 要删除的成员
 479.          * @return 状态码，成功返回1，成员不存在返回0
 480.          * */
 481.         public long srem(String key, String member) {
 482.             Jedis jedis = getJedis();
 483.             long s = jedis.srem(key, member);
 484.             returnJedis(jedis);
 485.             return s;
 486.         }
 487.
 488.         /**
 489.          * 合并多个集合并返回合并后的结果，合并后的结果集合并不保存<br/>
 490.          * @param String  ... keys
 491.          * @return 合并后的结果集合
 492.          * @see sunionstore
 493.          * */
 494.         public Set<String> sunion(String... keys) {
 495.             Jedis jedis = getJedis();
 496.             Set<String> set = jedis.sunion(keys);
 497.             returnJedis(jedis);
 498.             return set;
 499.         }
 500.
 501.         /**
 502.          * 合并多个集合并将合并后的结果集保存在指定的新集合中，如果新集合已经存在则覆盖
 503.          * @param String  newkey 新集合的key
 504.          * @param String ... keys 要合并的集合
 505.          * **/
 506.         public long sunionstore(String newkey, String... keys) {
 507.             Jedis jedis = getJedis();
 508.             long s = jedis.sunionstore(newkey, keys);
 509.             returnJedis(jedis);
 510.             return s;
 511.         }
 512.     }
 513.
 514.     //*******************************************SortSet*******************************************//
 515.     public class SortSet {
 516.
 517.         /**
 518.          * 向集合中增加一条记录,如果这个值已存在，这个值对应的权重将被置为新的权重
 519.          * @param String  key
 520.          * @param double score 权重
 521.          * @param String  member 要加入的值，
 522.          * @return 状态码 1成功，0已存在member的值
 523.          * */
 524.         public long zadd(String key, double score, String member) {
 525.             Jedis jedis = getJedis();
 526.             long s = jedis.zadd(key, score, member);
 527.             returnJedis(jedis);
 528.             return s;
 529.         }
 530.
 531.         /*public long zadd(String key, Map<Double, String> scoreMembers) {
 532.             Jedis jedis = getJedis();
 533.             long s = jedis.zadd(key, scoreMembers);
 534.             returnJedis(jedis);
 535.             return s;
 536.         }*/
 537.
 538.         /**
 539.          * 获取集合中元素的数量
 540.          * @param String  key
 541.          * @return 如果返回0则集合不存在
 542.          * */
 543.         public long zcard(String key) {
 544.             //ShardedJedis sjedis = getShardedJedis();
 545.             Jedis sjedis = getJedis();
 546.             long len = sjedis.zcard(key);
 547.             returnJedis(sjedis);
 548.             return len;
 549.         }
 550.
 551.         /**
 552.          * 获取指定权重区间内集合的数量
 553.          * @param String key
 554.          * @param double min 最小排序位置
 555.          * @param double max 最大排序位置
 556.          * */
 557.         public long zcount(String key, double min, double max) {
 558.             //ShardedJedis sjedis = getShardedJedis();
 559.             Jedis sjedis = getJedis();
 560.             long len = sjedis.zcount(key, min, max);
 561.             returnJedis(sjedis);
 562.             return len;
 563.         }
 564.
 565.         /**
 566.          * 获得set的长度
 567.          *
 568.          * @param key
 569.          * @return
 570.          */
 571.         public long zlength(String key) {
 572.             long len = 0;
 573.             Set<String> set = zrange(key, 0, -1);
 574.             len = set.size();
 575.             return len;
 576.         }
 577.
 578.         /**
 579.          * 权重增加给定值，如果给定的member已存在
 580.          * @param String  key
 581.          * @param double score 要增的权重
 582.          * @param String  member 要插入的值
 583.          * @return 增后的权重
 584.          * */
 585.         public double zincrby(String key, double score, String member) {
 586.             Jedis jedis = getJedis();
 587.             double s = jedis.zincrby(key, score, member);
 588.             returnJedis(jedis);
 589.             return s;
 590.         }
 591.
 592.         /**
 593.          * 返回指定位置的集合元素,0为第一个元素，-1为最后一个元素
 594.          * @param String key
 595.          * @param int start 开始位置(包含)
 596.          * @param int end 结束位置(包含)
 597.          * @return Set<String>
 598.          * */
 599.         public Set<String> zrange(String key, int start, int end) {
 600.             //ShardedJedis sjedis = getShardedJedis();
 601.             Jedis sjedis = getJedis();
 602.             Set<String> set = sjedis.zrange(key, start, end);
 603.             returnJedis(sjedis);
 604.             return set;
 605.         }
 606.
 607.         /**
 608.          * 返回指定权重区间的元素集合
 609.          * @param String key
 610.          * @param double min 上限权重
 611.          * @param double max 下限权重
 612.          * @return Set<String>
 613.          * */
 614.         public Set<String> zrangeByScore(String key, double min, double max) {
 615.             //ShardedJedis sjedis = getShardedJedis();
 616.             Jedis sjedis = getJedis();
 617.             Set<String> set = sjedis.zrangeByScore(key, min, max);
 618.             returnJedis(sjedis);
 619.             return set;
 620.         }
 621.
 622.         /**
 623.          * 获取指定值在集合中的位置，集合排序从低到高
 624.          * @see zrevrank
 625.          * @param String key
 626.          * @param String member
 627.          * @return long 位置
 628.          * */
 629.         public long zrank(String key, String member) {
 630.             //ShardedJedis sjedis = getShardedJedis();
 631.             Jedis sjedis = getJedis();
 632.             long index = sjedis.zrank(key, member);
 633.             returnJedis(sjedis);
 634.             return index;
 635.         }
 636.
 637.         /**
 638.          * 获取指定值在集合中的位置，集合排序从高到低
 639.          * @see zrank
 640.          * @param String key
 641.          * @param String member
 642.          * @return long 位置
 643.          * */
 644.         public long zrevrank(String key, String member) {
 645.             //ShardedJedis sjedis = getShardedJedis();
 646.             Jedis sjedis = getJedis();
 647.             long index = sjedis.zrevrank(key, member);
 648.             returnJedis(sjedis);
 649.             return index;
 650.         }
 651.
 652.         /**
 653.          * 从集合中删除成员
 654.          * @param String key
 655.          * @param String member
 656.          * @return 返回1成功
 657.          * */
 658.         public long zrem(String key, String member) {
 659.             Jedis jedis = getJedis();
 660.             long s = jedis.zrem(key, member);
 661.             returnJedis(jedis);
 662.             return s;
 663.         }
 664.
 665.         /**
 666.          * 删除
 667.          * @param key
 668.          * @return
 669.          */
 670.         public long zrem(String key) {
 671.             Jedis jedis = getJedis();
 672.             long s = jedis.del(key);
 673.             returnJedis(jedis);
 674.             return s;
 675.         }
 676.
 677.         /**
 678.          * 删除给定位置区间的元素
 679.          * @param String  key
 680.          * @param int start 开始区间，从0开始(包含)
 681.          * @param int end 结束区间,-1为最后一个元素(包含)
 682.          * @return 删除的数量
 683.          * */
 684.         public long zremrangeByRank(String key, int start, int end) {
 685.             Jedis jedis = getJedis();
 686.             long s = jedis.zremrangeByRank(key, start, end);
 687.             returnJedis(jedis);
 688.             return s;
 689.         }
 690.
 691.         /**
 692.          * 删除给定权重区间的元素
 693.          * @param String key
 694.          * @param double min 下限权重(包含)
 695.          * @param double max 上限权重(包含)
 696.          * @return 删除的数量
 697.          * */
 698.         public long zremrangeByScore(String key, double min, double max) {
 699.             Jedis jedis = getJedis();
 700.             long s = jedis.zremrangeByScore(key, min, max);
 701.             returnJedis(jedis);
 702.             return s;
 703.         }
 704.
 705.         /**
 706.          * 获取给定区间的元素，原始按照权重由高到低排序
 707.          * @param String  key
 708.          * @param int start
 709.          * @param int end
 710.          * @return Set<String>
 711.          * */
 712.         public Set<String> zrevrange(String key, int start, int end) {
 713.             //ShardedJedis sjedis = getShardedJedis();
 714.             Jedis sjedis = getJedis();
 715.             Set<String> set = sjedis.zrevrange(key, start, end);
 716.             returnJedis(sjedis);
 717.             return set;
 718.         }
 719.
 720.         /**
 721.          * 获取给定值在集合中的权重
 722.          * @param String  key
 723.          * @param memeber
 724.          * @return double 权重
 725.          * */
 726.         public double zscore(String key, String memebr) {
 727.             //ShardedJedis sjedis = getShardedJedis();
 728.             Jedis sjedis = getJedis();
 729.             Double score = sjedis.zscore(key, memebr);
 730.             returnJedis(sjedis);
 731.             if (score != null)
 732.                 return score;
 733.             return 0;
 734.         }
 735.     }
 736.
 737.     //*******************************************Hash*******************************************//
 738.     public class Hash {
 739.
 740.         /**
 741.          * 从hash中删除指定的存储
 742.          * @param String key
 743.          * @param String  fieid 存储的名字
 744.          * @return 状态码，1成功，0失败
 745.          * */
 746.         public long hdel(String key, String fieid) {
 747.             Jedis jedis = getJedis();
 748.             long s = jedis.hdel(key, fieid);
 749.             returnJedis(jedis);
 750.             return s;
 751.         }
 752.
 753.         public long hdel(String key) {
 754.             Jedis jedis = getJedis();
 755.             long s = jedis.del(key);
 756.             returnJedis(jedis);
 757.             return s;
 758.         }
 759.
 760.         /**
 761.          * 测试hash中指定的存储是否存在
 762.          * @param String key
 763.          * @param String  fieid 存储的名字
 764.          * @return 1存在，0不存在
 765.          * */
 766.         public boolean hexists(String key, String fieid) {
 767.             //ShardedJedis sjedis = getShardedJedis();
 768.             Jedis sjedis = getJedis();
 769.             boolean s = sjedis.hexists(key, fieid);
 770.             returnJedis(sjedis);
 771.             return s;
 772.         }
 773.
 774.         /**
 775.          * 返回hash中指定存储位置的值
 776.          *
 777.          * @param String key
 778.          * @param String fieid 存储的名字
 779.          * @return 存储对应的值
 780.          * */
 781.         public String hget(String key, String fieid) {
 782.             //ShardedJedis sjedis = getShardedJedis();
 783.             Jedis sjedis = getJedis();
 784.             String s = sjedis.hget(key, fieid);
 785.             returnJedis(sjedis);
 786.             return s;
 787.         }
 788.
 789.         public byte[] hget(byte[] key, byte[] fieid) {
 790.             //ShardedJedis sjedis = getShardedJedis();
 791.             Jedis sjedis = getJedis();
 792.             byte[] s = sjedis.hget(key, fieid);
 793.             returnJedis(sjedis);
 794.             return s;
 795.         }
 796.
 797.         /**
 798.          * 以Map的形式返回hash中的存储和值
 799.          * @param String    key
 800.          * @return Map<Strinig,String>
 801.          * */
 802.         public Map<String, String> hgetAll(String key) {
 803.             //ShardedJedis sjedis = getShardedJedis();
 804.             Jedis sjedis = getJedis();
 805.             Map<String, String> map = sjedis.hgetAll(key);
 806.             returnJedis(sjedis);
 807.             return map;
 808.         }
 809.
 810.         /**
 811.          * 添加一个对应关系
 812.          * @param String  key
 813.          * @param String fieid
 814.          * @param String value
 815.          * @return 状态码 1成功，0失败，fieid已存在将更新，也返回0
 816.          * **/
 817.         public long hset(String key, String fieid, String value) {
 818.             Jedis jedis = getJedis();
 819.             long s = jedis.hset(key, fieid, value);
 820.             returnJedis(jedis);
 821.             return s;
 822.         }
 823.
 824.         public long hset(String key, String fieid, byte[] value) {
 825.             Jedis jedis = getJedis();
 826.             long s = jedis.hset(key.getBytes(), fieid.getBytes(), value);
 827.             returnJedis(jedis);
 828.             return s;
 829.         }
 830.
 831.         /**
 832.          * 添加对应关系，只有在fieid不存在时才执行
 833.          * @param String key
 834.          * @param String fieid
 835.          * @param String value
 836.          * @return 状态码 1成功，0失败fieid已存
 837.          * **/
 838.         public long hsetnx(String key, String fieid, String value) {
 839.             Jedis jedis = getJedis();
 840.             long s = jedis.hsetnx(key, fieid, value);
 841.             returnJedis(jedis);
 842.             return s;
 843.         }
 844.
 845.         /**
 846.          * 获取hash中value的集合
 847.          *
 848.          * @param String
 849.          *            key
 850.          * @return List<String>
 851.          * */
 852.         public List<String> hvals(String key) {
 853.             //ShardedJedis sjedis = getShardedJedis();
 854.             Jedis sjedis = getJedis();
 855.             List<String> list = sjedis.hvals(key);
 856.             returnJedis(sjedis);
 857.             return list;
 858.         }
 859.
 860.         /**
 861.          * 在指定的存储位置加上指定的数字，存储位置的值必须可转为数字类型
 862.          * @param String  key
 863.          * @param String  fieid 存储位置
 864.          * @param String long value 要增加的值,可以是负数
 865.          * @return 增加指定数字后，存储位置的值
 866.          * */
 867.         public long hincrby(String key, String fieid, long value) {
 868.             Jedis jedis = getJedis();
 869.             long s = jedis.hincrBy(key, fieid, value);
 870.             returnJedis(jedis);
 871.             return s;
 872.         }
 873.
 874.         /**
 875.          * 返回指定hash中的所有存储名字,类似Map中的keySet方法
 876.          * @param String key
 877.          * @return Set<String> 存储名称的集合
 878.          * */
 879.         public Set<String> hkeys(String key) {
 880.             //ShardedJedis sjedis = getShardedJedis();
 881.             Jedis sjedis = getJedis();
 882.             Set<String> set = sjedis.hkeys(key);
 883.             returnJedis(sjedis);
 884.             return set;
 885.         }
 886.
 887.         /**
 888.          * 获取hash中存储的个数，类似Map中size方法
 889.          * @param String  key
 890.          * @return long 存储的个数
 891.          * */
 892.         public long hlen(String key) {
 893.             //ShardedJedis sjedis = getShardedJedis();
 894.             Jedis sjedis = getJedis();
 895.             long len = sjedis.hlen(key);
 896.             returnJedis(sjedis);
 897.             return len;
 898.         }
 899.
 900.         /**
 901.          * 根据多个key，获取对应的value，返回List,如果指定的key不存在,List对应位置为null
 902.          * @param String  key
 903.          * @param String ... fieids 存储位置
 904.          * @return List<String>
 905.          * */
 906.         public List<String> hmget(String key, String... fieids) {
 907.             //ShardedJedis sjedis = getShardedJedis();
 908.             Jedis sjedis = getJedis();
 909.             List<String> list = sjedis.hmget(key, fieids);
 910.             returnJedis(sjedis);
 911.             return list;
 912.         }
 913.
 914.         public List<byte[]> hmget(byte[] key, byte[]... fieids) {
 915.             //ShardedJedis sjedis = getShardedJedis();
 916.             Jedis sjedis = getJedis();
 917.             List<byte[]> list = sjedis.hmget(key, fieids);
 918.             returnJedis(sjedis);
 919.             return list;
 920.         }
 921.
 922.         /**
 923.          * 添加对应关系，如果对应关系已存在，则覆盖
 924.          * @param Strin   key
 925.          * @param Map <String,String> 对应关系
 926.          * @return 状态，成功返回OK
 927.          * */
 928.         public String hmset(String key, Map<String, String> map) {
 929.             Jedis jedis = getJedis();
 930.             String s = jedis.hmset(key, map);
 931.             returnJedis(jedis);
 932.             return s;
 933.         }
 934.
 935.         /**
 936.          * 添加对应关系，如果对应关系已存在，则覆盖
 937.          * @param Strin key
 938.          * @param Map <String,String> 对应关系
 939.          * @return 状态，成功返回OK
 940.          * */
 941.         public String hmset(byte[] key, Map<byte[], byte[]> map) {
 942.             Jedis jedis = getJedis();
 943.             String s = jedis.hmset(key, map);
 944.             returnJedis(jedis);
 945.             return s;
 946.         }
 947.
 948.     }
 949.
 950.
 951.     //*******************************************Strings*******************************************//
 952.     public class Strings {
 953.         /**
 954.          * 根据key获取记录
 955.          * @param String  key
 956.          * @return 值
 957.          * */
 958.         public String get(String key) {
 959.             //ShardedJedis sjedis = getShardedJedis();
 960.             Jedis sjedis = getJedis();
 961.             String value = sjedis.get(key);
 962.             returnJedis(sjedis);
 963.             return value;
 964.         }
 965.
 966.         /**
 967.          * 根据key获取记录
 968.          * @param byte[] key
 969.          * @return 值
 970.          * */
 971.         public byte[] get(byte[] key) {
 972.             //ShardedJedis sjedis = getShardedJedis();
 973.             Jedis sjedis = getJedis();
 974.             byte[] value = sjedis.get(key);
 975.             returnJedis(sjedis);
 976.             return value;
 977.         }
 978.
 979.         /**
 980.          * 添加有过期时间的记录
 981.          *
 982.          * @param String  key
 983.          * @param int seconds 过期时间，以秒为单位
 984.          * @param String value
 985.          * @return String 操作状态
 986.          * */
 987.         public String setEx(String key, int seconds, String value) {
 988.             Jedis jedis = getJedis();
 989.             String str = jedis.setex(key, seconds, value);
 990.             returnJedis(jedis);
 991.             return str;
 992.         }
 993.
 994.         /**
 995.          * 添加有过期时间的记录
 996.          *
 997.          * @param String key
 998.          * @param int seconds 过期时间，以秒为单位
 999.          * @param String  value
 1000.          * @return String 操作状态
 1001.          * */
 1002.         public String setEx(byte[] key, int seconds, byte[] value) {
 1003.             Jedis jedis = getJedis();
 1004.             String str = jedis.setex(key, seconds, value);
 1005.             returnJedis(jedis);
 1006.             return str;
 1007.         }
 1008.
 1009.         /**
 1010.          * 添加一条记录，仅当给定的key不存在时才插入
 1011.          * @param String key
 1012.          * @param String value
 1013.          * @return long 状态码，1插入成功且key不存在，0未插入，key存在
 1014.          * */
 1015.         public long setnx(String key, String value) {
 1016.             Jedis jedis = getJedis();
 1017.             long str = jedis.setnx(key, value);
 1018.             returnJedis(jedis);
 1019.             return str;
 1020.         }
 1021.
 1022.         /**
 1023.          * 添加记录,如果记录已存在将覆盖原有的value
 1024.          * @param String key
 1025.          * @param String value
 1026.          * @return 状态码
 1027.          * */
 1028.         public String set(String key, String value) {
 1029.             return set(SafeEncoder.encode(key), SafeEncoder.encode(value));
 1030.         }
 1031.
 1032.         /**
 1033.          * 添加记录,如果记录已存在将覆盖原有的value
 1034.          * @param String  key
 1035.          * @param String value
 1036.          * @return 状态码
 1037.          * */
 1038.         public String set(String key, byte[] value) {
 1039.             return set(SafeEncoder.encode(key), value);
 1040.         }
 1041.
 1042.         /**
 1043.          * 添加记录,如果记录已存在将覆盖原有的value
 1044.          * @param byte[] key
 1045.          * @param byte[] value
 1046.          * @return 状态码
 1047.          * */
 1048.         public String set(byte[] key, byte[] value) {
 1049.             Jedis jedis = getJedis();
 1050.             String status = jedis.set(key, value);
 1051.             returnJedis(jedis);
 1052.             return status;
 1053.         }
 1054.
 1055.         /**
 1056.          * 从指定位置开始插入数据，插入的数据会覆盖指定位置以后的数据<br/>
 1057.          * 例:String str1="123456789";<br/>
 1058.          * 对str1操作后setRange(key,4,0000)，str1="123400009";
 1059.          * @param String  key
 1060.          * @param long offset
 1061.          * @param String  value
 1062.          * @return long value的长度
 1063.          * */
 1064.         public long setRange(String key, long offset, String value) {
 1065.             Jedis jedis = getJedis();
 1066.             long len = jedis.setrange(key, offset, value);
 1067.             returnJedis(jedis);
 1068.             return len;
 1069.         }
 1070.
 1071.         /**
 1072.          * 在指定的key中追加value
 1073.          * @param String  key
 1074.          * @param String value
 1075.          * @return long 追加后value的长度
 1076.          * **/
 1077.         public long append(String key, String value) {
 1078.             Jedis jedis = getJedis();
 1079.             long len = jedis.append(key, value);
 1080.             returnJedis(jedis);
 1081.             return len;
 1082.         }
 1083.
 1084.         /**
 1085.          * 将key对应的value减去指定的值，只有value可以转为数字时该方法才可用
 1086.          * @param String key
 1087.          * @param long number 要减去的值
 1088.          * @return long 减指定值后的值
 1089.          * */
 1090.         public long decrBy(String key, long number) {
 1091.             Jedis jedis = getJedis();
 1092.             long len = jedis.decrBy(key, number);
 1093.             returnJedis(jedis);
 1094.             return len;
 1095.         }
 1096.
 1097.         /**
 1098.          * <b>可以作为获取唯一id的方法</b><br/>
 1099.          * 将key对应的value加上指定的值，只有value可以转为数字时该方法才可用
 1100.          * @param String  key
 1101.          * @param long number 要减去的值
 1102.          * @return long 相加后的值
 1103.          * */
 1104.         public long incrBy(String key, long number) {
 1105.             Jedis jedis = getJedis();
 1106.             long len = jedis.incrBy(key, number);
 1107.             returnJedis(jedis);
 1108.             return len;
 1109.         }
 1110.
 1111.         /**
 1112.          * 对指定key对应的value进行截取
 1113.          * @param String   key
 1114.          * @param long startOffset 开始位置(包含)
 1115.          * @param long endOffset 结束位置(包含)
 1116.          * @return String 截取的值
 1117.          * */
 1118.         public String getrange(String key, long startOffset, long endOffset) {
 1119.             //ShardedJedis sjedis = getShardedJedis();
 1120.             Jedis sjedis = getJedis();
 1121.             String value = sjedis.getrange(key, startOffset, endOffset);
 1122.             returnJedis(sjedis);
 1123.             return value;
 1124.         }
 1125.
 1126.         /**
 1127.          * 获取并设置指定key对应的value<br/>
 1128.          * 如果key存在返回之前的value,否则返回null
 1129.          * @param String  key
 1130.          * @param String value
 1131.          * @return String 原始value或null
 1132.          * */
 1133.         public String getSet(String key, String value) {
 1134.             Jedis jedis = getJedis();
 1135.             String str = jedis.getSet(key, value);
 1136.             returnJedis(jedis);
 1137.             return str;
 1138.         }
 1139.
 1140.         /**
 1141.          * 批量获取记录,如果指定的key不存在返回List的对应位置将是null
 1142.          * @param String keys
 1143.          * @return List<String> 值得集合
 1144.          * */
 1145.         public List<String> mget(String... keys) {
 1146.             Jedis jedis = getJedis();
 1147.             List<String> str = jedis.mget(keys);
 1148.             returnJedis(jedis);
 1149.             return str;
 1150.         }
 1151.
 1152.         /**
 1153.          * 批量存储记录
 1154.          * @param String keysvalues 例:keysvalues="key1","value1","key2","value2";
 1155.          * @return String 状态码
 1156.          * */
 1157.         public String mset(String... keysvalues) {
 1158.             Jedis jedis = getJedis();
 1159.             String str = jedis.mset(keysvalues);
 1160.             returnJedis(jedis);
 1161.             return str;
 1162.         }
 1163.
 1164.         /**
 1165.          * 获取key对应的值的长度
 1166.          * @param String key
 1167.          * @return value值得长度
 1168.          * */
 1169.         public long strlen(String key) {
 1170.             Jedis jedis = getJedis();
 1171.             long len = jedis.strlen(key);
 1172.             returnJedis(jedis);
 1173.             return len;
 1174.         }
 1175.     }
 1176.
 1177.
 1178.     //*******************************************Lists*******************************************//
 1179.     public class Lists {
 1180.         /**
 1181.          * List长度
 1182.          * @param String key
 1183.          * @return 长度
 1184.          * */
 1185.         public long llen(String key) {
 1186.             return llen(SafeEncoder.encode(key));
 1187.         }
 1188.
 1189.         /**
 1190.          * List长度
 1191.          * @param byte[] key
 1192.          * @return 长度
 1193.          * */
 1194.         public long llen(byte[] key) {
 1195.             //ShardedJedis sjedis = getShardedJedis();
 1196.             Jedis sjedis = getJedis();
 1197.             long count = sjedis.llen(key);
 1198.             returnJedis(sjedis);
 1199.             return count;
 1200.         }
 1201.
 1202.         /**
 1203.          * 覆盖操作,将覆盖List中指定位置的值
 1204.          * @param byte[] key
 1205.          * @param int index 位置
 1206.          * @param byte[] value 值
 1207.          * @return 状态码
 1208.          * */
 1209.         public String lset(byte[] key, int index, byte[] value) {
 1210.             Jedis jedis = getJedis();
 1211.             String status = jedis.lset(key, index, value);
 1212.             returnJedis(jedis);
 1213.             return status;
 1214.         }
 1215.
 1216.         /**
 1217.          * 覆盖操作,将覆盖List中指定位置的值
 1218.          * @param key
 1219.          * @param int index 位置
 1220.          * @param String  value 值
 1221.          * @return 状态码
 1222.          * */
 1223.         public String lset(String key, int index, String value) {
 1224.             return lset(SafeEncoder.encode(key), index,
 1225.                     SafeEncoder.encode(value));
 1226.         }
 1227.
 1228.         /**
 1229.          * 在value的相对位置插入记录
 1230.          * @param key
 1231.          * @param LIST_POSITION   前面插入或后面插入
 1232.          * @param String pivot 相对位置的内容
 1233.          * @param String value 插入的内容
 1234.          * @return 记录总数
 1235.          * */
 1236.         public long linsert(String key, LIST_POSITION where, String pivot,
 1237.                 String value) {
 1238.             return linsert(SafeEncoder.encode(key), where,
 1239.                     SafeEncoder.encode(pivot), SafeEncoder.encode(value));
 1240.         }
 1241.
 1242.         /**
 1243.          * 在指定位置插入记录
 1244.          * @param String key
 1245.          * @param LIST_POSITION 前面插入或后面插入
 1246.          * @param byte[] pivot 相对位置的内容
 1247.          * @param byte[] value 插入的内容
 1248.          * @return 记录总数
 1249.          * */
 1250.         public long linsert(byte[] key, LIST_POSITION where, byte[] pivot,
 1251.                 byte[] value) {
 1252.             Jedis jedis = getJedis();
 1253.             long count = jedis.linsert(key, where, pivot, value);
 1254.             returnJedis(jedis);
 1255.             return count;
 1256.         }
 1257.
 1258.         /**
 1259.          * 获取List中指定位置的值
 1260.          * @param String  key
 1261.          * @param int index 位置
 1262.          * @return 值
 1263.          * **/
 1264.         public String lindex(String key, int index) {
 1265.             return SafeEncoder.encode(lindex(SafeEncoder.encode(key), index));
 1266.         }
 1267.
 1268.         /**
 1269.          * 获取List中指定位置的值
 1270.          * @param byte[] key
 1271.          * @param int index 位置
 1272.          * @return 值
 1273.          * **/
 1274.         public byte[] lindex(byte[] key, int index) {
 1275.             //ShardedJedis sjedis = getShardedJedis();
 1276.             Jedis sjedis = getJedis();
 1277.             byte[] value = sjedis.lindex(key, index);
 1278.             returnJedis(sjedis);
 1279.             return value;
 1280.         }
 1281.
 1282.         /**
 1283.          * 将List中的第一条记录移出List
 1284.          * @param String key
 1285.          * @return 移出的记录
 1286.          * */
 1287.         public String lpop(String key) {
 1288.             return SafeEncoder.encode(lpop(SafeEncoder.encode(key)));
 1289.         }
 1290.
 1291.         /**
 1292.          * 将List中的第一条记录移出List
 1293.          * @param byte[] key
 1294.          * @return 移出的记录
 1295.          * */
 1296.         public byte[] lpop(byte[] key) {
 1297.             Jedis jedis = getJedis();
 1298.             byte[] value = jedis.lpop(key);
 1299.             returnJedis(jedis);
 1300.             return value;
 1301.         }
 1302.
 1303.         /**
 1304.          * 将List中最后第一条记录移出List
 1305.          *
 1306.          * @param byte[] key
 1307.          * @return 移出的记录
 1308.          * */
 1309.         public String rpop(String key) {
 1310.             Jedis jedis = getJedis();
 1311.             String value = jedis.rpop(key);
 1312.             returnJedis(jedis);
 1313.             return value;
 1314.         }
 1315.
 1316.         /**
 1317.          * 向List尾部追加记录
 1318.          * @param String key
 1319.          * @param String value
 1320.          * @return 记录总数
 1321.          * */
 1322.         public long lpush(String key, String value) {
 1323.             return lpush(SafeEncoder.encode(key), SafeEncoder.encode(value));
 1324.         }
 1325.
 1326.         /**
 1327.          * 向List头部追加记录
 1328.          * @param String  key
 1329.          * @param String  value
 1330.          * @return 记录总数
 1331.          * */
 1332.         public long rpush(String key, String value) {
 1333.             Jedis jedis = getJedis();
 1334.             long count = jedis.rpush(key, value);
 1335.             returnJedis(jedis);
 1336.             return count;
 1337.         }
 1338.
 1339.         /**
 1340.          * 向List头部追加记录
 1341.          * @param String key
 1342.          * @param String value
 1343.          * @return 记录总数
 1344.          * */
 1345.         public long rpush(byte[] key, byte[] value) {
 1346.             Jedis jedis = getJedis();
 1347.             long count = jedis.rpush(key, value);
 1348.             returnJedis(jedis);
 1349.             return count;
 1350.         }
 1351.
 1352.         /**
 1353.          * 向List中追加记录
 1354.          * @param byte[] key
 1355.          * @param byte[] value
 1356.          * @return 记录总数
 1357.          * */
 1358.         public long lpush(byte[] key, byte[] value) {
 1359.             Jedis jedis = getJedis();
 1360.             long count = jedis.lpush(key, value);
 1361.             returnJedis(jedis);
 1362.             return count;
 1363.         }
 1364.
 1365.         /**
 1366.          * 获取指定范围的记录，可以做为分页使用
 1367.          * @param String key
 1368.          * @param long start
 1369.          * @param long end
 1370.          * @return List
 1371.          * */
 1372.         public List<String> lrange(String key, long start, long end) {
 1373.             //ShardedJedis sjedis = getShardedJedis();
 1374.             Jedis sjedis = getJedis();
 1375.             List<String> list = sjedis.lrange(key, start, end);
 1376.             returnJedis(sjedis);
 1377.             return list;
 1378.         }
 1379.
 1380.         /**
 1381.          * 获取指定范围的记录，可以做为分页使用
 1382.          * @param byte[] key
 1383.          * @param int start
 1384.          * @param int end 如果为负数，则尾部开始计算
 1385.          * @return List
 1386.          * */
 1387.         public List<byte[]> lrange(byte[] key, int start, int end) {
 1388.             //ShardedJedis sjedis = getShardedJedis();
 1389.             Jedis sjedis = getJedis();
 1390.             List<byte[]> list = sjedis.lrange(key, start, end);
 1391.             returnJedis(sjedis);
 1392.             return list;
 1393.         }
 1394.
 1395.         /**
 1396.          * 删除List中c条记录，被删除的记录值为value
 1397.          * @param byte[] key
 1398.          * @param int c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录
 1399.          * @param byte[] value 要匹配的值
 1400.          * @return 删除后的List中的记录数
 1401.          * */
 1402.         public long lrem(byte[] key, int c, byte[] value) {
 1403.             Jedis jedis = getJedis();
 1404.             long count = jedis.lrem(key, c, value);
 1405.             returnJedis(jedis);
 1406.             return count;
 1407.         }
 1408.
 1409.         /**
 1410.          * 删除List中c条记录，被删除的记录值为value
 1411.          * @param String key
 1412.          * @param int c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录
 1413.          * @param String value 要匹配的值
 1414.          * @return 删除后的List中的记录数
 1415.          * */
 1416.         public long lrem(String key, int c, String value) {
 1417.             return lrem(SafeEncoder.encode(key), c, SafeEncoder.encode(value));
 1418.         }
 1419.
 1420.         /**
 1421.          * 算是删除吧，只保留start与end之间的记录
 1422.          * @param byte[] key
 1423.          * @param int start 记录的开始位置(0表示第一条记录)
 1424.          * @param int end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推）
 1425.          * @return 执行状态码
 1426.          * */
 1427.         public String ltrim(byte[] key, int start, int end) {
 1428.             Jedis jedis = getJedis();
 1429.             String str = jedis.ltrim(key, start, end);
 1430.             returnJedis(jedis);
 1431.             return str;
 1432.         }
 1433.
 1434.         /**
 1435.          * 算是删除吧，只保留start与end之间的记录
 1436.          * @param String key
 1437.          * @param int start 记录的开始位置(0表示第一条记录)
 1438.          * @param int end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推）
 1439.          * @return 执行状态码
 1440.          * */
 1441.         public String ltrim(String key, int start, int end) {
 1442.             return ltrim(SafeEncoder.encode(key), start, end);
 1443.         }
 1444.     }
 1445.
 1446.     public static void main(String[] args) {
 1447.         JedisUtil jedisUtil= JedisUtil.getInstance();
 1448.         JedisUtil.Strings strings=jedisUtil.new Strings();
 1449.         strings.set("nnn", "nnnn");
 1450.         System.out.println("-----"+strings.get("nnn"));
 1451.
 1452.         Jedis jedis=JedisUtil.getInstance().getJedis();
 1453.         for (int i = 0; i < 10; i++) {
 1454.             jedis.set("test", "test");
 1455.             System.out.println(i+"=="+jedis.get("test"));
 1456.
 1457.         }
 1458.         JedisUtil.getInstance().returnJedis(jedis);
 1459.     }
 1460.
 1461. }  

3.

测试 类 ：

  JedisUtil jedisUtil= JedisUtil.getInstance();
 2.         JedisUtil.Strings strings=jedisUtil.new Strings();
 3.         strings.set("nnn", "nnnn");
 4.         System.out.println("-----"+strings.get("nnn"));     

这个可以自己玩玩

毕竟项目中只是用到它来存日志文件的

　　主要还是好好学习mysql  及 Oracle

欢迎大家吐槽 我的不足之处      @@@@@@@@@@@@@@@@@@@@@