Spring Redis Jedis简单用法

maven依赖

1. <properties>  
2.     <spring.version>4.3.10.RELEASE</spring.version>
   
3.     <!-- redis 版本 -->  
4.     <redis.version>2.9.0</redis.version>  
5.     <spring.redis.version>1.8.4.RELEASE</spring.redis.version>  
6. </properties>  
7. <dependency>  
8.     <groupId>redis.clients</groupId>  
9.     <artifactId>jedis</artifactId>  
10.     <version>${redis.version}</version>  
11. </dependency>  
12. <dependency>  
13.     <groupId>org.springframework.data</groupId>  
14.     <artifactId>spring-data-redis</artifactId>  
15.     <version>${spring.redis.version}</version>  
16. </dependency>  
17. <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.2</version>
    </dependency>
    

redis.properties

1. redis.host=127.0.0.1  
2. redis.port=6379  
3. redis.password=""  
4. redis.maxIdle=400  
5. redis.maxTotal=6000  
6. redis.maxWaitMillis=1000  
7. redis.blockWhenExhausted=true  
8. redis.testOnBorrow=true  
9. redis.timeout=100000  
10. defaultCacheExpireTime=60  

spring-redis.xml

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd     
6.     http://www.springframework.org/schema/context     
7.     http://www.springframework.org/schema/context/spring-context-4.3.xsd"  
8.     default-lazy-init="false">  
9.       
10.     <!-- 加载配置文件 -->    
11.     <context:property-placeholder location="classpath:redis.properties" />    
12.     <!-- redis数据源 -->  
13.     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
14.         <!-- 最大空闲数 -->  
15.         <property name="maxIdle" value="${redis.maxIdle}" />  
16.         <!-- 最大空连接数 -->  
17.         <property name="maxTotal" value="${redis.maxTotal}" />  
18.         <!-- 最大等待时间 -->  
19.         <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />  
20.         <!-- 连接超时时是否阻塞，false时报异常,ture阻塞直到超时, 默认true -->  
21.          <property name="blockWhenExhausted" value="${redis.blockWhenExhausted}" />   
22.         <!-- 返回连接时，检测连接是否成功 -->  
23.         <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
24.     </bean>  
25.   
26.     <!-- Spring-redis连接池管理工厂 -->  
27.     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">  
28.         <!-- IP地址 -->  
29.         <property name="hostName" value="${redis.host}" />  
30.         <!-- 端口号 -->  
31.         <property name="port" value="${redis.port}" />  
32.         <!-- 超时时间 默认2000-->  
33.         <property name="timeout" value="${redis.timeout}" />  
34.         <!-- 连接池配置引用 -->  
35.         <property name="poolConfig" ref="poolConfig" />  
36.         <!-- usePool：是否使用连接池 -->  
37.         <property name="usePool" value="true"/>  
38.     </bean>  
39.   
40.     <!-- redis template definition -->  
41.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">  
42.         <property name="connectionFactory" ref="jedisConnectionFactory" />  
43.         <property name="keySerializer">  
44.             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
45.         </property>  
46.         <property name="valueSerializer">  
47.             <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />  
48.         </property>  
49.         <property name="hashKeySerializer">  
50.             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
51.         </property>  
52.         <property name="hashValueSerializer">  
53.             <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />  
54.         </property>  
55.          <!--开启事务  -->    
56.         <property name="enableTransactionSupport" value="true"></property>    
57.     </bean>  
58.       
59.     <!--自定义redis工具类,在需要缓存的地方注入此类  -->    
60.    
    1. <bean id="redisrCacheManager" class="redis.RedisCacheManager">    
          
    <constructor-arg> <ref bean="redisTemplate" /> </constructor-arg>
      </bean>  

</beans>  

