征服 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);

}
}

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