Redis的java客户端Jedis的使用

时间:2023-01-30 20:35:43

Redis的java客户端Jedis的使用

标签(空格分隔): 未分类


一、Jedis简介和使用

使用Jedis提供的JavaAPI对Redis进行操作,是Redis官方推崇的方式;并且,使用Jedis提供的对Redis的支持也最为灵活、全面;不足之处,就是编码复杂度较高。

  • 入门使用:

下载Jedis的依赖包jedis-2.1.0.jar,然后将其添加到classpath下面。然后,即可进行编程。
定义连接:Redis暂时不要设置登录密码
Jedis jedis = new Jedis("192.168.142.12");
进行键值存储:
jedis.set("country", "China");
获取value值:
String country = jedis.get("country");
删除key:
jedis.del("country");

  • 使用连接池:

添加依赖包commons-pool.jar,注意不要选择高版本,以免不必要的错误。
配置属性文件:redis.properties

redis.host=192.168.142.12       #Redis服务器地址 
redis.port=6379 #服务端口
redis.timeout=3000 #超时时间:单位ms
redis.password=nick123 #授权密码

redis.pool.maxActive=200 #最大连接数:能够同时建立的“最大链接个数”
redis.pool.maxIdle=20 #最大空闲数:空闲链接数大于maxIdle时,将进行回收
redis.pool.minIdle=5 #最小空闲数:低于minIdle时,将创建新的链接
redis.pool.maxWait=3000 #最大等待时间:单位ms

redis.pool.testOnBorrow=true #使用连接时,检测连接是否成功
redis.pool.testOnReturn=true #返回连接时,检测连接是否成功

加载属性文件:redis.properties
ResourceBundle bundle = ResourceBundle.getBundle("redis");
创建配置对象:

JedisPoolConfig config = new JedisPoolConfig();  
String host = bundle.getString("redis.host");
...
config.setMaxActive(Integer.valueOf(bundle.getString("redis.pool.maxActive")));
...
config.setTestOnBorrow(Boolean.valueOf(bundle.getString("redis.pool.testOnBorrow")));
...

创建Jedis连接池:

JedisPool pool = new JedisPool(config, host, port, timeout, password);  
  • 使用方式:

从连接池获取Jedis对象:
Jedis jedis = pool.getResource();
基本操作:

jedis.set("province", "shannxi");  
String province = jedis.get("province");
jedis.del("province");

将Jedis对象归还给连接池:
pool.returnResource(jedis);

二、Jedis使用详解

  • jedis简单测试
package com.kang.redis;

import redis.clients.jedis.Jedis;

public class JedisDemo {

public static void main(String[] args) {
// 构造jedis对象
Jedis jedis = new Jedis("127.0.0.1", 6379);
// 向redis中添加数据
jedis.set("mytest", "123");
// 从redis中读取数据
String value = jedis.get("mytest");

System.out.println(value);
// 关闭连接
jedis.close();

}

}
  • jedis连接池测试
package com.kang.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolDemo {

public static void main(String[] args) {
// 构建连接池配置信息
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
// 设置最大连接数
jedisPoolConfig.setMaxTotal(50);

// 构建连接池
JedisPool jedisPool = new JedisPool(jedisPoolConfig, "127.0.0.1", 6379);

// 从连接池中获取连接
Jedis jedis = jedisPool.getResource();

// 读取数据
System.out.println(jedis.get("mytest"));

// 将连接还回到连接池中
jedisPool.returnResource(jedis);

// 释放连接池
jedisPool.close();

}

}
  • jedis设置集群连接池
package com.kang.redis;

import java.util.ArrayList;
import java.util.List;

import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**
* 集群式的连接池
*
*/

public class ShardedJedisPoolDemo {

public static void main(String[] args) {
// 构建连接池配置信息
JedisPoolConfig poolConfig = new JedisPoolConfig();
// 设置最大连接数
poolConfig.setMaxTotal(50);

// 定义集群信息
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo("127.0.0.1", 6379));
//可以加入其他集群的jedis端口
// 定义集群连接池
ShardedJedisPool shardedJedisPool = new ShardedJedisPool(poolConfig, shards);
ShardedJedis shardedJedis = null;
try {
// 从连接池中获取到jedis分片对象
shardedJedis = shardedJedisPool.getResource();

// 从redis中获取数据
String value = shardedJedis.get("mytest");
System.out.println(value);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != shardedJedis) {
// 关闭,检测连接是否有效,有效则放回到连接池中,无效则重置状态
shardedJedis.close();
}
}

// 关闭连接池
shardedJedisPool.close();

}
}
  • 一个jedis的工具类
package com.kang.redis;  

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtil {
protected Logger log = LoggerFactory.getLogger(getClass());

/**
* 私有构造器.
*/

private RedisUtil() {

}
private static Map<String,JedisPool> maps = new HashMap<String,JedisPool>();


/**
* 获取连接池.
* @return 连接池实例
*/

static JedisPool getPool(String ip,int port) {
String key = ip+":" +port;
JedisPool pool = null;
if(!maps.containsKey(key)) {
JedisPoolConfig config = new JedisPoolConfig();
config.setTestOnBorrow(true);
config.setTestOnReturn(true);
try{
/**
*如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
*请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
*/

pool = new JedisPool(config, ip, port);
maps.put(key, pool);
} catch(Exception e) {
e.printStackTrace();
}
}else{
pool = maps.get(key);
}
return pool;
}

/**
*类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例
*没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。
*/

private static class RedisUtilHolder{
/**
* 静态初始化器,由JVM来保证线程安全
*/

private static RedisUtil instance = new RedisUtil();
}

/**
*当getInstance方法第一次被调用的时候,它第一次读取
*RedisUtilHolder.instance,导致RedisUtilHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静
*态域,从而创建RedisUtil的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。
*这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。
*/

public static RedisUtil getInstance() {
return RedisUtilHolder.instance;
}

/**
* 获取Redis实例.
* @return Redis工具类实例
*/

public static Jedis getJedis(String ip,int port) {
Jedis jedis = null;
int count =0;
do{
try{
jedis = getPool(ip,port).getResource();
//log.info("get redis master1!");
} catch (Exception e) {
// 销毁对象
getPool(ip,port).returnBrokenResource(jedis);
}
count++;
}while(jedis==null&&count<1000);
return jedis;
}

/**
* 释放redis实例到连接池.
* @param jedis redis实例
*/

public static void closeJedis(Jedis jedis,String ip,int port) {
if(jedis != null) {
getPool(ip,port).returnResource(jedis);
}
}
}
  • 一个jedis的详细测试代码
package com.kang.redis; 

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.SortingParams;