一、spring-data-redis功能介绍
jedis客户端在编程实施方面存在如下不足：
1)connection管理缺乏自动化，connection-pool的设计缺少必要的容器支持。
2)数据操作需要关注“序列化”/“反序列化”，因为jedis的客户端API接受的数据类型为string和byte，对结构化数据(json,xml,pojo等)操作需要额外的支持。
3)事务操作纯粹为硬编码。
4)pub/sub功能，缺乏必要的设计模式支持，对于开发者而言需要关注的太多。
spring-data-redis针对jedis提供了如下功能：
1.连接池自动管理，提供了一个高度封装的“RedisTemplate”类
2.针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
ValueOperations：简单K-V操作
SetOperations：set类型数据操作
ZSetOperations：zset类型数据操作
HashOperations：针对map类型的数据操作
ListOperations：针对list类型的数据操作
3.提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：
BoundValueOperations
BoundSetOperations
BoundListOperations
BoundSetOperations
BoundHashOperations
4.将事务操作封装，有容器控制。
5.针对数据的“序列化/反序列化”，提供了多种可选择策略(RedisSerializer)
JdkSerializationRedisSerializer：POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列。是目前最常用的序列化策略。
StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。
JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。【需要jackson-mapper-asl工具支持】
OxmSerializer：提供了将javabean与xml之间的转换能力，目前可用的三方支持包括jaxb，apache-xmlbeans；redis存储的数据将是xml工具。不过使用此策略，编程将会有些难度，而且效率最低；不建议使用。【需要spring-oxm模块的支持】
针对“序列化和发序列化”中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的策略，原则上，我们可以将数据存储为任何格式以便应用程序存取和解析(其中应用包括app，hadoop等其他工具)，不过在设计时仍然不推荐直接使用“JacksonJsonRedisSerializer”和“OxmSerializer”，因为无论是json还是xml，他们本身仍然是String。如果你的数据需要被第三方工具解析，那么数据应该使用StringRedisSerializer而不是JdkSerializationRedisSerializer。如果你的数据格式必须为json或者xml，那么在编程级别，在redisTemplate配置中仍然使用StringRedisSerializer，在存储之前或者读取之后，使用“SerializationUtils”工具转换转换成json或者xml，请参见下文实例。
6.基于设计模式，和JMS开发思路，将pub/sub的API设计进行了封装，使开发更加便捷。
7.spring-data-redis中，并没有对sharding提供良好的封装，如果你的架构是基于sharding，那么你需要自己去实现，这也是sdr和jedis相比，唯一缺少的特性。
二、serializer策略
spring-data-redis提供了多种serializer策略，这对使用jedis的开发者而言，实在是非常便捷。sdr提供了4种内置的serializer：
JdkSerializationRedisSerializer：使用JDK的序列化手段(serializable接口，ObjectInputStrean，ObjectOutputStream)，数据以字节流存储
StringRedisSerializer：字符串编码，数据以string存储
JacksonJsonRedisSerializer：json格式存储
OxmSerializer：xml格式存储
其中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的序列化策略，其中“JacksonJsonRedisSerializer”与“OxmSerializer”都是基于stirng存储，因此它们是较为“高级”的序列化(最终还是使用string解析以及构建java对象)。
RedisTemplate中需要声明4种serializer，默认为“JdkSerializationRedisSerializer”：
1) keySerializer ：对于普通K-V操作时，key采取的序列化策略
2) valueSerializer：value采取的序列化策略
3) hashKeySerializer： 在hash数据结构中，hash-key的序列化策略
4) hashValueSerializer：hash-value的序列化策略

无论如何，建议key/hashKey采用StringRedisSerializer。

RedisTemplate

• RedisTemplate
• StringRedisTemplate

RedisTemplate能够让我们持久化各种类型的key和value，并不仅限于字节数组

StringRedisTemplate扩展了RedisTemplate，只能使用String类型

StringRedisTemplate有一个接受RedisConnectionFactory的构造器，因此没有必要在构建后在调用setConnectionFactory()

使用RedisTemplateAPI

方法	子API接口	描述
opsForValue()	ValueOperations	描述具有简单值的条目
opsForList()	ListOperations	操作具有list值的条目
opsForSet()	SetOperations	操作具有set值的条目
opsForZSet()	ZSetOperations	操作具有ZSet值（排序的set）的条目
opsForHash()	HashOperations	操作具有hash值的条目
boundValueOps(K)	BoundValueOperations	以绑定指定key的方式，操作具有简单值的条目
boundListOps(K)	BoundListOperations	以绑定指定key的方式，操作具有list的条目
boundSetOps(K)	BoundSetOperations	以绑定指定key的方式，操作具有set的条目
boundZSet(K)	BoundZSetOperations	以绑定指定key的方式，操作具有ZSet（排序的set）的条目
boundHashOps(K)	BoundHashOperations	以绑定指定key的方式，操作具有hash值的条目

/案例使用：

package redis;

  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
import java.util.concurrent.TimeUnit;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;  
import org.springframework.util.CollectionUtils;

import sun.security.jca.GetInstance;  
  

public class RedisCacheManager {  
      
    private RedisTemplate<String, Object> redisTemplate;  
  
    
    private static RedisCacheManager intance;
    
    public RedisCacheManager(RedisTemplate<String, Object> redisTemplate) {
    	this.redisTemplate = redisTemplate;
    	intance=this;
    }
    
    
    private RedisCacheManager() {
    	
    }
    
    
    
    public static RedisCacheManager getIntance() {
    	if(intance==null) {
    		ApplicationContext context = new ClassPathXmlApplicationContext("redis_config.xml");
    		intance=new RedisCacheManager();
    		intance.setRedisTemplate(context.getBean("redisTemplate", RedisTemplate.class));
    	}
    	return intance;
    }
    
    


	public RedisTemplate<String, Object> getRedisTemplate() {
		return redisTemplate;
	}


