首页 > 代码库 > 征服 Redis + Jedis + Spring (三)—— 列表操作【转】

征服 Redis + Jedis + Spring (三)—— 列表操作【转】

一开始以为Spring下操作哈希表,列表,真就是那么土。恍惚间发现“stringRedisTemplate.opsForList()”的强大,抓紧时间恶补下。酷

  

相关链接:

征服 Redis

征服 Redis + Jedis

征服 Redis + Jedis + Spring (一)—— 配置&常规操作(GET SET DEL)

征服 Redis + Jedis + Spring (二)—— 哈希表操作(HMGET HMSET)

征服 Redis + Jedis + Spring (三)—— 列表操作

 

通过spring-data-redis完成LINDEX, LLEN, LPOP, LPUSH, LRANGE, LREM, LSET, LTRIM, RPOP, RPUSH命令。其实还有一些命令,当前版本不支持。皱眉不过,这些List的操作方法可以实现队列,堆栈的正常操作,足够用了。

为了简便操作,我使用了StringRedisTemplate。用字符串操作做展示。当然,你可以继续使用RedisTemplate。

闲言少叙,上代码,一目了然:

 

Java代码  收藏代码
  1. /** 
  2.  * Mar 5, 2013 
  3.  */  
  4. package org.zlex.redis.support;  
  5.   
  6. import java.util.List;  
  7.   
  8. import org.springframework.beans.factory.annotation.Autowired;  
  9. import org.springframework.data.redis.core.StringRedisTemplate;  
  10. import org.springframework.stereotype.Component;  
  11.   
  12. /** 
  13.  *  
  14.  * @author snowolf 
  15.  * @version 1.0 
  16.  * @since 1.0 
  17.  */  
  18. @Component("listOps")  
  19. public class ListOps {  
  20.   
  21.     @Autowired  
  22.     private StringRedisTemplate stringRedisTemplate;  
  23.   
  24.     /** 
  25.      * 压栈 
  26.      *  
  27.      * @param key 
  28.      * @param value 
  29.      * @return 
  30.      */  
  31.     public Long push(String key, String value) {  
  32.         return stringRedisTemplate.opsForList().leftPush(key, value);  
  33.     }  
  34.   
  35.     /** 
  36.      * 出栈 
  37.      *  
  38.      * @param key 
  39.      * @return 
  40.      */  
  41.     public String pop(String key) {  
  42.         return stringRedisTemplate.opsForList().leftPop(key);  
  43.     }  
  44.   
  45.     /** 
  46.      * 入队 
  47.      *  
  48.      * @param key 
  49.      * @param value 
  50.      * @return 
  51.      */  
  52.     public Long in(String key, String value) {  
  53.         return stringRedisTemplate.opsForList().rightPush(key, value);  
  54.     }  
  55.   
  56.     /** 
  57.      * 出队 
  58.      *  
  59.      * @param key 
  60.      * @return 
  61.      */  
  62.     public String out(String key) {  
  63.         return stringRedisTemplate.opsForList().leftPop(key);  
  64.     }  
  65.   
  66.     /** 
  67.      * 栈/队列长 
  68.      *  
  69.      * @param key 
  70.      * @return 
  71.      */  
  72.     public Long length(String key) {  
  73.         return stringRedisTemplate.opsForList().size(key);  
  74.     }  
  75.   
  76.     /** 
  77.      * 范围检索 
  78.      *  
  79.      * @param key 
  80.      * @param start 
  81.      * @param end 
  82.      * @return 
  83.      */  
  84.     public List<String> range(String key, int start, int end) {  
  85.         return stringRedisTemplate.opsForList().range(key, start, end);  
  86.     }  
  87.   
  88.     /** 
  89.      * 移除 
  90.      *  
  91.      * @param key 
  92.      * @param i 
  93.      * @param value 
  94.      */  
  95.     public void remove(String key, long i, String value) {  
  96.         stringRedisTemplate.opsForList().remove(key, i, value);  
  97.     }  
  98.   
  99.     /** 
  100.      * 检索 
  101.      *  
  102.      * @param key 
  103.      * @param index 
  104.      * @return 
  105.      */  
  106.     public String index(String key, long index) {  
  107.         return stringRedisTemplate.opsForList().index(key, index);  
  108.     }  
  109.   
  110.     /** 
  111.      * 置值 
  112.      *  
  113.      * @param key 
  114.      * @param index 
  115.      * @param value 
  116.      */  
  117.     public void set(String key, long index, String value) {  
  118.         stringRedisTemplate.opsForList().set(key, index, value);  
  119.     }  
  120.   
  121.     /** 
  122.      * 裁剪 
  123.      *  
  124.      * @param key 
  125.      * @param start 
  126.      * @param end 
  127.      */  
  128.     public void trim(String key, long start, int end) {  
  129.         stringRedisTemplate.opsForList().trim(key, start, end);  
  130.     }  
  131. }  

 

 

这里说明下,例如LPUSH,RPUSH,其实就是从左边压栈,还是从右边压栈的不同命令。可以把堆栈看作是一个从左至右的数组。如果左边压栈,右边出栈,那就是队列的入队/出队操作;如果左边压栈,左边出栈,那就是堆栈操作。

 

