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

最新推荐文章于 2025-11-30 19:25:58 发布

最新推荐文章于 2025-11-30 19:25:58 发布 · 206 阅读

文章标签：

本文介绍如何使用Spring Data Redis中的StringRedisTemplate实现List的基本操作，包括压栈、出栈、入队、出队等，并提供了具体的Java代码示例。

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

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

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

   Java代码
    
  
 /** 
 *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替换。

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

   Java代码
    
  
 /** 
 *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); 
  
 } 
 } 