public class TestCase {

/**
* 在不同的线程中使用相同的Jedis实例会发生奇怪的错误。但是创建太多的实现也不好因为这意味着会建立很多sokcet连接,
* 也会导致奇怪的错误发生。单一Jedis实例不是线程安全的。为了避免这些问题,可以使用JedisPool,
* JedisPool是一个线程安全的网络连接池。可以用JedisPool创建一些可靠Jedis实例,可以从池中拿到Jedis的实例。
* 这种方式可以解决那些问题并且会实现高效的性能
*/



@Test
public void Hello() {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
try {
// 向key-->name中放入了value-->java
jedis.set("name", "java");
String ss = jedis.get("name");
System.out.println(ss);

// 很直观,将spring append到已经有的value之后
jedis.append("name", "spring");
ss = jedis.get("name");
System.out.println(ss); //输出javasspring

// 2、直接覆盖原来的数据
jedis.set("name", "spring");
System.out.println(jedis.get("name")); //输出spring

// 删除key对应的记录
jedis.del("name");
System.out.println(jedis.get("name"));// 执行结果:null

/**
* mset相当于 jedis.set("name","java"); jedis.set("jarorwar","aaa");
*/

jedis.mset("name", "java", "jarorwar", "aaa");
System.out.println(jedis.mget("name", "jarorwar")); //输出[java, aaa]
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

}

@Test
public void testKey() {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
System.out.println("=============key==========================");
// 清空数据
System.out.println(jedis.flushDB());
System.out.println(jedis.echo("foo")); //Echo命令用于打印给定的字符串。
// 判断key否存在
System.out.println(jedis.exists("foo")); //false
jedis.set("key", "values");
System.out.println(jedis.exists("key")); //true
}

@Test
public void testString() {
System.out.println("==String==");
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
try {
// String
jedis.set("key", "Hello World!");
String value = jedis.get("key");
System.out.println(value);
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

System.out.println("=============String==========================");
// 清空数据
System.out.println(jedis.flushDB());
// 存储数据
jedis.set("foo", "bar");
System.out.println(jedis.get("foo"));
// 若key不存在,则存储
jedis.setnx("foo", "foo not exits"); //因为key(foo)已存在,所以这里不会存储这个值
System.out.println(jedis.get("foo")); //输出foo
// 覆盖数据
jedis.set("foo", "foo update");
System.out.println(jedis.get("foo")); //foo update
// 追加数据
jedis.append("foo", " hello, world");
System.out.println(jedis.get("foo")); //foo update hello, world
// 设置key的有效期,并存储数据
jedis.setex("foo", 2, "foo not exits"); //有效期两秒
System.out.println(jedis.get("foo")); //foo not exits
try {
Thread.sleep(3000); //延时3秒,数据失效
} catch (InterruptedException e) {
}
System.out.println(jedis.get("foo")); //null
// 获取并更改数据
jedis.set("foo", "foo update");
System.out.println(jedis.getSet("foo", "foo modify")); //foo modify
System.out.println(jedis.get("foo"));//foo modify
// 截取value的值
System.out.println(jedis.getrange("foo", 1, 5)); //oo mo
System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2",
"mset3", "mvalue3", "mset4", "mvalue4"));
System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4")); //[mvalue1, mvalue2, mvalue3, mvalue4]
System.out.println(jedis.del(new String[] { "foo", "foo1", "foo3" })); //输出1,DEL命令用于删除已存在的键。不存在的 key 会被忽略。
//返回值是被删除 key 的数量。
}

@Test
public void testList() {
System.out.println("==List==");
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
try {
// 开始前,先移除所有的内容
jedis.del("messages");
jedis.rpush("messages", "Hello how are you?");
jedis.rpush("messages", "Fine thanks. I'm having fun with redis.");
jedis.rpush("messages", "I should look into this NOSQL thing ASAP");

// 再取出所有数据。jedis.lrange是按范围取出,
// 第一个是key,第二个是起始位置,第三个是结束位置,jedis.llen获取长度 -1表示取得所有
List<String> values = jedis.lrange("messages", 0, -1);
System.out.println(values);

} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

// 清空数据
System.out.println(jedis.flushDB());
// 添加数据
jedis.lpush("lists", "8");
jedis.lpush("lists", "5");
jedis.lpush("lists", "9");
// 数组长度
System.out.println(jedis.llen("lists")); //3
// 排序
System.out.println(jedis.sort("lists")); //[5, 8, 9](默认升序排序)
/*
* 如果使用Redis SORT排序的不是数字,是字母,将他们按照字典的顺序排名,则需要使用 SORT key ALPHA
* 如果不加ALPHA参数,则会报错,提示:(error) ERR One or more scores can't be converted into double。
* 我们还可以使用关系型数据库的DESC进行倒序排序和LIMIT offset count来限定获取的条数
*/

// 字串
System.out.println(jedis.lrange("lists", 0, 3)); //[9, 5, 8]
/*LRANGE命令将返回存储在key列表的特定元素。偏移量开始和停止是从0开始的索引,
* 0是第一元素(该列表的头部),1是列表的下一个元素。这些偏移量也可以是表示开始在列表的末尾偏移负数。
* 例如,-1是该列表的最后一个元素,-2倒数第二个,等等。
*/

// 修改列表中单个值
jedis.lset("lists", 0, "hello list!");
System.out.println(jedis.lrange("lists", 0, 3));//[hello list!, 5, 8]
// 获取列表指定下标的值
System.out.println(jedis.lindex("lists", 1)); //5
// 删除列表指定下标的值
System.out.println(jedis.lrem("lists", 1, "vector")); //输出0
/*
* Lrem 根据参数 COUNT 的值,移除列表中与参数 VALUE 相等的元素。命令形式:LREM KEY_NAME COUNT VALUE
* COUNT 的值可以是以下几种:
* count > 0 : 从表头开始向表尾搜索,移除与 VALUE 相等的元素,数量为 COUNT 。
* count < 0 : 从表尾开始向表头搜索,移除与 VALUE 相等的元素,数量为 COUNT 的绝对值。
* count = 0 : 移除表中所有与 VALUE 相等的值。
* 返回值是被移除元素的数量。 列表不存在时返回 0 。
*/

// 删除区间以外的数据
System.out.println(jedis.ltrim("lists", 0, 1)); //ok
/*
* Ltrim 对一个列表进行修剪(trim),就是说,让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除。
* 下标 0 表示列表的第一个元素,以 1 表示列表的第二个元素,以此类推。 你也可以使用负数下标,
* 以 -1 表示列表的最后一个元素, -2 表示列表的倒数第二个元素,以此类推。命令形式: LTRIM KEY_NAME START STOP
* 返回值:命令执行成功时,返回 ok 。
*/

// 列表出栈
System.out.println(jedis.lpop("lists")); //hello list!
/*
* Lpop 命令用于移除并返回列表的第一个元素。返回值:列表的第一个元素。 当列表 key 不存在时,返回 nil 。
*/

// 整个列表值
System.out.println(jedis.lrange("lists", 0, -1)); // [5]
}

@Test
public void testSet() {
System.out.println("==Set==");
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
try {
jedis.sadd("myset", "1");
jedis.sadd("myset", "2");
jedis.sadd("myset", "3");
jedis.sadd("myset", "4");
Set<String> setValues = jedis.smembers("myset"); // Smembers命令返回集合中的所有的成员。 不存在的集合 key 被视为空集合。
System.out.println(setValues); //输出是无序的[3, 2, 1, 4]

// 移除noname
jedis.srem("myset", "4"); //Srem 命令用于移除集合中的一个或多个成员元素,不存在的成员元素会被忽略。当 key 不是集合类型,返回一个错误。
System.out.println(jedis.smembers("myset"));// 获取所有加入的value,输出[3, 2, 1]
System.out.println(jedis.sismember("myset", "4"));// 输出false。Sismember 命令判断成员元素是否是集合的成员。
System.out.println(jedis.scard("myset"));// 返回集合的元素个数 :3
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

// 清空数据
System.out.println(jedis.flushDB());
// 添加数据
jedis.sadd("sets", "HashSet");
jedis.sadd("sets", "SortedSet");
jedis.sadd("sets", "TreeSet");
// 判断value是否在列表中
System.out.println(jedis.sismember("sets", "TreeSet")); //true
// 整个列表值
System.out.println(jedis.smembers("sets")); //[SortedSet, TreeSet, HashSet]
// 删除指定元素
System.out.println(jedis.srem("sets", "SortedSet"));
// 出栈
System.out.println(jedis.spop("sets")); //Spop 命令用于移除并返回集合中的一个随机元素。
System.out.println(jedis.smembers("sets"));
//
jedis.sadd("sets1", "HashSet1");
jedis.sadd("sets1", "SortedSet1");
jedis.sadd("sets1", "TreeSet");
jedis.sadd("sets2", "HashSet2");
jedis.sadd("sets2", "SortedSet1");
jedis.sadd("sets2", "TreeSet1");
// 交集
System.out.println(jedis.sinter("sets1", "sets2")); //[SortedSet1]
// 并集
System.out.println(jedis.sunion("sets1", "sets2")); //[HashSet2, HashSet1, TreeSet1, SortedSet1, TreeSet]
// 差集
System.out.println(jedis.sdiff("sets1", "sets2")); //[TreeSet, HashSet1]
}

@Test
public void sortedSet() {
System.out.println("==SoretedSet==");
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
try {
jedis.zadd("hackers", 1940, "Alan Kay");
jedis.zadd("hackers", 1953, "Richard Stallman");
jedis.zadd("hackers", 1965, "Yukihiro Matsumoto");
jedis.zadd("hackers", 1916, "Claude Shannon");
jedis.zadd("hackers", 1969, "Linus Torvalds");
jedis.zadd("hackers", 1912, "Alan Turing");
Set<String> setValues = jedis.zrange("hackers", 0, -1);
// Zrange 返回有序集中,指定区间内的成员。其中成员的位置按分数值递增(从小到大)来排序。
//具有相同分数值的成员按字典序(lexicographical order )来排列。
System.out.println(setValues); //[Alan Turing, Claude Shannon, Alan Kay, Richard Stallman, Yukihiro Matsumoto, Linus Torvalds]
Set<String> setValues2 = jedis.zrevrange("hackers", 0, -1);
//Zrevrange 命令返回有序集中,指定区间内的成员.其中成员的位置按分数值递减(从大到小)来排列。
System.out.println(setValues2); //[Linus Torvalds, Yukihiro Matsumoto, Richard Stallman, Alan Kay, Claude Shannon, Alan Turing]
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

// 清空数据
System.out.println(jedis.flushDB());
// 添加数据
jedis.zadd("zset", 10.1, "hello");
jedis.zadd("zset", 10.0, ":");
jedis.zadd("zset", 9.0, "zset");
jedis.zadd("zset", 11.0, "zset!");
// 元素个数
System.out.println(jedis.zcard("zset")); //4
// 元素下标
System.out.println(jedis.zscore("zset", "zset"));//9.0
//Zscore 命令返回有序集中,成员的分数值。 如果成员元素不是有序集 key 的成员,或 key 不存在,返回 nil 。
// 集合子集
System.out.println(jedis.zrange("zset", 0, -1)); //[zset, :, hello, zset!]
// 删除元素
System.out.println(jedis.zrem("zset", "zset!"));
System.out.println(jedis.zcount("zset", 9.5, 10.5)); //2.Zcount 命令用于计算有序集合中指定分数区间的成员数量。

// 整个集合值
System.out.println(jedis.zrange("zset", 0, -1)); //[zset, :, hello]
}

@Test
public void testHsh() {
System.out.println("==Hash==");
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
try {
Map<String, String> pairs = new HashMap<String, String>();
pairs.put("name", "Akshi");
pairs.put("age", "2");
pairs.put("sex", "Female");
jedis.hmset("kid", pairs);
List<String> name = jedis.hmget("kid", "name");// 结果是个泛型的LIST
// jedis.hdel("kid","age"); //删除map中的某个键值
System.out.println(jedis.hmget("kid", "pwd")); // 因为删除了,所以返回的是null
System.out.println(jedis.hlen("kid")); // 返回key为user的键中存放的值的个数
System.out.println(jedis.exists("kid"));// 是否存在key为user的记录
System.out.println(jedis.hkeys("kid"));// 返回map对象中的所有key
System.out.println(jedis.hvals("kid"));// 返回map对象中的所有value

Iterator<String> iter = jedis.hkeys("kid").iterator();
while (iter.hasNext()) {
String key = iter.next();
System.out.println(key + ":" + jedis.hmget("kid", key));
}

List<String> values = jedis.lrange("messages", 0, -1);
values = jedis.hmget("kid", new String[] { "name", "age", "sex" });
System.out.println(values);
Set<String> setValues = jedis.zrange("hackers", 0, -1);
setValues = jedis.hkeys("kid");
System.out.println(setValues);
values = jedis.hvals("kid");
System.out.println(values);
pairs = jedis.hgetAll("kid");
System.out.println(pairs);
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

// 清空数据
System.out.println(jedis.flushDB());
// 添加数据
jedis.hset("hashs", "entryKey", "entryValue");
jedis.hset("hashs", "entryKey1", "entryValue1");
jedis.hset("hashs", "entryKey2", "entryValue2");
// 判断某个值是否存在
System.out.println(jedis.hexists("hashs", "entryKey"));
// 获取指定的值
System.out.println(jedis.hget("hashs", "entryKey")); // 批量获取指定的值
System.out.println(jedis.hmget("hashs", "entryKey", "entryKey1"));
// 删除指定的值
System.out.println(jedis.hdel("hashs", "entryKey"));
// 为key中的域 field 的值加上增量 increment
System.out.println(jedis.hincrBy("hashs", "entryKey", 123l));
// 获取所有的keys
System.out.println(jedis.hkeys("hashs"));
// 获取所有的values
System.out.println(jedis.hvals("hashs"));
}

@Test
public void testOther() throws InterruptedException {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);

try {
// keys中传入的可以用通配符
System.out.println(jedis.keys("*")); // 返回当前库中所有的key [sose, sanme,
// name, jarorwar, foo,
// sname, java framework,
// user, braand]
System.out.println(jedis.keys("*name"));// 返回的sname [sname, name]
System.out.println(jedis.del("sanmdde"));// 删除key为sanmdde的对象 删除成功返回1
// 删除失败(或者不存在)返回 0
System.out.println(jedis.ttl("sname"));// 返回给定key的有效时间,如果是-1则表示永远有效
jedis.setex("timekey", 10, "min");// 通过此方法,可以指定key的存活(有效时间) 时间为秒
Thread.sleep(5000);// 睡眠5秒后,剩余时间将为<=5
System.out.println(jedis.ttl("timekey")); // 输出结果为5
jedis.setex("timekey", 1, "min"); // 设为1后,下面再看剩余时间就是1了
System.out.println(jedis.ttl("timekey")); // 输出结果为1
System.out.println(jedis.exists("key"));// 检查key是否存在
System.out.println(jedis.rename("timekey", "time"));
System.out.println(jedis.get("timekey"));// 因为移除,返回为null
System.out.println(jedis.get("time")); // 因为将timekey 重命名为time
// 所以可以取得值 min
// jedis 排序
// 注意,此处的rpush和lpush是List的操作。是一个双向链表(但从表现来看的)
jedis.del("a");// 先清除数据,再加入数据进行测试
jedis.rpush("a", "1");
jedis.lpush("a", "6");
jedis.lpush("a", "3");
jedis.lpush("a", "9");
System.out.println(jedis.lrange("a", 0, -1));// [9, 3, 6, 1]
System.out.println(jedis.sort("a")); // [1, 3, 6, 9] //输入排序后结果
System.out.println(jedis.lrange("a", 0, -1));
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

}

@Test
public void testUnUsePipeline() {
long start = new Date().getTime();

Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
for (int i = 0; i < 10000; i++) {
jedis.set("age1" + i, i + "");
jedis.get("age1" + i);// 每个操作都发送请求给redis-server
}
long end = new Date().getTime();

System.out.println("unuse pipeline cost:" + (end - start) + "ms");

RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}

@Test
/**
* 参考:http://blog.csdn.net/freebird_lb/article/details/7778919
*/

public void testUsePipeline() {
long start = new Date().getTime();

Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
jedis.flushDB();
Pipeline p = jedis.pipelined();
for (int i = 0; i < 10000; i++) {
p.set("age2" + i, i + "");
System.out.println(p.get("age2" + i));
}
p.sync();// 这段代码获取所有的response

long end = new Date().getTime();

System.out.println("use pipeline cost:" + (end - start) + "ms");

RedisUtil.getPool("127.0.0.1",6379).returnResource(jedis);
}


@Test
/**
* 时间复杂度:
O(N+M*log(M)), N 为要排序的列表或集合内的元素数量, M 为要返回的元素数量。
如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序,时间复杂度 O(N)。
*/

public void testSort1() {
// 排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较
Jedis redis = RedisUtil.getJedis("127.0.0.1",6379);
// 一般SORT用法 最简单的SORT使用方法是SORT key。
redis.lpush("mylist", "1");
redis.lpush("mylist", "4");
redis.lpush("mylist", "6");
redis.lpush("mylist", "3");
redis.lpush("mylist", "0");
// List<String> list = redis.sort("sort");// 默认是升序
SortingParams sortingParameters = new SortingParams();
sortingParameters.desc();
// sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用 ALPHA
// 修饰符(modifier)进行排序。
sortingParameters.limit(0, 2);// 可用于分页查询
List<String> list = redis.sort("mylist", sortingParameters);// 默认是升序
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
redis.flushDB();
RedisUtil.closeJedis(redis,"127.0.0.1",6379);
}

@Test
/**
* sort list
* LIST结合hash的排序
*/

public void testSort2() {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
jedis.del("user:66", "user:55", "user:33", "user:22", "user:11",
"userlist");
jedis.lpush("userlist", "33");
jedis.lpush("userlist", "22");
jedis.lpush("userlist", "55");
jedis.lpush("userlist", "11");

jedis.hset("user:66", "name", "66");
jedis.hset("user:55", "name", "55");
jedis.hset("user:33", "name", "33");
jedis.hset("user:22", "name", "79");
jedis.hset("user:11", "name", "24");
jedis.hset("user:11", "add", "beijing");
jedis.hset("user:22", "add", "shanghai");
jedis.hset("user:33", "add", "guangzhou");
jedis.hset("user:55", "add", "chongqing");
jedis.hset("user:66", "add", "xi'an");

SortingParams sortingParameters = new SortingParams();
// 符号 "->" 用于分割哈希表的键名(key name)和索引域(hash field),格式为 "key->field"
sortingParameters.get("user:*->name");
sortingParameters.get("user:*->add");
// sortingParameters.by("user:*->name");
// sortingParameters.get("#");
List<String> result = jedis.sort("userlist", sortingParameters);
for (String item : result) {
System.out.println("item...." + item);
}
/**
* 对应的redis客户端命令是:sort ml get user*->name sort ml get user:*->name get
* user:*->add
*/

}

@org.junit.Test
/**
* sort set
* SET结合String的排序
*/

public void testSort3() {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
jedis.del("tom:friend:list", "score:uid:123", "score:uid:456",
"score:uid:789", "score:uid:101", "uid:123", "uid:456",
"uid:789", "uid:101");

jedis.sadd("tom:friend:list", "123"); // tom的好友列表
jedis.sadd("tom:friend:list", "456");
jedis.sadd("tom:friend:list", "789");
jedis.sadd("tom:friend:list", "101");

jedis.set("score:uid:123", "1000"); // 好友对应的成绩
jedis.set("score:uid:456", "6000");
jedis.set("score:uid:789", "100");
jedis.set("score:uid:101", "5999");

jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息
jedis.set("uid:456", "{'uid':456,'name':'jack'}");
jedis.set("uid:789", "{'uid':789,'name':'jay'}");
jedis.set("uid:101", "{'uid':101,'name':'jolin'}");

SortingParams sortingParameters = new SortingParams();

sortingParameters.desc();
// sortingParameters.limit(0, 2);
// 注意GET操作是有序的,GET user_name_* GET user_password_*
// 和 GET user_password_* GET user_name_*返回的结果位置不同
sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"
// ,用于获取被排序对象(我们这里的例子是 user_id )的当前元素。
sortingParameters.get("uid:*");
sortingParameters.get("score:uid:*");
sortingParameters.by("score:uid:*");
// 对应的redis 命令是./redis-cli sort tom:friend:list by score:uid:* get # get
// uid:* get score:uid:*
List<String> result = jedis.sort("tom:friend:list", sortingParameters);
for (String item : result) {
System.out.println("item..." + item);
}

}

/**
*
* 只获取对象而不排序 BY 修饰符可以将一个不存在的 key 当作权重,让 SORT 跳过排序操作。
* 该方法用于你希望获取外部对象而又不希望引起排序开销时使用。
*/

public void testSort4() {

}

/**
*
保存排序结果 默认情况下, SORT 操作只是简单地返回排序结果,如果你希望保存排序结果,可以给 STORE 选项指定一个 key
* 作为参数,排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在,则覆盖。) 一个有趣的用法是将 SORT
* 结果保存,用 EXPIRE 为结果集设置生存时间,这样结果集就成了 SORT 操作的一个缓存。 这样就不必频繁地调用 SORT
* 操作了,只有当结果集过期时,才需要再调用一次 SORT 操作。
* 有时候为了正确实现这一用法,你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端,同一时间进行 SORT
* 操作,并保存为结果集),具体参见 SETNX 命令。
*/

@Test
public void testSort5() {
// 排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
// 一般SORT用法 最简单的SORT使用方法是SORT key。
jedis.lpush("mylist", "1");
jedis.lpush("mylist", "4");
jedis.lpush("mylist", "6");
jedis.lpush("mylist", "3");
jedis.lpush("mylist", "0");
// List<String> list = redis.sort("sort");// 默认是升序
SortingParams sortingParameters = new SortingParams();
sortingParameters.desc();
// sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用 ALPHA
// 修饰符(modifier)进行排序。
// sortingParameters.limit(0, 2);//可用于分页查询

// 没有使用 STORE 参数,返回列表形式的排序结果. 使用 STORE 参数,返回排序结果的元素数量。

jedis.sort("mylist", sortingParameters, "mylist");// 排序后指定排序结果到一个KEY中,这里讲结果覆盖原来的KEY

List<String> list = jedis.lrange("mylist", 0, -1);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}

jedis.sadd("tom:friend:list", "123"); // tom的好友列表
jedis.sadd("tom:friend:list", "456");
jedis.sadd("tom:friend:list", "789");
jedis.sadd("tom:friend:list", "101");

jedis.set("score:uid:123", "1000"); // 好友对应的成绩
jedis.set("score:uid:456", "6000");
jedis.set("score:uid:789", "100");
jedis.set("score:uid:101", "5999");

jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息
jedis.set("uid:456", "{'uid':456,'name':'jack'}");
jedis.set("uid:789", "{'uid':789,'name':'jay'}");
jedis.set("uid:101", "{'uid':101,'name':'jolin'}");

sortingParameters = new SortingParams();
// sortingParameters.desc();
sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"
// ,用于获取被排序对象(我们这里的例子是 user_id )的当前元素。
sortingParameters.by("score:uid:*");
jedis.sort("tom:friend:list", sortingParameters, "tom:friend:list");
List<String> result = jedis.lrange("tom:friend:list", 0, -1);
for (String item : result) {
System.out.println("item..." + item);
}

jedis.flushDB();
RedisUtil.closeJedis(jedis,"127.0.0.1",6379);
}


public void testMore(){
//ZRANGE取出最新的10个项目。
//使用LPUSH + LTRIM,确保只取出最新的1000条项目。
//HINCRBY key field increment,为哈希表 key 中的域 field 的值加上增量 increment
//INCRBY,HINCRBY等等,redis有了原子递增(atomic increment),你可以放心的加上各种计数,用GETSET重置,或者是让它们过期。
// LREM greet 2 morning # 移除从表头到表尾,最先发现的两个 morning,这个可以用来删除特定评论
// zrevrank test a 查看a在sorted set中倒排序时排在第几名,查询结果按照INDEX,所以INDEX是3表示排在第四名
// zrank test a 相反,表示正排序时候的名次
// zscore test one表示one这个元素在sorted set中的score为多少
// zrevrange test 0 -1 表示sorted set倒排序,zrange test 0 -1表示正排序
//将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员,那么更新这个 member 的 score 值,并通过重新插入这个 member 元素,来保证该 member 在正确的位置上。
//zrem test one删除sorted set中某个元素
}

public List<String> get_latest_comments(int start, int num_items){
//获取最新评论
//LPUSH latest.comments <ID>
//-我们将列表裁剪为指定长度,因此Redis只需要保存最新的5000条评论:
//LTRIM latest.comments 0 5000
//们做了限制不能超过5000个ID,因此我们的获取ID函数会一直询问Redis。只有在start/count参数超出了这个范围的时候,才需要去访问数据库。
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
List<String> id_list = jedis.lrange("latest.comments",start,start+num_items-1) ;

if(id_list.size()<num_items){
//id_list = SQL.EXECUTE("SELECT ... ORDER BY time LIMIT ...");
}
return id_list;
}



@Test
public void testDB() {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
System.out.println(jedis.select(0));// select db-index
// 通过索引选择数据库,默认连接的数据库所有是0,默认数据库数是16个。返回1表示成功,0失败
System.out.println(jedis.dbSize());// dbsize 返回当前数据库的key数量
System.out.println(jedis.keys("*")); // 返回匹配指定模式的所有key
System.out.println(jedis.randomKey());
jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用
jedis.flushAll();// 删除所有数据库中的所有key,此方法不会失败。更加慎用

}

@Test
public void testMget() {

Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用

jedis.rpush("ids", "aa");
jedis.rpush("ids", "bb");
jedis.rpush("ids", "cc");

List<String> ids = jedis.lrange("ids", 0, -1);

jedis.set("aa", "{'name':'zhoujie','age':20}");
jedis.set("bb", "{'name':'yilin','age':28}");
jedis.set("cc", "{'name':'lucy','age':21}");
List<String> list = jedis.mget(ids.toArray(new String[ids.size()]));
System.out.println(list);
}

/**
* 可以利用lrange对list进行分页操作
*/

@Test
public void queryPageBy() {
int pageNo = 6;
int pageSize = 6;
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
jedis.del("a");
for (int i = 1; i <= 30; i++) {
jedis.rpush("a", i + "");
}

int start = pageSize * (pageNo - 1);// 因为redis中list元素位置基数是0
int end = start + pageSize - 1;

List<String> results = jedis.lrange("a", start, end);// 从start算起,start算一个元素,到结束那个元素
for (String str : results) {
System.out.println(str);
}

}

@Test
/**
* [向Redis list压入ID而不是实际的数据]
在上面的例子里 ,我们将“对象”(此例中是简单消息)直接压入Redis list,但通常不应这么做,
由于对象可能被多次引用:例如在一个list中维护其时间顺序,在一个集合中保存它的类别,只要有必要,它还会出现在其他list中,等等。
让我们回到reddit.com的例子,将用户提交的链接(新闻)添加到list中,有更可靠的方法如下所示:
$ redis-cli incr next.news.id
(integer) 1
$ redis-cli set news:1:title "Redis is simple"
OK
$ redis-cli set news:1:url "http://code.google.com/p/redis"
OK
$ redis-cli lpush submitted.news 1
OK
我们自增一个key,很容易得到一个独一无二的自增ID,然后通过此ID创建对象–为对象的每个字段设置一个key。最后将新对象的ID压入submitted.news list。
这只是牛刀小试。在命令参考文档中可以读到所有和list有关的命令。你可以删除元素,旋转list,根据索引获取和设置元素,当然也可以用LLEN得到list的长度。
*/

public void testListStrUsage() {
String title = "太阳能是绿色能源4";
String url = "http://javacreazyer.iteye.com";
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);

long adInfoId = jedis.incr("ad:adinfo:next.id");
jedis.set("ad:adinfo:" + adInfoId + ":title", title);
jedis.set("ad:adinfo:" + adInfoId + ":url", url);
jedis.lpush("ad:adinfo", String.valueOf(adInfoId));

String resultTitle = jedis.get("ad:adinfo:" + adInfoId + ":title");
String resultUrl = jedis.get("ad:adinfo:" + adInfoId + ":url");
List<String> ids = jedis.lrange("ad:adinfo", 0, -1);
System.out.println(resultTitle);
System.out.println(resultUrl);
System.out.println(ids);

/**
* dbsize返回的是所有key的数目,包括已经过期的, 而redis-cli keys "*"查询得到的是有效的key数目
*/

System.out.println(jedis.dbSize());

jedis.flushAll();
}

/**
* 下面是一个简单的方案:对每个想加标签的对象,用一个标签ID集合与之关联,并且对每个已有的标签,一组对象ID与之关联。 例如假设我们的新闻ID
* 在命令参考文档中可以找到和集合相关的其他命令,令人感兴趣的一抓一大把。一定要留意SORT命令,Redis集合和list都是可排序的。
*/

@Test
public void testSetUsage() {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
jedis.sadd("kang:news:1000:tags", "1");
jedis.sadd("kang:news:1000:tags", "2");
jedis.sadd("kang:news:1000:tags", "5");
jedis.sadd("kang:news:1000:tags", "77");
jedis.sadd("kang:news:2000:tags", "1");
jedis.sadd("kang:news:2000:tags", "2");
jedis.sadd("kang:news:2000:tags", "5");
jedis.sadd("kang:news:2000:tags", "77");
jedis.sadd("kang:news:3000:tags", "2");
jedis.sadd("kang:news:4000:tags", "77");
jedis.sadd("kang:news:5000:tags", "1");
jedis.sadd("kang:news:6000:tags", "5");

jedis.sadd("kang:tag:1:objects", 1000 + "");
jedis.sadd("kang:tag:2:objects", 1000 + "");
jedis.sadd("kang:tag:5:objects", 1000 + "");
jedis.sadd("kang:tag:77:objects", 1000 + "");

jedis.sadd("kang:tag:1:objects", 2000 + "");
jedis.sadd("kang:tag:2:objects", 2000 + "");
jedis.sadd("kang:tag:5:objects", 2000 + "");
jedis.sadd("kang:tag:77:objects", 2000 + "");

Set<String> sets = jedis.sinter("kang:tag:1:objects",
"kang:tag:2:objects", "kang:tag:5:objects",
"kang:tag:77:objects");
System.out.println(sets);
jedis.flushAll();
}

@Test
public void testSortedSetUsage() {
Jedis jedis = RedisUtil.getJedis("127.0.0.1",6379);
jedis.zadd("kang:hackers", 1940, "Alan Kay");
jedis.zadd("kang:hackers", 1953, "Richard Stallman");
jedis.zadd("kang:hackers", 1943, "Jay");
jedis.zadd("kang:hackers", 1920, "Jellon");
jedis.zadd("kang:hackers", 1965, "Yukihiro Matsumoto");
jedis.zadd("kang:hackers", 1916, "Claude Shannon");
jedis.zadd("kang:hackers", 1969, "Linus Torvalds");
jedis.zadd("kang:hackers", 1912, "Alan Turing");

Set<String> hackers = jedis.zrange("kang:hackers", 0, -1);
System.out.println(hackers);

Set<String> hackers2 = jedis.zrevrange("kang:hackers", 0, -1);
System.out.println(hackers2);

// 区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素(两个极值也包含了)。
Set<String> hackers3 = jedis.zrangeByScore("kang:hackers", "-inf",
"1920");
System.out.println(hackers3);

// ZREMRANGEBYSCORE 这个名字虽然不算好,但他却非常有用,还会返回已删除的元素数量。
long num = jedis.zremrangeByScore("kang:hackers", "-inf", "1920");
System.out.println(num);

jedis.flushAll();
}

}

三、Spring集成Jedis

如果和Spring进行整合的话,我们将获得更好的简洁性、灵活性,显然是一种更加优雅(graceful)的方式。

1、搭建环境:

