RedisUtil工具类

原文地址:http://blog.csdn.net/liuxiao723846/article/details/50401406

1、使用了jedis客户端，对Redis进行了封装，包括：

1）使用了redispool获取连接；以及连接的回收；

2）常用五种数据结构的常用操作封装；

[java] view plain copy
  1. 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. }  


2、序列化、反序列化：

redis服务器本身支持二进制安全的类型，所以可以把一个Java对象序列化后存储到redis中。下面封装了一个序列化、反序列化的工具类：

[java] view plain copy
  1. package redis.utils;  
  2.   
  3. import java.io.ByteArrayInputStream;  
  4. import java.io.ByteArrayOutputStream;  
  5. import java.io.ObjectInputStream;  
  6. import java.io.ObjectOutputStream;  
  7.   
  8. public class SerializeUtil {  
  9.     /** 
  10.      * 序列化 
  11.      *  
  12.      * @param object 
  13.      * @return 
  14.      */  
  15.     public static byte[] serialize(Object object) {  
  16.         ObjectOutputStream oos = null;  
  17.         ByteArrayOutputStream baos = null;  
  18.         try {  
  19.             // 序列化  
  20.             baos = new ByteArrayOutputStream();  
  21.             oos = new ObjectOutputStream(baos);  
  22.             oos.writeObject(object);  
  23.             byte[] bytes = baos.toByteArray();  
  24.             return bytes;  
  25.         } catch (Exception e) {  
  26.   
  27.         }  
  28.         return null;  
  29.     }  
  30.   
  31.     /** 
  32.      * 反序列化 
  33.      *  
  34.      * @param bytes 
  35.      * @return 
  36.      */  
  37.     public static Object unserialize(byte[] bytes) {  
  38.         ByteArrayInputStream bais = null;  
  39.         try {  
  40.             // 反序列化  
  41.             bais = new ByteArrayInputStream(bytes);  
  42.             ObjectInputStream ois = new ObjectInputStream(bais);  
  43.             return ois.readObject();  
  44.         } catch (Exception e) {  
  45.   
  46.         }  
  47.         return null;  
  48.     }  
  49. }  


3、测试：

1）直接使用RedisUtils实例进行五大数据类型的操作：（这样，使用完后会自动归还到池子中）

[html] view plain copy
  1. JedisUtil jedisUtil= JedisUtil.getInstance();    
  2.         JedisUtil.Strings strings=jedisUtil.new Strings();  
  3.         strings.set("nnn", "nnnn");   
  4.         System.out.println("-----"+strings.get("nnn"));     


2）通过RedisUtil实例获取Jedis连接对象；这样就可以用原生的方式使用；最后使用完后需要手动将其归还到池子中：

[java] view plain copy
  1. Jedis jedis=JedisUtil.getInstance().getJedis();   
  2.         for (int i = 0; i < 10; i++) {   
  3.             jedis.set("test", "test");   
  4.             System.out.println(i+"=="+jedis.get("test"));    
  5.           
  6.         }  
  7.         JedisUtil.getInstance().returnJedis(jedis);    


3）将java对象存到redis中：

[java] view plain copy
    1. Person p = new Person();  
    2.         p.setId(3);  
    3.         p.setName("测试");  
    4.           
    5.         JedisUtil.Strings strings=jedisUtil.new Strings();  
    6.         strings.set("object3", SerializeUtil.serialize(p));  
    7.           
    8.         //jedis.set(SafeEncoder.encode("object1"),SerializeUtil.serialize(p));  
    9.         byte[] personBy = jedis.get(SafeEncoder.encode("object3"));  
    10.         Person p1 = (Person) SerializeUtil.unserialize(personBy);  
    11.         System.out.println(p1.getName()); 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/austinspark-jessylu/p/7357805.html