概述          Jedis是redis官方推荐的用于访问Java客户端，在https://github.com/xetorthio/jedis下载最新的jedis。 访问redis 1、访问简单的key——value， pu

只需简单几步，就可以利用Spring-Data-Redis和Jedis操作Redis缓存。步骤如下：

第一步：依赖包

org.springframework.data

spring-data-redis

1.4.2.RELEASE

redis.clients

jedis

2.6.0

第二步：封装自己的Redis操作类

1、spring配置,下面是一个完整redis配置，密码只需要设置password属性。

/**

* 封装对Redis的常用操作，尽量与Redis原始命令一致。Redis命令参考：http://redisdoc.com/

* @author Xu

*

*/

public class XjjStringRedisOps extends StringRedisTemplate {

//Key(键)，简单的key-value操作

/**

* 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。

* @param key

* @return

*/

public long TTL(String key) {

return getExpire(key);

}

/**

* 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key

*/

public Set KEYS(String pattern){

return super.keys(pattern);

}

/**

* 实现命令：DEL key，删除一个key

* @param key

*/

public void DEL(String key){

delete(key);

}

//String(字符串)

/**

* 实现命令：SET key value，设置一个key-value(将字符串值 value关联到 key)

* @param key

* @param value

*/

public void SET(String key, String value) {

opsForValue().set(key, value);

}

/**

* 实现命令：SET key value EX seconds，设置key-value和超时时间(秒)

* @param key

* @param value

* @param timeout (以秒为单位)

*/

public void SET(String key, String value, long timeout) {

opsForValue().set(key, value, timeout, TimeUnit.SECONDS);

}

/**

* 实现命令：GET key，返回 key所关联的字符串值。

* @param key

* @return value

*/

public String GET(String key) {

return opsForValue().get(key);

}

//Hash(哈希表)

/**

* 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value

* @param key

* @param field

* @param value

*/

public void HSET(String key, String field, Object value) {

opsForHash().put(key, field, value);

}

/**

* 实现命令：HGET key field，返回哈希表 key中给定域 field的值

* @param key

* @param field

* @return

*/

public String HGET(String key, String field) {

return (String) opsForHash().get(key, field);

}

/**

* 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。

* @param key

* @param fields

*/

public void HDEL(String key, Object... fields) {

opsForHash().delete(key, fields);

}

/**

* 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。

* @param key

* @return

*/

public Map HGETALL(String key) {

return opsForHash().entries(key);

}

//List(列表)

/**

* 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头

* @param key

* @param value

* @return 执行 LPUSH命令后，列表的长度。

*/

public long LPUSH(String key, String value) {

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

}

/**

* 实现命令：LPOP key，移除并返回列表 key的头元素。

* @param key

* @return 列表key的头元素。

*/

public String LPOP(String key) {

return opsForList().leftPop(key);

}

/**

* 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。

* @param key

* @param value

* @return 执行 LPUSH命令后，列表的长度。

*/

public long RPUSH(String key, String value) {

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

}

/**

* 实现命令：RPOP key，移除并返回列表 key的尾元素。

* @param key

* @return 列表key的头元素。

*/

public String RPOP(String key) {

return opsForList().rightPop(key);

}

//Set(集合)

/**

* 实现命令：SADD key member，将一个 member元素加入到集合 key当中，已经存在于集合的 member元素将被忽略。

* @param key

* @param member

*/

public void SADD(String key, String member) {

opsForSet().add(key, member);

}

/**

* 实现命令：SMEMBERS key，返回集合 key 中的所有成员。

* @param key

* @return

*/

public Set SMEMEBERS(String key) {

return opsForSet().members(key);

}

//SortedSet(有序集合)

/**

* 实现命令：ZADD key score member，将一个 member元素及其 score值加入到有序集 key当中。

* @param key

* @param score

* @param member

*/

public void ZADD(String key, double score, String member) {

opsForZSet().add(key, member, score);

}

/**

* 实现命令：ZRANGE key start stop，返回有序集 key中，指定区间内的成员。

* @param key

* @param start

* @param stop

* @return

*/

public Set ZRANGE(String key, double start, double stop) {

return opsForZSet().rangeByScore(key, start, stop);

}

}

第三步：Spring配置

第四步：测试

@RunWith(SpringJUnit4ClassRunner.class) //使用Spring Junit4进行测试

@ContextConfiguration ({"classpath:spring/applicationContext.xml"}) //加载配置文件

public abstract class BaseJunit4Test {

}

public class RedisTest extends BaseJunit4Test {

@Autowired

XjjStringRedisOps redisOps;

@Test

public void deleteTestKeys(){

redisOps.DEL("xjj.v1");

redisOps.DEL("xjj.v2");

redisOps.DEL("xjj.h1");

redisOps.DEL("xjj.11");

redisOps.DEL("xjj.z1");

HashSet keySet = (HashSet) redisOps.keys("xjj*");

System.out.println(keySet);

Assert.assertEquals("keys删除不成功！", new HashSet(), keySet);

}

//String类型测试

@Test

public void setStringValue(){

String key = "xjj.v1";

String value = "Hello World!";

redisOps.SET(key, value);

System.out.println("value of xjj: " + redisOps.GET(key));

Assert.assertEquals(value, redisOps.GET(key));

}

@Test

public void setStringValueWithTimeout(){

String key = "xjj.v2";

String value = "Hello World, xjj1!";

long timeout = 100;

redisOps.SET(key, value, timeout);

System.out.println("ttl of xjj1: " + redisOps.TTL(key));

Assert.assertEquals(timeout, redisOps.TTL(key));

}

//Hash类型测试

@Test

public void setHashValue(){

String key = "xjj.h1";

String field1 = "f1";

String value1 = "123";

redisOps.HSET(key, field1, value1);

System.out.println(redisOps.HGET(key, field1));

String field2 = "f2";

String value2 = String.valueOf(888);

redisOps.HSET(key, field2, value2);

System.out.println(redisOps.HGET(key, field2));

System.out.println(redisOps.HGETALL(key));

}

@Test

public void delHashKeys(){

redisOps.HDEL("xjj.h1", "f1", "f2"); //删除xjj.h1中的f1和f2

}

//List类型测试

@Test

public void ListOps(){

String key = "xjj.l1";

String value1 = "Java";

redisOps.LPUSH(key, value1);

String value2 = "php";

redisOps.RPUSH(key, value2);

System.out.println(redisOps.RPOP(key));

System.out.println(redisOps.LPOP(key));

}

//Set类型测试

@Test

public void SetOps(){

String key = "xjj.s1";

String member1 = "Java";

String member2 = "Python";

String member3 = "PHP";

redisOps.SADD(key, member1);

redisOps.SADD(key, member2);

redisOps.SADD(key, member3);

System.out.println(redisOps.SMEMEBERS(key));

}

//SortedSet类型测试

@Test

public void ZSetOps(){

String key = "xjj.z1";

String member1 = "Java";

String member2 = "Python";

String member3 = "PHP";

double score1 = 1.2;

double score2 = 100.5;

double score3 = 188;

redisOps.ZADD(key, score1, member1);

redisOps.ZADD(key, score2, member2);

redisOps.ZADD(key, score3, member3);

System.out.println(redisOps.ZRANGE(key, 1, 150));

}

}

参考一下这篇文章: http://snowolf.iteye.com/blog/1666908 也可以借鉴一下这个的思路，仅供参考: package com.ttpod.cache.impl; import com.ttpod.cache.Cache