征服 Redis + Jedis + Spring （三）—— 列表操作

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

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

闲言少叙，上代码，一目了然：

 /**
 *Mar5,2013
 */
 packageorg.zlex.redis.support;

 importjava.util.List;

 importorg.springframework.beans.factory.annotation.Autowired;
 importorg.springframework.data.redis.core.StringRedisTemplate;
 importorg.springframework.stereotype.Component;

 /**
 *
 *@authorsnowolf
 *@version1.0
 *@since1.0
 */
 @Component("listOps")
 publicclassListOps{

 @Autowired
 privateStringRedisTemplatestringRedisTemplate;

 /**
 *压栈
 *
 *@paramkey
 *@paramvalue
 *@return
 */
 publicLongpush(Stringkey,Stringvalue){
 returnstringRedisTemplate.opsForList().leftPush(key,value);
 }

 /**
 *出栈
 *
 *@paramkey
 *@return
 */
 publicStringpop(Stringkey){
 returnstringRedisTemplate.opsForList().leftPop(key);
 }

 /**
 *入队
 *
 *@paramkey
 *@paramvalue
 *@return
 */
 publicLongin(Stringkey,Stringvalue){
 returnstringRedisTemplate.opsForList().rightPush(key,value);
 }

 /**
 *出队
 *
 *@paramkey
 *@return
 */
 publicStringout(Stringkey){
 returnstringRedisTemplate.opsForList().leftPop(key);
 }

 /**
 *栈/队列长
 *
 *@paramkey
 *@return
 */
 publicLonglength(Stringkey){
 returnstringRedisTemplate.opsForList().size(key);
 }

 /**
 *范围检索
 *
 *@paramkey
 *@paramstart
 *@paramend
 *@return
 */
 publicList<String>range(Stringkey,intstart,intend){
 returnstringRedisTemplate.opsForList().range(key,start,end);
 }

 /**
 *移除
 *
 *@paramkey
 *@parami
 *@paramvalue
 */
 publicvoidremove(Stringkey,longi,Stringvalue){
 stringRedisTemplate.opsForList().remove(key,i,value);
 }

 /**
 *检索
 *
 *@paramkey
 *@paramindex
 *@return
 */
 publicStringindex(Stringkey,longindex){
 returnstringRedisTemplate.opsForList().index(key,index);
 }

 /**
 *置值
 *
 *@paramkey
 *@paramindex
 *@paramvalue
 */
 publicvoidset(Stringkey,longindex,Stringvalue){
 stringRedisTemplate.opsForList().set(key,index,value);
 }

 /**
 *裁剪
 *
 *@paramkey
 *@paramstart
 *@paramend
 */
 publicvoidtrim(Stringkey,longstart,intend){
 stringRedisTemplate.opsForList().trim(key,start,end);
 }
 }

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

举个具体的例子：

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

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

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

 /**
 *Mar5,2013
 */
 packageorg.zlex.redis;

 importstaticorg.junit.Assert.*;

 importjava.util.List;

 importorg.junit.Before;
 importorg.junit.After;
 importorg.junit.Test;
 importorg.springframework.context.ApplicationContext;
 importorg.springframework.context.support.ClassPathXmlApplicationContext;
 importorg.zlex.redis.support.ListOps;

 /**
 *
 *@authorsnowolf
 *@version1.0
 *@since1.0
 */
 publicclassListOpsTest{
 privateApplicationContextapp;
 privateListOpslistOps;
 privateStringkey="queue";

 @Before
 publicvoidbefore()throwsException{
 app=newClassPathXmlApplicationContext("applicationContext.xml");
 listOps=(ListOps)app.getBean("listOps");

 System.out.println("------------IN---------------");
 for(inti=0;i<5;i++){
 Stringuid="u"+i;
 System.out.println(uid);
 listOps.in(key,uid);
 }
 }

 @After
 publicvoidafter(){
 //------------OUT---------------
 System.out.println("------------OUT---------------");
 longlength=listOps.length(key);
 for(longi=0;i<length;i++){
 Stringuid=listOps.out(key);
 System.out.println(uid);
 }
 }

 @Test
 publicvoidstack(){
 //------------PUSH---------------
 Stringkey="stack";
 intlen=5;
 System.out.println("------------PUSH---------------");
 for(inti=0;i<len;i++){
 Stringuid="u"+System.currentTimeMillis();
 System.out.println(uid);
 listOps.push(key,uid);
 }

 longlength=listOps.length(key);
 assertEquals(len,length);

 //------------POP---------------
 System.out.println("------------POP---------------");
 for(longi=0;i<length;i++){
 Stringuid=listOps.pop(key);
 System.out.println(uid);
 }
 }

 @Test
 publicvoidindex(){

 //-------------INDEX-------------
 Stringvalue=listOps.index(key,3);
 assertEquals("u3",value);
 }

 @Test
 publicvoidrange(){
 //-------------RANGE-------------
 List<String>list=listOps.range(key,3,5);
 booleanresult1=list.contains("u3");
 assertEquals(true,result1);

 booleanresult2=list.contains("u1");
 assertEquals(false,result2);
 }

 @Test
 publicvoidtrim(){
 //------------TRIM---------------
 List<String>list=listOps.range(key,3,5);
 listOps.trim(key,3,5);
 booleanresult3=list.contains("u1");
 assertEquals(false,result3);
 }

 @Test
 publicvoidset(){
 //------------SET-----------------
 List<String>list=listOps.range(key,3,5);
 listOps.set(key,4,"ux4");
 booleanresult4=list.contains("u4");
 assertEquals(true,result4);

 }

 @Test
 publicvoidremove(){
 //------------REMOVE-----------------
 listOps.remove(key,4,"u4");
 Stringvalue=listOps.index(key,4);
 assertEquals(null,value);

 }
 }

回头继续整理，这个套路没错！