	public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
        this.redisTemplate = redisTemplate;  
    }    
    /** 
     * 指定缓存失效时间 
     *  
     * @param key 
     *            键 
     * @param time 
     *            时间(秒) 
     * @return 
     */  
    public boolean expire(String key, long time) {  
        try {  
            if (time > 0) {  
                redisTemplate.expire(key, time, TimeUnit.SECONDS);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 根据key 获取过期时间 
     *  
     * @param key 
     *            键 不能为null 
     * @return 时间(秒) 返回0代表为永久有效 
     */  
    public long getExpire(String key) {  
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);  
    }  
  
    /** 
     * 判断key是否存在 
     *  
     * @param key 
     *            键 
     * @return true 存在 false不存在 
     */  
    public boolean hasKey(String key) {  
        try {  
            return redisTemplate.hasKey(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 删除缓存 
     *  
     * @param key 
     *            可以传一个值 或多个 
     */  
    @SuppressWarnings("unchecked")  
    public void del(String... key) {  
        if (key != null && key.length > 0) {  
            if (key.length == 1) {  
                redisTemplate.delete(key[0]);  
            } else {  
                redisTemplate.delete(CollectionUtils.arrayToList(key));  
            }  
        }  
    }  
  
    // ============================String=============================  
    /** 
     * 普通缓存获取 
     *  
     * @param key 
     *            键 
     * @return 值 
     */  
    public Object get(String key) {  
        return key == null ? null : redisTemplate.opsForValue().get(key);  
    }  
  
    /** 
     * 普通缓存放入 
     *  
     * @param key 
     *            键 
     * @param value 
     *            值 
     * @return true成功 false失败 
     */  
    public boolean set(String key, Object value) {  
        try {  
            redisTemplate.opsForValue().set(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
  
    }  
  
    /** 
     * 普通缓存放入并设置时间 
     *  
     * @param key 
     *            键 
     * @param value 
     *            值 
     * @param time 
     *            时间(秒) time要大于0 如果time小于等于0 将设置无限期 
     * @return true成功 false 失败 
     */  
    public boolean set(String key, Object value, long time) {  
        try {  
            if (time > 0) {  
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);  
            } else {  
                set(key, value);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 递增 
     *  
     * @param key 
     *            键 
     * @param by 
     *            要增加几(大于0) 
     * @return 
     */  
    public long incr(String key, long delta) {  
        if (delta < 0) {  
            throw new RuntimeException("递增因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, delta);  
    }  
  
    /** 
     * 递减 
     *  
     * @param key 
     *            键 
     * @param by 
     *            要减少几(小于0) 
     * @return 
     */  
    public long decr(String key, long delta) {  
        if (delta < 0) {  
            throw new RuntimeException("递减因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, -delta);  
    }  
  
    // ================================Map=================================  
    /** 
     * HashGet 
     *  
     * @param key 
     *            键 不能为null 
     * @param item 
     *            项 不能为null 
     * @return 值 
     */  
    public Object hget(String key, String item) {  
        return redisTemplate.opsForHash().get(key, item);  
    }  
  
    /** 
     * 获取hashKey对应的所有键值 
     *  
     * @param key 
     *            键 
     * @return 对应的多个键值 
     */  
    public Map<Object, Object> hmget(String key) {  
        return redisTemplate.opsForHash().entries(key);  
    }  
  
    /** 
     * HashSet 
     *  
     * @param key 
     *            键 
     * @param map 
     *            对应多个键值 
     * @return true 成功 false 失败 
     */  
    public boolean hmset(String key, Map<String, Object> map) {  
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * HashSet 并设置时间 
     *  
     * @param key 
     *            键 
     * @param map 
     *            对应多个键值 
     * @param time 
     *            时间(秒) 
     * @return true成功 false失败 
     */  
    public boolean hmset(String key, Map<String, Object> map, long time) {  
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            if (time > 0) {  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     *  
     * @param key 
     *            键 
     * @param item 
     *            项 
     * @param value 
     *            值 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key, String item, Object value) {  
        try {  
            redisTemplate.opsForHash().put(key, item, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     *  
     * @param key 
     *            键 
     * @param item 
     *            项 
     * @param value 
     *            值 
     * @param time 
     *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key, String item, Object value, long time) {  
        try {  
            redisTemplate.opsForHash().put(key, item, value);  
            if (time > 0) {  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 删除hash表中的值 
     *  
     * @param key 
     *            键 不能为null 
     * @param item 
     *            项 可以使多个 不能为null 
     */  
    public void hdel(String key, Object... item) {  
        redisTemplate.opsForHash().delete(key, item);  
    }  
  
    /** 
     * 判断hash表中是否有该项的值 
     *  
     * @param key 
     *            键 不能为null 
     * @param item 
     *            项 不能为null 
     * @return true 存在 false不存在 
     */  
    public boolean hHasKey(String key, String item) {  
        return redisTemplate.opsForHash().hasKey(key, item);  
    }  
  
    /** 
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回 
     *  
     * @param key 
     *            键 
     * @param item 
     *            项 
     * @param by 
     *            要增加几(大于0) 
     * @return 
     */  
    public double hincr(String key, String item, double by) {  
        return redisTemplate.opsForHash().increment(key, item, by);  
    }  
  
    /** 
     * hash递减 
     *  
     * @param key 
     *            键 
     * @param item 
     *            项 
     * @param by 
     *            要减少记(小于0) 
     * @return 
     */  
    public double hdecr(String key, String item, double by) {  
        return redisTemplate.opsForHash().increment(key, item, -by);  
    }  
  
    // ============================set=============================  
    /** 
     * 根据key获取Set中的所有值 
     *  
     * @param key 
     *            键 
     * @return 
     */  
    public Set<Object> sGet(String key) {  
        try {  
            return redisTemplate.opsForSet().members(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
  
    /** 
     * 根据value从一个set中查询,是否存在 
     *  
     * @param key 
     *            键 
     * @param value 
     *            值 
     * @return true 存在 false不存在 
     */  
    public boolean sHasKey(String key, Object value) {  
        try {  
            return redisTemplate.opsForSet().isMember(key, value);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 将数据放入set缓存 
     *  
     * @param key 
     *            键 
     * @param values 
     *            值 可以是多个 
     * @return 成功个数 
     */  
    public long sSet(String key, Object... values) {  
        try {  
            return redisTemplate.opsForSet().add(key, values);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
    /** 
     * 将set数据放入缓存 
     *  
     * @param key 
     *            键 
     * @param time 
     *            时间(秒) 
     * @param values 
     *            值 可以是多个 
     * @return 成功个数 
     */  
    public long sSetAndTime(String key, long time, Object... values) {  
        try {  
            Long count = redisTemplate.opsForSet().add(key, values);  
            if (time > 0)  
                expire(key, time);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
    /** 
     * 获取set缓存的长度 
     *  
     * @param key 
     *            键 
     * @return 
     */  
    public long sGetSetSize(String key) {  
        try {  
            return redisTemplate.opsForSet().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
    /** 
     * 移除值为value的 
     *  
     * @param key 
     *            键 
     * @param values 
     *            值 可以是多个 
     * @return 移除的个数 
     */  
    public long setRemove(String key, Object... values) {  
        try {  
            Long count = redisTemplate.opsForSet().remove(key, values);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
    // ===============================list=================================  
  
    /** 
     * 获取list缓存的内容 
     *  
     * @param key 
     *            键 
     * @param start 
     *            开始 
     * @param end 
     *            结束 0 到 -1代表所有值 
     * @return 
     */  
    public List<Object> lGet(String key, long start, long end) {  
        try {  
            return redisTemplate.opsForList().range(key, start, end);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
  
    /** 
     * 获取list缓存的长度 
     *  
     * @param key 
     *            键 
     * @return 
     */  
    public long lGetListSize(String key) {  
        try {  
            return redisTemplate.opsForList().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
  
    /** 
     * 通过索引 获取list中的值 
     *  
     * @param key 
     *            键 
     * @param index 
     *            索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 
     * @return 
     */  
    public Object lGetIndex(String key, long index) {  
        try {  
            return redisTemplate.opsForList().index(key, index);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
  
    /** 
     * 将list放入缓存 
     *  
     * @param key 
     *            键 
     * @param value 
     *            值 
     * @param time 
     *            时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 将list放入缓存 
     *  
     * @param key 
     *            键 
     * @param value 
     *            值 
     * @param time 
     *            时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value, long time) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            if (time > 0)  
                expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 将list放入缓存 
     *  
     * @param key 
     *            键 
     * @param value 
     *            值 
     * @param time 
     *            时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 将list放入缓存 
     *  
     * @param key 
     *            键 
     * @param value 
     *            值 
     * @param time 
     *            时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value, long time) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            if (time > 0)  
                expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 根据索引修改list中的某条数据 
     *  
     * @param key 
     *            键 
     * @param index 
     *            索引 
     * @param value 
     *            值 
     * @return 
     */  
    public boolean lUpdateIndex(String key, long index, Object value) {  
        try {  
            redisTemplate.opsForList().set(key, index, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
  
    /** 
     * 移除N个值为value 
     *  
     * @param key 
     *            键 
     * @param count 
     *            移除多少个 
     * @param value 
     *            值 
     * @return 移除的个数 
     */  
    public long lRemove(String key, long count, Object value) {  
        try {  
            Long remove = redisTemplate.opsForList().remove(key, count, value);  
            return remove;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
}  

jedis API 参考链接 http://tool.oschina.net/apidocs/apidoc?api=jedis-2.1.0