注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

itoedr的it学苑

记录从IT文盲学到专家的历程

 
 
 

日志

 
 

Redis应用案例:java整合(2)  

2013-07-18 16:38:54|  分类: 新型数据库 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
相关Redis的Java封装:
  1. import java.util.List;  
  2. import java.util.Map;  
  3. import java.util.Set;  
  4.   
  5.   
  6. import javax.annotation.PostConstruct;  
  7.   
  8.   
  9. import org.springframework.beans.factory.annotation.Autowired;  
  10. import org.springframework.stereotype.Service;  
  11.   
  12.   
  13. import redis.clients.jedis.BinaryClient.LIST_POSITION;  
  14. import redis.clients.jedis.Jedis;  
  15. import redis.clients.jedis.JedisPool;  
  16. import redis.clients.jedis.ShardedJedis;  
  17. import redis.clients.jedis.ShardedJedisPool;  
  18. import redis.clients.jedis.SortingParams;  
  19. import redis.clients.util.SafeEncoder;  
  20. @Service("redisBase")  
  21. public class RedisBase{  
  22.   
  23.   
  24.      @Autowired  
  25.      private JedisPool jedisPool;  
  26.      @Autowired  
  27.      private ShardedJedisPool shardedJedisPool;  
  28.        
  29.      /**操作Key的方法*/  
  30.      public Keys KEYS;  
  31.      /**对存储结构为String类型的操作*/  
  32.      public Strings STRINGS;  
  33.      /**对存储结构为List类型的操作*/  
  34.      public Lists LISTS;  
  35.      /**对存储结构为Set类型的操作*/  
  36.      public Sets SETS;  
  37.      /**对存储结构为HashMap类型的操作*/  
  38.      public Hash HASH;  
  39.      /**对存储结构为Set(排序的)类型的操作*/  
  40.      public SortSet SORTSET;  
  41.        
  42.        
  43.      @PostConstruct  
  44.      public void init(){  
  45.          KEYS=new Keys();  
  46.          STRINGS=new Strings();  
  47.          LISTS=new Lists();  
  48.          SETS=new Sets();  
  49.          SORTSET=new SortSet();  
  50.          HASH=new Hash();  
  51.      }  
  52.        
  53.      //TODO  
  54.      public class Keys{  
  55.            
  56.            
  57.          /** 
  58.           * 更改key,仅当新key不存在时才执行 
  59.           * @param String oldkey 
  60.           * @param String newkey 
  61.           * @return 状态码 
  62.           * */  
  63.          public String flushAll(){  
  64.              Jedis jedis=jedisPool.getResource();  
  65.              String stata=jedis.flushAll();  
  66.              jedisPool.returnResource(jedis);  
  67.              return stata;  
  68.          }  
  69.            
  70.          /** 
  71.           * 更改key 
  72.           * @param String oldkey 
  73.           * @param String newkey 
  74.           * @return 状态码 
  75.           * */  
  76.          public String rename(String oldkey,String newkey){  
  77.              return rename(SafeEncoder.encode(oldkey),SafeEncoder.encode(newkey));  
  78.          }  
  79.            
  80.          /** 
  81.           * 更改key,仅当新key不存在时才执行 
  82.           * @param String oldkey 
  83.           * @param String newkey 
  84.           * @return 状态码 
  85.           * */  
  86.          public long renamenx(String oldkey,String newkey){  
  87.              Jedis jedis=jedisPool.getResource();  
  88.              long status =jedis.renamenx(oldkey, newkey);  
  89.              jedisPool.returnResource(jedis);  
  90.              return status;  
  91.          }  
  92.            
  93.          /** 
  94.           * 更改key 
  95.           * @param String oldkey 
  96.           * @param String newkey 
  97.           * @return 状态码 
  98.           * */  
  99.          public String rename(byte[] oldkey,byte[] newkey){  
  100.              Jedis jedis=jedisPool.getResource();  
  101.              String status =jedis.rename(oldkey, newkey);  
  102.              jedisPool.returnResource(jedis);  
  103.              return status;  
  104.          }  
  105.            
  106.          /** 
  107.           * 设置key的过期时间,以秒为单位 
  108.           * @param String key 
  109.           * @param 时间,已秒为单位 
  110.           * @return 影响的记录数 
  111.           * */  
  112.          public long expired(String key,int seconds){  
  113.              Jedis jedis=jedisPool.getResource();  
  114.              long count =jedis.expire(key, seconds);  
  115.              jedisPool.returnResource(jedis);  
  116.              return count;  
  117.          }  
  118.            
  119.          /** 
  120.           * 设置key的过期时间,它是距历元(即格林威治标准时间 1970 年 1 月 1 日的 00:00:00,格里高利历)的偏移量。 
  121.           * @param String key 
  122.           * @param 时间,已秒为单位 
  123.           * @return 影响的记录数 
  124.           * */  
  125.          public long expireAt(String key,long timestamp){  
  126.              Jedis jedis=jedisPool.getResource();  
  127.              long count =jedis.expireAt(key, timestamp);  
  128.              jedisPool.returnResource(jedis);  
  129.              return count;  
  130.          }  
  131.            
  132.          /** 
  133.           * 查询key的过期时间 
  134.           * @param String key 
  135.           * @return 以秒为单位的时间表示 
  136.           * */  
  137.          public long ttl(String key){  
  138.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  139.              long len=sjedis.ttl(key);  
  140.              shardedJedisPool.returnResource(sjedis);  
  141.              return len;  
  142.          }  
  143.            
  144.          /** 
  145.           * 取消对key过期时间的设置 
  146.           *@param key 
  147.           *@return 影响的记录数 
  148.           * */  
  149.          public long persist(String key){  
  150.              Jedis jedis=jedisPool.getResource();  
  151.              long count =jedis.persist(key);  
  152.              jedisPool.returnResource(jedis);  
  153.              return count;  
  154.          }  
  155.          /** 
  156.           * 删除keys对应的记录,可以是多个key 
  157.           * @param String... keys 
  158.           * @return 删除的记录数 
  159.           * */  
  160.          public long del(String... keys){  
  161.              Jedis jedis=jedisPool.getResource();  
  162.              long count =jedis.del(keys);  
  163.              jedisPool.returnResource(jedis);  
  164.              return count;  
  165.          }  
  166.            
  167.          /** 
  168.           * 删除keys对应的记录,可以是多个key 
  169.           * @param String... keys 
  170.           * @return 删除的记录数 
  171.           * */  
  172.          public long del(byte[]... keys){  
  173.              Jedis jedis=jedisPool.getResource();  
  174.              long count =jedis.del(keys);  
  175.              jedisPool.returnResource(jedis);  
  176.              return count;  
  177.          }  
  178.            
  179.          /** 
  180.           * 判断key是否存在 
  181.           * @param String key 
  182.           * @return boolean 
  183.           * */  
  184.          public boolean exists(String key){  
  185.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  186.              boolean exis=sjedis.exists(key);  
  187.              shardedJedisPool.returnResource(sjedis);  
  188.              return exis;  
  189.          }  
  190.            
  191.          /** 
  192.           * 对List,Set,SortSet进行排序,如果集合数据较大应避免使用这个方法 
  193.           * @param String key 
  194.           * @return List<String> 集合的全部记录 
  195.           * **/  
  196.          public List<String> sort(String key){  
  197.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  198.              List<String> list=sjedis.sort(key);  
  199.              shardedJedisPool.returnResource(sjedis);  
  200.              return list;  
  201.          }  
  202.            
  203.          /** 
  204.           * 对List,Set,SortSet进行排序或limit 
  205.           * @param String key 
  206.           * @param SortingParams parame 定义排序类型或limit的起止位置. 
  207.           * @return List<String> 全部或部分记录 
  208.           * **/  
  209.          public List<String> sort(String key,SortingParams parame){  
  210.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  211.              List<String> list=sjedis.sort(key, parame);  
  212.              shardedJedisPool.returnResource(sjedis);  
  213.              return list;  
  214.          }  
  215.            
  216.          /** 
  217.           * 返回指定key存储的类型 
  218.           * @param String key 
  219.           * @return String  string|list|set|zset|hash 
  220.           * **/  
  221.          public String type(String key){  
  222.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  223.              String type=sjedis.type(key);  
  224.              shardedJedisPool.returnResource(sjedis);  
  225.              return type;  
  226.          }  
  227.          /** 
  228.           * 查找所有匹配给定的模式的键 
  229.           * @param String key的表达式,*表示多个,?表示一个 
  230.           * */  
  231.          public Set<String> kyes(String pattern){  
  232.              Jedis jedis=jedisPool.getResource();  
  233.              Set<String> set =jedis.keys(pattern);  
  234.              jedisPool.returnResource(jedis);  
  235.              return set;  
  236.          }  
  237.      }  
  238.        
  239.      //TODO  
  240.      public class Sets{  
  241.            
  242.          /** 
  243.           * 向Set添加一条记录,如果member已存在返回0,否则返回1 
  244.           * @param String key 
  245.           * @param String member 
  246.           * @return 操作码,0或1 
  247.           * */  
  248.          public long sadd(String key,String member){  
  249.              Jedis jedis=jedisPool.getResource();  
  250.              long s =jedis.sadd(key, member);  
  251.              jedisPool.returnResource(jedis);  
  252.              return s;  
  253.          }  
  254.            
  255.          /** 
  256.           * 获取给定key中元素个数 
  257.           * @param String key 
  258.           * @return 元素个数 
  259.           * */  
  260.          public long scard(String key){  
  261.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  262.              long len=sjedis.scard(key);  
  263.              shardedJedisPool.returnResource(sjedis);  
  264.              return len;  
  265.          }  
  266.            
  267.          /** 
  268.           * 返回从第一组和所有的给定集合之间的差异的成员 
  269.           * @param String... keys 
  270.           * @return 差异的成员集合 
  271.           * */  
  272.          public Set<String> sdiff(String...keys){  
  273.              Jedis jedis=jedisPool.getResource();  
  274.              Set<String> set =jedis.sdiff(keys);  
  275.              jedisPool.returnResource(jedis);  
  276.              return set;  
  277.          }  
  278.            
  279.          /** 
  280.           * 这个命令等于sdiff,但返回的不是结果集,而是将结果集存储在新的集合中,如果目标已存在,则覆盖。 
  281.           * @param String newkey 新结果集的key 
  282.           * @param String... keys 比较的集合 
  283.           * @return 新集合中的记录数 
  284.           * **/  
  285.          public long sdiffstore(String newkey,String...keys){  
  286.              Jedis jedis=jedisPool.getResource();  
  287.              long s =jedis.sdiffstore(newkey, keys);  
  288.              jedisPool.returnResource(jedis);  
  289.              return s;  
  290.          }  
  291.            
  292.          /** 
  293.           * 返回给定集合交集的成员,如果其中一个集合为不存在或为空,则返回空Set 
  294.           * @param String... keys 
  295.           * @return 交集成员的集合 
  296.           * **/  
  297.          public Set<String> sinter(String...keys){  
  298.              Jedis jedis=jedisPool.getResource();  
  299.              Set<String> set =jedis.sinter(keys);  
  300.              jedisPool.returnResource(jedis);  
  301.              return set;  
  302.          }  
  303.            
  304.          /** 
  305.           * 这个命令等于sinter,但返回的不是结果集,而是将结果集存储在新的集合中,如果目标已存在,则覆盖。 
  306.           * @param String newkey 新结果集的key 
  307.           * @param String... keys 比较的集合 
  308.           * @return 新集合中的记录数 
  309.           * **/  
  310.          public long sinterstore(String newkey,String...keys){  
  311.              Jedis jedis=jedisPool.getResource();  
  312.              long s =jedis.sinterstore(newkey, keys);  
  313.              jedisPool.returnResource(jedis);  
  314.              return s;  
  315.          }  
  316.            
  317.          /** 
  318.           * 确定一个给定的值是否存在 
  319.           * @param String key 
  320.           * @param String member 要判断的值 
  321.           * @return 存在返回1,不存在返回0 
  322.           * **/  
  323.          public boolean sismember(String key,String member){  
  324.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  325.              boolean s= sjedis.sismember(key, member);  
  326.              shardedJedisPool.returnResource(sjedis);  
  327.              return s;  
  328.          }  
  329.            
  330.          /** 
  331.           * 返回集合中的所有成员 
  332.           * @param String key 
  333.           * @return 成员集合 
  334.           * */  
  335.          public Set<String> smembers(String key){  
  336.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  337.              Set<String> set= sjedis.smembers(key);  
  338.              shardedJedisPool.returnResource(sjedis);  
  339.              return set;  
  340.          }  
  341.            
  342.          /** 
  343.           * 将成员从源集合移出放入目标集合 
  344.           * <br/>如果源集合不存在或不包哈指定成员,不进行任何操作,返回0<br/> 
  345.           * 否则该成员从源集合上删除,并添加到目标集合,如果目标集合中成员已存在,则只在源集合进行删除 
  346.           * @param String srckey 源集合 
  347.           * @param String dstkey 目标集合 
  348.           * @param String member 源集合中的成员 
  349.           * @return 状态码,1成功,0失败 
  350.           * */         
  351.          public long smove(String srckey,String dstkey,String member){  
  352.              Jedis jedis=jedisPool.getResource();  
  353.              long s =jedis.smove(srckey, dstkey, member);  
  354.              jedisPool.returnResource(jedis);  
  355.              return s;  
  356.          }  
  357.            
  358.          /** 
  359.           * 从集合中删除成员 
  360.           * @param String key 
  361.           * @return 被删除的成员 
  362.           * */  
  363.          public String spop(String key){  
  364.              Jedis jedis=jedisPool.getResource();  
  365.              String s =jedis.spop(key);  
  366.              jedisPool.returnResource(jedis);  
  367.              return s;  
  368.          }  
  369.            
  370.          /** 
  371.           * 从集合中删除指定成员 
  372.           * @param String key 
  373.           * @param String member 要删除的成员 
  374.           * @return 状态码,成功返回1,成员不存在返回0 
  375.           * */  
  376.          public long srem(String key,String member){  
  377.              Jedis jedis=jedisPool.getResource();  
  378.              long s =jedis.srem(key,member);  
  379.              jedisPool.returnResource(jedis);  
  380.              return s;  
  381.          }  
  382.            
  383.          /** 
  384.           * 合并多个集合并返回合并后的结果,合并后的结果集合并不保存<br/> 
  385.           * @param String... keys 
  386.           * @return 合并后的结果集合 
  387.           * @see sunionstore 
  388.           * */  
  389.          public Set<String> sunion(String...keys){  
  390.              Jedis jedis=jedisPool.getResource();  
  391.              Set<String> set =jedis.sunion(keys);  
  392.              jedisPool.returnResource(jedis);  
  393.              return set;  
  394.          }  
  395.            
  396.          /** 
  397.           * 合并多个集合并将合并后的结果集保存在指定的新集合中,如果新集合已经存在则覆盖 
  398.           * @param String newkey 新集合的key 
  399.           * @param String... keys 要合并的集合 
  400.           * **/  
  401.          public long sunionstore(String newkey,String...keys){  
  402.              Jedis jedis=jedisPool.getResource();  
  403.              long s =jedis.sunionstore(newkey, keys);  
  404.              jedisPool.returnResource(jedis);  
  405.              return s;  
  406.          }  
  407.      }  
  408.        
  409.      //TODO  
  410.      public class SortSet{  
  411.            
  412.          /** 
  413.           * 向集合中增加一条记录,如果这个值已存在,这个值对应的权重将被置为新的权重 
  414.           * @param String key 
  415.           * @param double score 权重 
  416.           * @param String member 要加入的值, 
  417.           * @return 状态码 1成功,0已存在member的值 
  418.           * */  
  419.          public long zadd(String key,double score,String member){  
  420.              Jedis jedis=jedisPool.getResource();  
  421.              long s =jedis.zadd(key, score, member);  
  422.              jedisPool.returnResource(jedis);  
  423.              return s;  
  424.          }  
  425.            
  426.          /** 
  427.           * 获取集合中元素的数量 
  428.           * @param String key 
  429.           * @return 如果返回0则集合不存在 
  430.           * */  
  431.          public long zcard(String key){  
  432.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  433.              long len= sjedis.zcard(key);  
  434.              shardedJedisPool.returnResource(sjedis);  
  435.              return len;  
  436.          }  
  437.            
  438.          /** 
  439.           * 获取指定权重区间内集合的数量 
  440.           * @param String key 
  441.           * @param double min 最小排序位置 
  442.           * @param double max 最大排序位置 
  443.           * */  
  444.          public long zcount(String key,double min,double max){  
  445.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  446.              long len= sjedis.zcount(key, min, max);  
  447.              shardedJedisPool.returnResource(sjedis);  
  448.              return len;  
  449.          }  
  450.            
  451.          /** 
  452.           * 获得set的长度 
  453.           * @param key 
  454.           * @return 
  455.           */  
  456.          public long zlength(String key){  
  457.              long len = 0;  
  458.              Set<String> set = zrange(key,0,-1);  
  459.              len = set.size();  
  460.              return len;  
  461.          }  
  462.            
  463.          /** 
  464.           * 权重增加给定值,如果给定的member已存在 
  465.           * @param String key 
  466.           * @param double score 要增的权重 
  467.           * @param String member 要插入的值 
  468.           * @return 增后的权重 
  469.           * */  
  470.          public double zincrby(String key,double score,String member){  
  471.              Jedis jedis=jedisPool.getResource();  
  472.              double s =jedis.zincrby(key, score, member);  
  473.              jedisPool.returnResource(jedis);  
  474.              return s;  
  475.          }  
  476.            
  477.          /** 
  478.           * 返回指定位置的集合元素,0为第一个元素,-1为最后一个元素 
  479.           * @param String key 
  480.           * @param int start 开始位置(包含) 
  481.           * @param int end  结束位置(包含) 
  482.           * @return Set<String> 
  483.           * */  
  484.          public Set<String> zrange(String key,int start,int end){  
  485.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  486.              Set<String> set= sjedis.zrange(key, start, end);  
  487.              shardedJedisPool.returnResource(sjedis);  
  488.              return set;  
  489.          }  
  490.            
  491.          /** 
  492.           * 返回指定权重区间的元素集合 
  493.           * @param String key 
  494.           * @param double min 上限权重 
  495.           * @param double max 下限权重 
  496.           * @return Set<String> 
  497.           * */  
  498.          public Set<String> zrangeByScore(String key,double min,double max){  
  499.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  500.              Set<String> set= sjedis.zrangeByScore(key, min, max);  
  501.              shardedJedisPool.returnResource(sjedis);  
  502.              return set;  
  503.          }  
  504.            
  505.          /** 
  506.           * 获取指定值在集合中的位置,集合排序从低到高 
  507.           * @see zrevrank 
  508.           * @param String key 
  509.           * @param String member 
  510.           * @return long 位置 
  511.           * */  
  512.          public long zrank(String key,String member){  
  513.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  514.              long index= sjedis.zrank(key,member);  
  515.              shardedJedisPool.returnResource(sjedis);  
  516.              return index;  
  517.          }  
  518.            
  519.          /** 
  520.           * 获取指定值在集合中的位置,集合排序从低到高 
  521.           * @see zrank 
  522.           * @param String key 
  523.           * @param String member 
  524.           * @return long 位置 
  525.           * */  
  526.          public long zrevrank(String key,String member){  
  527.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  528.              long index= sjedis.zrevrank(key, member);  
  529.              shardedJedisPool.returnResource(sjedis);  
  530.              return index;  
  531.          }  
  532.            
  533.          /** 
  534.           * 从集合中删除成员 
  535.           * @param String key 
  536.           * @param String member 
  537.           * @return 返回1成功 
  538.           * */  
  539.          public long zrem(String key,String member){  
  540.              Jedis jedis=jedisPool.getResource();  
  541.              long s =jedis.zrem(key, member);  
  542.              jedisPool.returnResource(jedis);  
  543.              return s;  
  544.          }  
  545.            
  546.          /** 
  547.           * 删除 
  548.           * @param key 
  549.           * @return 
  550.           */  
  551.          public long zrem(String key){  
  552.              Jedis jedis=jedisPool.getResource();  
  553.              long s =jedis.del(key);  
  554.              jedisPool.returnResource(jedis);  
  555.              return s;  
  556.          }  
  557.            
  558.            
  559.          /** 
  560.           * 删除给定位置区间的元素 
  561.           * @param String key 
  562.           * @param int start 开始区间,从0开始(包含) 
  563.           * @param int end 结束区间,-1为最后一个元素(包含) 
  564.           * @return 删除的数量 
  565.           * */  
  566.          public long zremrangeByRank(String key,int start,int end){  
  567.              Jedis jedis=jedisPool.getResource();  
  568.              long s =jedis.zremrangeByRank(key, start, end);  
  569.              jedisPool.returnResource(jedis);  
  570.              return s;  
  571.          }  
  572.            
  573.          /** 
  574.           * 删除给定权重区间的元素 
  575.           * @param String key 
  576.           * @param double min 下限权重(包含) 
  577.           * @param double max 上限权重(包含) 
  578.           * @return 删除的数量 
  579.           * */  
  580.          public long zremrangeByScore(String key,double min,double max){  
  581.              Jedis jedis=jedisPool.getResource();  
  582.              long s =jedis.zremrangeByScore(key, min, max);  
  583.              jedisPool.returnResource(jedis);  
  584.              return s;  
  585.          }  
  586.            
  587.          /** 
  588.           * 获取给定区间的元素,原始按照权重由高到低排序 
  589.           * @param String key 
  590.           * @param int start 
  591.           * @param int end 
  592.           * @return Set<String> 
  593.           * */  
  594.          public Set<String> zrevrange(String key,int start,int end){  
  595.              ShardedJedis sjedis=shardedJedisPool.getResource();  
  596.              Set<String> set= sjedis.zrevrange(key,start,end);  
  597.              shardedJedisPool.returnResource(sjedis);  
  598.              return set;  
  599.          }  
  600.           
    >>>
  评论这张
 
阅读(714)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017