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将错误抛出，也不会出现莫名其妙的问题。