举个具体的例子:

队列操作:LPUSH入队,RPOP出队,同理,可把L|R替换。

堆栈操作:LPUSH压栈,LPOP出栈,同理,可把L|R替换。

 

下面进行测试用例,初始、结束时,分别做入队、出队操作,期间进行堆栈,队列操作。不用我细说了,看测试用例,很简单!

 

Java代码  收藏代码
  1. /** 
  2.  * Mar 5, 2013 
  3.  */  
  4. package org.zlex.redis;  
  5.   
  6. import static org.junit.Assert.*;  
  7.   
  8. import java.util.List;  
  9.   
  10. import org.junit.Before;  
  11. import org.junit.After;  
  12. import org.junit.Test;  
  13. import org.springframework.context.ApplicationContext;  
  14. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  15. import org.zlex.redis.support.ListOps;  
  16.   
  17. /** 
  18.  *  
  19.  * @author snowolf 
  20.  * @version 1.0 
  21.  * @since 1.0 
  22.  */  
  23. public class ListOpsTest {  
  24.     private ApplicationContext app;  
  25.     private ListOps listOps;  
  26.     private String key = "queue";  
  27.   
  28.     @Before  
  29.     public void before() throws Exception {  
  30.         app = new ClassPathXmlApplicationContext("applicationContext.xml");  
  31.         listOps = (ListOps) app.getBean("listOps");  
  32.   
  33.         System.out.println("------------IN---------------");  
  34.         for (int i = 0; i < 5; i++) {  
  35.             String uid = "u" + i;  
  36.             System.out.println(uid);  
  37.             listOps.in(key, uid);  
  38.         }  
  39.     }  
  40.   
  41.     @After  
  42.     public void after() {  
  43.         // ------------OUT---------------  
  44.         System.out.println("------------OUT---------------");  
  45.         long length = listOps.length(key);  
  46.         for (long i = 0; i < length; i++) {  
  47.             String uid = listOps.out(key);  
  48.             System.out.println(uid);  
  49.         }  
  50.     }  
  51.   
  52.     @Test  
  53.     public void stack() {  
  54.         // ------------PUSH---------------  
  55.         String key = "stack";  
  56.         int len = 5;  
  57.         System.out.println("------------PUSH---------------");  
  58.         for (int i = 0; i < len; i++) {  
  59.             String uid = "u" + System.currentTimeMillis();  
  60.             System.out.println(uid);  
  61.             listOps.push(key, uid);  
  62.         }  
  63.   
  64.         long length = listOps.length(key);  
  65.         assertEquals(len, length);  
  66.   
  67.         // ------------POP---------------  
  68.         System.out.println("------------POP---------------");  
  69.         for (long i = 0; i < length; i++) {  
  70.             String uid = listOps.pop(key);  
  71.             System.out.println(uid);  
  72.         }  
  73.     }  
  74.   
  75.     @Test  
  76.     public void index() {  
  77.   
  78.         // -------------INDEX-------------  
  79.         String value = listOps.index(key, 3);  
  80.         assertEquals("u3", value);  
  81.     }  
  82.   
  83.     @Test  
  84.     public void range() {  
  85.         // -------------RANGE-------------  
  86.         List<String> list = listOps.range(key, 3, 5);  
  87.         boolean result1 = list.contains("u3");  
  88.         assertEquals(true, result1);  
  89.   
  90.         boolean result2 = list.contains("u1");  
  91.         assertEquals(false, result2);  
  92.     }  
  93.   
  94.     @Test  
  95.     public void trim() {  
  96.         // ------------TRIM---------------  
  97.         List<String> list = listOps.range(key, 3, 5);  
  98.         listOps.trim(key, 3, 5);  
  99.         boolean result3 = list.contains("u1");  
  100.         assertEquals(false, result3);  
  101.     }  
  102.   
  103.     @Test  
  104.     public void set() {  
  105.         // ------------SET-----------------  
  106.         List<String> list = listOps.range(key, 3, 5);  
  107.         listOps.set(key, 4, "ux4");  
  108.         boolean result4 = list.contains("u4");  
  109.         assertEquals(true, result4);  
  110.   
  111.     }  
  112.   
  113.     @Test  
  114.     public void remove() {  
  115.         // ------------REMOVE-----------------  
  116.         listOps.remove(key, 4, "u4");  
  117.         String value = listOps.index(key, 4);  
  118.         assertEquals(null, value);  
  119.   
  120.     }  
  121. }  

 

回头继续整理,这个套路没错!酷

 

详见附件!

 

相关链接:

征服 Redis

征服 Redis + Jedis

征服 Redis + Jedis + Spring (一)—— 配置&常规操作(GET SET DEL)

征服 Redis + Jedis + Spring (二)—— 哈希表操作(HMGET HMSET)

征服 Redis + Jedis + Spring (三)—— 列表操作

 

  • spring-data-redis.zip (30.8 KB)
  • 下载次数: 396

征服 Redis + Jedis + Spring (三)—— 列表操作【转】