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

转载自：http://snowolf.iteye.com/blog/1824868/

一开始以为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代码  


/** 

 * Mar 5, 2013 

 */  

package org.zlex.redis.support;  

  

import java.util.List;  

  

import org.springframework.beans.factory.annotation.Autowired;  

import org.springframework.data.redis.core.StringRedisTemplate;  

import org.springframework.stereotype.Component;  

  

/** 

 *  

 * @author snowolf 

 * @version 1.0 

 * @since 1.0 

 */  

@Component("listOps")  

public class ListOps {  

  

    @Autowired  

    private StringRedisTemplate stringRedisTemplate;  

  

    /** 

     * 压栈 

     *  

     * @param key 

     * @param value 

     * @return 

     */  

    public Long push(String key, String value) {  

        return stringRedisTemplate.opsForList().leftPush(key, value);  

    }  

  

    /** 

     * 出栈 

     *  

     * @param key 

     * @return 

     */  

    public String pop(String key) {  

        return stringRedisTemplate.opsForList().leftPop(key);  

    }  

  

    /** 

     * 入队 

     *  

     * @param key 

     * @param value 

     * @return 

     */  

    public Long in(String key, String value) {  

        return stringRedisTemplate.opsForList().rightPush(key, value);  

    }  

  

    /** 

     * 出队 

     *  

     * @param key 

     * @return 

     */  

    public String out(String key) {  

        return stringRedisTemplate.opsForList().leftPop(key);  

    }  

  

    /** 

     * 栈/队列长 

     *  

     * @param key 

     * @return 

     */  

    public Long length(String key) {  

        return stringRedisTemplate.opsForList().size(key);  

    }  

  

    /** 

     * 范围检索 

     *  

     * @param key 

     * @param start 

     * @param end 

     * @return 

     */  

    public List<String> range(String key, int start, int end) {  

        return stringRedisTemplate.opsForList().range(key, start, end);  

    }  

  

    /** 

     * 移除 

     *  

     * @param key 

     * @param i 

     * @param value 

     */  

    public void remove(String key, long i, String value) {  

        stringRedisTemplate.opsForList().remove(key, i, value);  

    }  

  

    /** 

     * 检索 

     *  

     * @param key 

     * @param index 

     * @return 

     */  

    public String index(String key, long index) {  

        return stringRedisTemplate.opsForList().index(key, index);  

    }  

  

    /** 

     * 置值 

     *  

     * @param key 

     * @param index 

     * @param value 

     */  

    public void set(String key, long index, String value) {  

        stringRedisTemplate.opsForList().set(key, index, value);  

    }  

  

    /** 

     * 裁剪 

     *  

     * @param key 

     * @param start 

     * @param end 

     */  

    public void trim(String key, long start, int end) {  

        stringRedisTemplate.opsForList().trim(key, start, end);  

    }  

}  

 

 

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

 

举个具体的例子：

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

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

 

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

 

Java代码  


/** 

 * Mar 5, 2013 

 */  

package org.zlex.redis;  

  

import static org.junit.Assert.*;  

  

import java.util.List;  

  

import org.junit.Before;  

import org.junit.After;  

import org.junit.Test;  

import org.springframework.context.ApplicationContext;  

import org.springframework.context.support.ClassPathXmlApplicationContext;  

import org.zlex.redis.support.ListOps;  

  

/** 

 *  

 * @author snowolf 

 * @version 1.0 

 * @since 1.0 

 */  

public class ListOpsTest {  

    private ApplicationContext app;  

    private ListOps listOps;  

    private String key = "queue";  

  

    @Before  

    public void before() throws Exception {  

        app = new ClassPathXmlApplicationContext("applicationContext.xml");  

        listOps = (ListOps) app.getBean("listOps");  

  

        System.out.println("------------IN---------------");  

        for (int i = 0; i < 5; i++) {  

            String uid = "u" + i;  

            System.out.println(uid);  

            listOps.in(key, uid);  

        }  

    }  

  

    @After  

    public void after() {  

        // ------------OUT---------------  

        System.out.println("------------OUT---------------");  

        long length = listOps.length(key);  

        for (long i = 0; i < length; i++) {  

            String uid = listOps.out(key);  

            System.out.println(uid);  

        }  

    }  

  

    @Test  

    public void stack() {  

        // ------------PUSH---------------  

        String key = "stack";  

        int len = 5;  

        System.out.println("------------PUSH---------------");  

        for (int i = 0; i < len; i++) {  

            String uid = "u" + System.currentTimeMillis();  

            System.out.println(uid);  

            listOps.push(key, uid);  

        }  

  

        long length = listOps.length(key);  

        assertEquals(len, length);  

  

        // ------------POP---------------  

        System.out.println("------------POP---------------");  

        for (long i = 0; i < length; i++) {  

            String uid = listOps.pop(key);  

            System.out.println(uid);  

        }  

    }  

  

    @Test  

    public void index() {  

  

        // -------------INDEX-------------  

        String value = listOps.index(key, 3);  

        assertEquals("u3", value);  

    }  

  

    @Test  

    public void range() {  

        // -------------RANGE-------------  

        List<String> list = listOps.range(key, 3, 5);  

        boolean result1 = list.contains("u3");  

        assertEquals(true, result1);  

  

        boolean result2 = list.contains("u1");  

        assertEquals(false, result2);  

    }  

  

    @Test  

    public void trim() {  

        // ------------TRIM---------------  

        List<String> list = listOps.range(key, 3, 5);  

        listOps.trim(key, 3, 5);  

        boolean result3 = list.contains("u1");  

        assertEquals(false, result3);  

    }  

  

    @Test  

    public void set() {  

        // ------------SET-----------------  

        List<String> list = listOps.range(key, 3, 5);  

        listOps.set(key, 4, "ux4");  

        boolean result4 = list.contains("u4");  

        assertEquals(true, result4);  

  

    }  

  

    @Test  

    public void remove() {  

        // ------------REMOVE-----------------  

        listOps.remove(key, 4, "u4");  

        String value = listOps.index(key, 4);  

        assertEquals(null, value);  

  

    }  

}  

 

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


 

详见附件！

 

相关链接：

征服 Redis

征服 Redis + Jedis

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

征服 Redis + Jedis + Spring （二）—— 哈希表操作（HMGET HMSET）

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