  • 在之前版本的基础之上,添加如下的依赖:

spring.jar
commons-logging.jar
log4j-1.2.15.jar
同时添加日志配置文件:log4j.properties到classpath下面。

  • 配置Spring文件:applicationContext.xml

注意:连接池jedisPool的配置,这里使用了构造方式注入,这是和Jedis的API一致的;在注入port时,需要使用使用type=”int”指定注入的参数类型,否则出现异常。

<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
>


<!-- 加载redis配置文件 -->
<context:property-placeholder location="classpath:redis.properties"/>

<!-- redis连接池的配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxActive" value="${redis.pool.maxActive}"/>
<property name="maxIdle" value="${redis.pool.maxIdle}"/>
<property name="minIdle" value="${redis.pool.minIdle}"/>
<property name="maxWait" value="${redis.pool.maxWait}"/>
<property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>
<property name="testOnReturn" value="${redis.pool.testOnReturn}"/>
</bean>

<!-- redis的连接池pool,不是必选项:timeout/password -->
<bean id = "jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg index="0" ref="jedisPoolConfig"/>
<constructor-arg index="1" value="${redis.host}"/>
<constructor-arg index="2" value="${redis.port}" type="int"/>
<constructor-arg index="3" value="${redis.timeout}" type="int"/>
<constructor-arg index="4" value="${redis.password}"/>
</bean>

</beans>

2、从SPring容器中获取JedisPool:

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");  
JedisPool pool = (JedisPool) context.getBean("jedisPool");
Jedis jedis = pool.getResource();
...
pool.returnResource(jedis);

3、缓存JavaBean:

很多时候我们都希望Redis能够对JavaBean进行缓存,这需要借助于JDK提供的序列化技术。

  • 要求缓存实体实现了序列化Serializable接口:这里以Userinfo为例。
  • 序列化工具类:Jedis对序列化的支持,是提供了字节数组byte[]作为参数;为此编写SerializingUtil工具类负责byte[]和JavaBean之间的相互转换。该方法的API如下所示:
public static byte[] serialize(Object source);   
public static Object deserialize(byte[] source);

该工具类的具体实现:

/** 
* 功能简述: 序列化工具类,负责byte[]和Object之间的相互转换.
*/

public class SerializingUtil {

private static Log logger = LogFactory.getLog(SerializingUtil.class);

/**
* 功能简述: 对实体Bean进行序列化操作.
* @param source 待转换的实体
* @return 转换之后的字节数组
* @throws Exception
*/

public static byte[] serialize(Object source) {
ByteArrayOutputStream byteOut = null;
ObjectOutputStream ObjOut = null;
try {
byteOut = new ByteArrayOutputStream();
ObjOut = new ObjectOutputStream(byteOut);
ObjOut.writeObject(source);
ObjOut.flush();
}
catch (IOException e) {
logger.error(source.getClass().getName()
+ " serialized error !", e);
}
finally {
try {
if (null != ObjOut) {
ObjOut.close();
}
}
catch (IOException e) {
ObjOut = null;
}
}
return byteOut.toByteArray();
}

/**
* 功能简述: 将字节数组反序列化为实体Bean.
* @param source 需要进行反序列化的字节数组
* @return 反序列化后的实体Bean
* @throws Exception
*/

public static Object deserialize(byte[] source) {
ObjectInputStream ObjIn = null;
Object retVal = null;
try {
ByteArrayInputStream byteIn = new ByteArrayInputStream(source);
ObjIn = new ObjectInputStream(byteIn);
retVal = ObjIn.readObject();
}
catch (Exception e) {
logger.error("deserialized error !", e);
}
finally {
try {
if(null != ObjIn) {
ObjIn.close();
}
}
catch (IOException e) {
ObjIn = null;
}
}
return retVal;
}
}
  • 对JavaBean的存储和获取:

定义实体:借助于Timestamp类,获取ms值。

Userinfo actual = new Userinfo(140520, "xiaokang",   
new Date(Timestamp.valueOf("1990-11-11 00:00:00").getTime()));

使用Jedis操作:key、value都需要转成byte[]字节数组。

String key = "user.userid." + actual.getUserId(); 
jedis.set(key.getBytes(), SerializingUtil.serialize(actual));
Userinfo expected = (Userinfo) SerializingUtil.deserialize(jedis.get(key.getBytes()));

对象的比较:需要覆写equals和hashCode方法。

四、Jedis接口的封装

我们每次将shardedJedisPool注入到相关类中会比较麻烦,我们需要集成一个封装方法,方便redis的实现

  • spring集成redis的配置文件内容如下
<?xml version="1.0" encoding="GBK"?>  
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans default-lazy-init="false">
<description>REDIS缓存配置</description>

<!-- JEDIS SHARD 池配置 -->
<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1">
<list>
<ref bean="jedis.shardInfo.default" />
</list>
</constructor-arg>
</bean>

<!-- JEDIS连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="100" />
<property name="maxIdle" value="20" />
<property name="maxWaitMillis" value="5000" />
<property name="testOnBorrow" value="true" />
</bean>

<!-- JEDIS SHARD信息配置[START] 在此添加REDIS集群配置 -->
<bean id="jedis.shardInfo.default" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="192.168.1.21" />
<constructor-arg index="1" type="int" value="6379" />
<constructor-arg index="2" type="java.lang.String" value="192.168.1.21" />
</bean>
<!-- JEDIS SHARD信息配置 [END] -->
<!-- 缓存代理,使用缓存内容请使用本代理进行操作 请使用接口进行注入 -->
<bean id="cacheProxy" class="com.kang.common.cache.CacheProxy">
<property name="shardedJedisPool">
<ref bean="shardedJedisPool" />
</property>
</bean>
</beans>
  • 实现cacheProxy类继承ShardedRedisProxy类
package com.kang.common.cache;  

/**
* 缓存代理
*/

public class CacheProxy{
//TODO 这里可以继承ShardedJedisPool的实现类
...
}
  • shardedJedisPool的java实现与jedis客户端的封装类

IRedisProxy缓存代理接口

package com.kang.common.cache;  

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

/**
* * 缓存代理接口
* 提供缓存内容操作接口,包括key以及value的操作,本代理只提供缓存基本操作,不提供涉及连接等连接池操作。
* 1、以H开头的为HASH操作命令;
* 2、以L开头的为LIST操作命令;
* 3、以S开头的为SET(集合)操作命令;
* 4、以Z开头的为ZSET(有序集合)操作命令
*
*/

public interface IRedisProxy {

/**
* toString
* @return
*/

public String toString();

/**
* 将字符串值value关联到key。 如果key已经持有其他值,SET就覆写旧值,无视类型。
*
* @param key key
* @param value value
* @return string
*/

public String set(String key, String value);

/**
* 返回key所关联的字符串值
* <p>
* 假如key储存的值不是字符串类型,返回一个错误,因为GET只能用于处理字符串值
*
* @param key key
* @return String
*/

public String get(String key);

/**
* 检查给定key是否存在。
* <p>
*
* @param key key
* @return 是否
*/

public Boolean exists(String key);

/**
* 返回key所储存的值的类型
*
* @param key key
* @return String
*/

public String type(String key);

/**
* 为给定key设置生存时间。单位秒 当key过期时,它会被自动删除。
*
* @param key key
* @param seconds seconds
* @return Long
*/

public Long expire(String key, int seconds);

/**
* 以UNIX时间戳为key设置生存时间。 EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。
*
* @param key key
* @param unixTime unixTime
* @return Long
*/

public Long expireAt(String key, long unixTime);

/**
* 返回给定key的剩余生存时间(time to live)(以秒为单位)。
*
* @param key key
* @return Long
*/

public Long ttl(String key);

/**
* 用value参数覆写(Overwrite)给定key所储存的字符串值,从偏移量offset开始。 不存在的key当作空白字符串处理。
*
* @param key key
* @param offset offset
* @param value value
* @return long
*/

public long setrange(String key, long offset, String value);

/**
* 返回key中字符串值的子字符串,字符串的截取范围由startOffset和endOffset两个偏移量决定(包括startOffset和endOffset在内)。
*
* @param key key
* @param startOffset startOffset
* @param endOffset endOffset
* @return 子字符串
*/

public String getrange(String key, long startOffset, long endOffset);

/**
* 将给定key的值设为value,并返回key的旧值。 当key存在但不是字符串类型时,返回一个错误。
*
* @param key key
* @param value value
* @return value
*/

public String getSet(String key, String value);

/**
* 设置过期时间
* @param key key
* @param value value
* @return Long
*/

public Long setnx(String key, String value);

/**
* 将值value关联到key,并将key的生存时间设为seconds(以秒为单位)。 如果key 已经存在,SETEX命令将覆写旧值。
*
* @param key key
* @param seconds seconds
* @param value value
* @return
*/

public String setex(String key, int seconds, String value);

/**
* 将key所储存的值减去减量integer。 如果key不存在,以0为key的初始值,然后执行DECRBY操作。 如果值包含错误的类型,或字符串类型的值不能表示为数字,那么返回一个错误。
* 本操作的值限制在64位(bit)有符号数字表示之内。
*
* @param key key
* @param integer integer
* @return
*/

public Long decrBy(String key, long integer);

/**
* 将key中储存的数字值减一。 如果key不存在,以0为key的初始值,然后执行DECR操作。 如果值包含错误的类型,或字符串类型的值不能表示为数字,那么返回一个错误。
*
* @param key key
* @return
*/

public Long decr(String key);

/**
* 将key所储存的值加上增量increment。 如果key不存在,以0为key的初始值,然后执行INCRBY命令。 如果值包含错误的类型,或字符串类型的值不能表示为数字,那么返回一个错误
*
* @param key key
* @param integer integer
* @return
*/

public Long incrBy(String key, long integer);

/**
* 将key中储存的数字值增一。 如果key不存在,以0为key的初始值,然后执行INCR操作。 如果值包含错误的类型,或字符串类型的值不能表示为数字,那么返回一个错误。
*
* @param key key
* @return Long
*/

public Long incr(String key);

/**
* 如果key已经存在并且是一个字符串,APPEND命令将value追加到key原来的值之后。 如果key不存在,APPEND就简单地将给定key设为value,就像执行SET key value一样。
*
* @param key key
* @param value value
* @return
*/

public Long append(String key, String value);

/**
* 截取子串
* @param key key
* @param start start
* @param end end
* @return 子串
*/

public String substr(String key, int start, int end);

/**
* 将哈希表key中的域field的值设为value。 如果key不存在,一个新的哈希表被创建并进行HSET操作。 如果域field已经存在于哈希表中,旧值将被覆盖。
*
* @param key key
* @param field field
* @param value value
* @return
*/

public Long hset(String key, String field, String value);

/**
* 返回哈希表key中给定域field的值。
*
* @param key key
* @param field field
* @return
*/

public String hget(String key, String field);

/**
* 将哈希表key中的域field的值设置为value,当且仅当域field不存在。 若域field已经存在,该操作无效。 如果key不存在,一个新哈希表被创建并执行HSETNX命令。
*
* @param key key
* @param field field
* @param value value
* @return value
*/

public Long hsetnx(String key, String field, String value);

/**
* 同时将多个field - value(域-值)对设置到哈希表key中。 此命令会覆盖哈希表中已存在的域。
*
* @param key key
* @param hash hash
* @return
*/

public String hmset(String key, Map<String, String> hash);

/**
* 返回哈希表key中,一个或多个给定域的值。
*
* @param key key
* @param fields fields
* @return
*/

public List<String> hmget(String key, String... fields);

/**
* hincrBy
* @param key key
* @param field field
* @param value value
* @return Long
*/

public Long hincrBy(String key, String field, long value);

/**
* 为哈希表key中的域field的值加上增量increment。 增量也可以为负数,相当于对给定域进行减法操作。 如果key不存在,一个新的哈希表被创建并执行HINCRBY命令。
* 如果域field不存在,那么在执行命令前,域的值被初始化为0。
*
* @param key key
* @param field field
* @return 是否
*/

public Boolean hexists(String key, String field);

/**
* 移除给定的一个或多个key。 如果key不存在,则忽略该命令。
*
* @param key key
* @return Long
*/

public Long del(String key);

/**
* 删除哈希表key中的一个指定域,不存在的域将被忽略
*
* @param key key
* @param field field
* @return Long
*/

public Long hdel(String key, String field);

/**
* 返回哈希表key中域的数量。
*
* @param key key
* @return Long
*/

public Long hlen(String key);

/**
* 返回哈希表key中的所有域
*
* @param key key
* @return Set
*/

public Set<String> hkeys(String key);

/**
* 返回哈希表key中的所有值。
*
* @param key key
* @return List
*/

public List<String> hvals(String key);

/**
* 返回哈希表key中,所有的域和值。 在返回值里,紧跟每个域名(field name)之后是域的值(value),所以返回值的长度是哈希表大小的两倍。
*
* @param key key
* @return Map
*/

public Map<String, String> hgetAll(String key);

/**
* 将一个值value插入到列表key的表尾。
*
* @param key key
* @param string string
* @return Long
*/

public Long rpush(String key, String string);

/**
* 将一个值value插入到列表key的表头。
*
* @param key key
* @param string string
* @return Long
*/

public Long lpush(String key, String string);

/**
* 返回列表key的长度。 如果key不存在,则key被解释为一个空列表,返回0. 如果key不是列表类型,返回一个错误。
*
* @param key key
* @return Long
*/

public Long llen(String key);

/**
* 返回列表key中指定区间内的元素,区间以偏移量start和end指定。 下标(index)参数start和end都以0为底,也就是说,以0表示列表的第一个元素,以1表示列表的第二个元素,以此类推。
* 你也可以使用负数下标,以-1表示列表的最后一个元素,-2表示列表的倒数第二个元素,以此类推。
*
* @param key key
* @param start start
* @param end end
* @return List
*/

public List<String> lrange(String key, long start, long end);

/**
* 对一个列表进行修剪(trim),就是说,让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除。
*
* @param key key
* @param start start
* @param end end
* @return String
*/

public String ltrim(String key, long start, long end);

/**
* 返回列表key中,下标为index的元素。
*
* @param key key
* @param index index
* @return String
*/

public String lindex(String key, long index);

/**
* 将列表key下标为index的元素的值设置为value。 当index参数超出范围,或对一个空列表(key不存在)进行LSET时,返回一个错误。
*
* @param key key
* @param index index
* @param value value
* @return String
*/

public String lset(String key, long index, String value);

/**
* 根据参数count的值,移除列表中与参数value相等的元素。
* <P>
* count的值可以是以下几种:
* <P>
* count > 0: 从表头开始向表尾搜索,移除与value相等的元素,数量为count。
* <P>
* count < 0: 从表尾开始向表头搜索,移除与value相等的元素,数量为count的绝对值。
* <P>
* count = 0: 移除表中所有与value相等的值。
*
* @param key key
* @param start start
* @param end end
* @return Long
*/

public Long lrem(String key, long count, String value);

/**
* 移除并返回列表key的头元素。
*
* @param key key
* @return String
*/

public String lpop(String key);

/**
* 移除并返回列表key的尾元素。
*
* @param key key
* @return String
*/

public String rpop(String key);

/**
* 将一个或多个member元素加入到集合key当中,已经存在于集合的member元素将被忽略。 假如key不存在,则创建一个只包含member元素作成员的集合。
*
* @param key key
* @param member member
* @return Long
*/

public Long sadd(String key, String member);

/**
* 返回集合key中的所有成员。
*
* @param key key
* @return Set
*/

public Set<String> smembers(String key);

/**
* 移除集合key中的一个或多个member元素,不存在的member元素会被忽略。 当key不是集合类型,返回一个错误。
*
* @param key key
* @param member member
* @return Long
*/

public Long srem(String key, String member);

/**
* 移除并返回集合中的一个随机元素。
*
* @param key key
* @return String
*/

public String spop(String key);

/**
* 返回集合key的基数(集合中元素的数量)。
*
* @param key key
* @return Long
*/

public Long scard(String key);

/**
* 判断member元素是否是集合key的成员。
*
* @param key key
* @param member member
* @return 是否
*/

public Boolean sismember(String key, String member);

/**
* 返回集合中的一个随机元素。
*
* @param key key
* @return String
*/

public String srandmember(String key);

/**
* 将一个member元素及其score值加入到有序集key当中。
*
* @param key key
* @param score score
* @param member member
* @return Long
*/

public Long zadd(String key, double score, String member);

/**
* 返回有序集key中,指定区间内的成员。 其中成员的位置按score值递增(从小到大)来排序。
*
* @param key key
* @param start start
* @param end end
* @return Set
*/

public Set<String> zrange(String key, int start, int end);

/**
* 移除有序集key中的一个或多个成员,不存在的成员将被忽略。 当key存在但不是有序集类型时,返回一个错误。
*
* @param key key
* @param member member
* @return Long
*/

public Long zrem(String key, String member);

/**
* 为有序集key的成员member的score值加上增量increment。
*
* @param key key
* @param score score
* @param member member
* @return Double
*/

public Double zincrby(String key, double score, String member);

/**
* 返回有序集key中成员member的排名。其中有序集成员按score值递增(从小到大)顺序排列。 排名以0为底,也就是说,score值最小的成员排名为0。
*
* @param key key
* @param member member
* @return Long
*/

public Long zrank(String key, String member);

/**
* 返回有序集key中成员member的排名。其中有序集成员按score值递减(从大到小)排序。 排名以0为底,也就是说,score值最大的成员排名为0。
*
* @param key key
* @param member member
* @return Long
*/

public Long zrevrank(String key, String member);

/**
* 返回有序集key中,指定区间内的成员。 其中成员的位置按score值递减(从大到小)来排列。
*
* @param key key
* @param start
* @param end
* @return
*/

public Set<String> zrevrange(String key, int start, int end);

/**
* 返回有序集key的基数。
*
* @param key
* @return
*/

public Long zcard(String key);

/**
* 返回有序集key中,成员member的score值。 如果member元素不是有序集key的成员,或key不存在,返回null。
*
* @param key
* @param member
* @return
*/

public Double zscore(String key, String member);

/**
* 排序
* @param key
* @return
*/

public List<String> sort(String key);

/**
* 返回有序集key中,score值在min和max之间(默认包括score值等于min或max)的成员。
*
* @param key
* @param min
* @param max
* @return
*/

public Long zcount(String key, double min, double max);

public Set<String> zrangeByScore(String key, double min, double max);

/**
* 返回有序集key中,score值介于max和min之间(默认包括等于max或min)的所有的成员。有序集成员按score值递减(从大到小)的次序排列
*
* @param key
* @param max
* @param min
* @return
*/

public Set<String> zrevrangeByScore(String key, double max, double min);

/**
* 返回有序集key中,所有score值介于min和max之间(包括等于min或max)的成员。有序集成员按score值递增(从小到大)次序排列。 具有相同score值的成员按字典序(lexicographical
* order)来排列(该属性是有序集提供的,不需要额外的计算)。
*
* @param key
* @param min
* @param max
* @param offset
* @param count
* @return
*/

public Set<String> zrangeByScore(String key, double min, double max, int offset, int count);

/**
* zrevrangeByScore
* @param key key
* @param max max
* @param min min
* @param offset offset
* @param count count
* @return Set
*/

public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count);

/**
* zremrangeByRank
* @param key key
* @param start start
* @param end end
* @return Long
*/

public Long zremrangeByRank(String key, int start, int end);

/**
* zremrangeByScore
* @param key key
* @param start start
* @param end end
* @return zremrangeByScore
*/

public Long zremrangeByScore(String key, double start, double end);
}

ShardedRedisProxy接口的实现类

package com.kang.common.cache;  

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**
*
* 本实现为分片Redis缓存服务代理
*
* @author eko
*/

public class ShardedRedisProxy implements IRedisProxy {

/**
* 日志
*/

protected Log log = LogFactory.getLog(this.getClass());

/**
* 缓存连接池
*/

private ShardedJedisPool shardedJedisPool;

public Long append(String key, String value) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.append(key, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}

public Long decr(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.decr(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}

public Long decrBy(String key, long integer) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.decrBy(key, integer);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}

public Long del(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.del(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Boolean exists(String key) {
ShardedJedis shardedJedis = null;
Boolean ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.exists(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long expire(String key, int seconds) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.expire(key, seconds);
return ret;
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long expireAt(String key, long unixTime) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.expireAt(key, unixTime);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String get(String key) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.get(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String getSet(String key, String value) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.getSet(key, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String getrange(String key, long startOffset, long endOffset) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.getrange(key, startOffset, endOffset);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long hdel(String key, String field) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hdel(key, field);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Boolean hexists(String key, String field) {
ShardedJedis shardedJedis = null;
Boolean ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hexists(key, field);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String hget(String key, String field) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hget(key, field);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Map<String, String> hgetAll(String key) {
ShardedJedis shardedJedis = null;
Map<String, String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hgetAll(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long hincrBy(String key, String field, long value) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hincrBy(key, field, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> hkeys(String key) {
ShardedJedis shardedJedis = null;
Set<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hkeys(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long hlen(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hlen(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public List<String> hmget(String key, String... fields) {
ShardedJedis shardedJedis = null;
List<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hmget(key, fields);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String hmset(String key, Map<String, String> hash) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hmset(key, hash);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long hset(String key, String field, String value) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hset(key, field, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long hsetnx(String key, String field, String value) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hsetnx(key, field, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public List<String> hvals(String key) {
ShardedJedis shardedJedis = null;
List<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.hvals(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long incr(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.incr(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long incrBy(String key, long integer) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.incrBy(key, integer);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String lindex(String key, long index) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.lindex(key, index);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long llen(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.llen(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String lpop(String key) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.lpop(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long lpush(String key, String string) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.lpush(key, string);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public List<String> lrange(String key, long start, long end) {
ShardedJedis shardedJedis = null;
List<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.lrange(key, start, end);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long lrem(String key, long count, String value) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.lrem(key, count, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String lset(String key, long index, String value) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.lset(key, index, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String ltrim(String key, long start, long end) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.ltrim(key, start, end);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String rpop(String key) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.rpop(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long rpush(String key, String string) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.rpush(key, string);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long sadd(String key, String member) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.sadd(key, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long scard(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.scard(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String set(String key, String value) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.set(key, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String setex(String key, int seconds, String value) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.setex(key, seconds, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long setnx(String key, String value) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.setnx(key, value);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public long setrange(String key, long offset, String value) {
ShardedJedis shardedJedis = null;
long ret = 0;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.setrange(key, offset, value);
return ret;
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Boolean sismember(String key, String member) {
ShardedJedis shardedJedis = null;
Boolean ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.sismember(key, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> smembers(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = shardedJedisPool.getResource();
Set<String> ret = shardedJedis.smembers(key);
return ret;
} catch (Exception e) {
log.error(this, e);
return null;
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
}


public List<String> sort(String key) {
ShardedJedis shardedJedis = null;
List<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.sort(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String spop(String key) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.spop(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String srandmember(String key) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.srandmember(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long srem(String key, String member) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.srem(key, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String substr(String key, int start, int end) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.substr(key, start, end);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long ttl(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.ttl(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public String type(String key) {
ShardedJedis shardedJedis = null;
String ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.type(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zadd(String key, double score, String member) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zadd(key, score, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zcard(String key) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zcard(key);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zcount(String key, double min, double max) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zcount(key, min, max);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Double zincrby(String key, double score, String member) {
ShardedJedis shardedJedis = null;
Double ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zincrby(key, score, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> zrange(String key, int start, int end) {
ShardedJedis shardedJedis = null;
Set<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrange(key, start, end);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> zrangeByScore(String key, double min, double max) {
ShardedJedis shardedJedis = null;
Set<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrangeByScore(key, min, max);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> zrangeByScore(String key, double min, double max,
int offset, int count) {
ShardedJedis shardedJedis = null;
Set<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrangeByScore(key, min, max, offset, count);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zrank(String key, String member) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrank(key, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zrem(String key, String member) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrem(key, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zremrangeByRank(String key, int start, int end) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zremrangeByRank(key, start, end);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zremrangeByScore(String key, double start, double end) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zremrangeByScore(key, start, end);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> zrevrange(String key, int start, int end) {
ShardedJedis shardedJedis = null;
Set<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrevrange(key, start, end);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> zrevrangeByScore(String key, double max, double min) {
ShardedJedis shardedJedis = null;
Set<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrevrangeByScore(key, max, min);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Set<String> zrevrangeByScore(String key, double max, double min,
int offset, int count) {
ShardedJedis shardedJedis = null;
Set<String> ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrevrangeByScore(key, max, min, offset, count);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Long zrevrank(String key, String member) {
ShardedJedis shardedJedis = null;
Long ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zrevrank(key, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}


public Double zscore(String key, String member) {
ShardedJedis shardedJedis = null;
Double ret = null;
try {
shardedJedis = shardedJedisPool.getResource();
ret = shardedJedis.zscore(key, member);
} catch (Exception e) {
log.error(this, e);
} finally {
shardedJedisPool.returnResource(shardedJedis);
}
return ret;
}

/**
* @return the shardedJedisPool
*/

public ShardedJedisPool getShardedJedisPool() {
return shardedJedisPool;
}

/**
* @param shardedJedisPool
* the shardedJedisPool to set
*/

public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {
this.shardedJedisPool = shardedJedisPool;
}

}

CacheProxy继承接口IRedisProxy

package com.kang.common.cache;  

/**
* 缓存代理
*/

public class CacheProxy extends ShardedRedisProxy{
//TODO 继承ShardedRedisProxy缓存代理的方法
...
}

这样我们就可以实现接口的封装。使用封装接口的好处就是ShardedJedisPool缓存池执行的时候如果出现一些问题,抛出一些bug,即使不使用try catch将错误抛出,也不会出现莫名其妙的问题。