Jedis学习使用（java操作redis）

Jedis 是 Redis 官方首选的 Java client开发包。

工作过程总结的一个演示样例。贴出来，例如以下：

package com.wujintao.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;
import com.wujintao.redis.util.RedisUtil;
public class TestCase {
/**
* 在不同的线程中使用同样的Jedis实例会发生奇怪的错误。

可是创建太多的实现也不好由于这意味着会建立非常多sokcet连接。
* 也会导致奇怪的发生错误。

单一Jedis实例不是线程安全的。为了避免这些问题，能够使用JedisPool,
* JedisPool是一个线程安全的网络连接池。

能够用JedisPool创建一些可靠Jedis实例，能够从池中拿到Jedis的实例。
* 这样的方式能够解决那些问题而且会实现高效的性能
*/
public static void main(String[] args) {
// ...when closing your application:
RedisUtil.getPool().destroy();
}
public static void Hello() {
Jedis jedis = RedisUtil.getJedis();
try {
// 向key-->name中放入了value-->minxr
jedis.set("name", "minxr");
String ss = jedis.get("name");
System.out.println(ss);
// 非常直观。类似map 将jintao append到已经有的value之后
jedis.append("name", "jintao");
ss = jedis.get("name");
System.out.println(ss);
// 2、直接覆盖原来的数据
jedis.set("name", "jintao");
System.out.println(jedis.get("jintao"));
// 删除key相应的记录
jedis.del("name");
System.out.println(jedis.get("name"));// 运行结果：null
/**
* mset相当于 jedis.set("name","minxr"); jedis.set("jarorwar","aaa");
*/
jedis.mset("name", "minxr", "jarorwar", "aaa");
System.out.println(jedis.mget("name", "jarorwar"));
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool().returnResource(jedis);
}
}
private void testKey() {
Jedis jedis = RedisUtil.getJedis();
System.out.println("=============key==========================");
// 清空数据
System.out.println(jedis.flushDB());
System.out.println(jedis.echo("foo"));
// 推断key否存在
System.out.println(jedis.exists("foo"));
jedis.set("key", "values");
System.out.println(jedis.exists("key"));
}
public static void testString() {
System.out.println("==String==");
Jedis jedis = RedisUtil.getJedis();
try {
// String
jedis.set("key", "Hello World!");
String value = jedis.get("key");
System.out.println(value);
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool().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");
System.out.println(jedis.get("foo"));
// 覆盖数据
jedis.set("foo", "foo update");
System.out.println(jedis.get("foo"));
// 追加数据
jedis.append("foo", " hello, world");
System.out.println(jedis.get("foo"));
// 设置key的有效期，并存储数据
, "foo not exits");
System.out.println(jedis.get("foo"));
try {
);
} catch (InterruptedException e) {
}
System.out.println(jedis.get("foo"));
// 获取并更改数据
jedis.set("foo", "foo update");
System.out.println(jedis.getSet("foo", "foo modify"));
// 截取value的值
, 3));
System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2",
"mset3", "mvalue3", "mset4", "mvalue4"));
System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4"));
System.out.println(jedis.del(new String[] { "foo", "foo1", "foo3" }));
}
public static void testList() {
System.out.println("==List==");
Jedis jedis = RedisUtil.getJedis();
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表示取得全部
, -1);
System.out.println(values);
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool().returnResource(jedis);
}
// 清空数据
System.out.println(jedis.flushDB());
// 加入数据
jedis.lpush("lists", "vector");
jedis.lpush("lists", "ArrayList");
jedis.lpush("lists", "LinkedList");
// 数组长度
System.out.println(jedis.llen("lists"));
// 排序
System.out.println(jedis.sort("lists"));
// 字串
, 3));
// 改动列表中单个值
, "hello list!");
// 获取列表指定下标的值
));
// 删除列表指定下标的值
, "vector"));
// 删除区间以外的数据
, 1));
// 列表出栈
System.out.println(jedis.lpop("lists"));
// 整个列表值
, -1));
}
public static void testSet() {
System.out.println("==Set==");
Jedis jedis = RedisUtil.getJedis();
try {
jedis.sadd("myset", "1");
jedis.sadd("myset", "2");
jedis.sadd("myset", "3");
jedis.sadd("myset", "4");
Set<String> setValues = jedis.smembers("myset");
System.out.println(setValues);
// 移除noname
jedis.srem("myset", "4");
System.out.println(jedis.smembers("myset"));// 获取全部增加的value
System.out.println(jedis.sismember("myset", "4"));// 推断 minxr
// 是否是sname集合的元素
System.out.println(jedis.scard("sname"));// 返回集合的元素个数
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool().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"));
;
// 整个列表值
System.out.println(jedis.smembers("sets"));
// 删除指定元素
System.out.println(jedis.srem("sets", "SortedSet"));
// 出栈
System.out.println(jedis.spop("sets"));
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"));
// 并集
System.out.println(jedis.sunion("sets1", "sets2"));
// 差集
System.out.println(jedis.sdiff("sets1", "sets2"));
}
public static void sortedSet() {
System.out.println("==SoretedSet==");
Jedis jedis = RedisUtil.getJedis();
try {
, "Alan Kay");
, "Richard Stallman");
, "Yukihiro Matsumoto");
, "Claude Shannon");
, "Linus Torvalds");
, "Alan Turing");
, -1);
System.out.println(setValues);
, -1);
System.out.println(setValues2);
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool().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"));
// 元素下标
System.out.println(jedis.zscore("zset", "zset"));
// 集合子集
, -1));
// 删除元素
System.out.println(jedis.zrem("zset", "zset!"));
System.out.println(jedis.zcount("zset", 9.5, 10.5));
// 整个集合值
, -1));
}
public static void testHsh() {
System.out.println("==Hash==");
Jedis jedis = RedisUtil.getJedis();
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));
}
, -1);
values = jedis.hmget("kid", new String[] { "name", "age", "sex" });
System.out.println(values);
, -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().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"));
}
public static void testOther() throws InterruptedException {
Jedis jedis = RedisUtil.getJedis();
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则表示永远有效
, "min");// 通过此方法，能够指定key的存活（有效时间）时间为秒
);// 睡眠5秒后，剩余时间将为<=5
System.out.println(jedis.ttl("timekey")); // 输出结果为5
, "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");
, -1));// [9, 3, 6, 1]
System.out.println(jedis.sort("a")); // [1, 3, 6, 9] //输入排序后结果
, -1));
} catch (Exception e) {
e.printStackTrace();
} finally {
RedisUtil.getPool().returnResource(jedis);
}
}
@org.junit.Test
public void testUnUsePipeline() {
long start = new Date().getTime();
Jedis jedis = RedisUtil.getJedis();
; 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().returnResource(jedis);
}
@org.junit.Test
/**
* 參考:http://blog.csdn.net/freebird_lb/article/details/7778919
*/
public void testUsePipeline() {
long start = new Date().getTime();
Jedis jedis = RedisUtil.getJedis();
jedis.flushDB();
Pipeline p = jedis.pipelined();
; 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().returnResource(jedis);
}
@org.junit.Test
/**
* 时间复杂度：
O(N+M*log(M))。 N 为要排序的列表或集合内的元素数量， M 为要返回的元素数量。
假设仅仅是使用 SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。
*/
public void testSort1() {
// 排序默认以数字作为对象。值被解释为双精度浮点数，然后进行比較
Jedis redis = RedisUtil.getJedis();
// 一般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)进行排序。
, 2);// 可用于分页查询
List<String> list = redis.sort("mylist", sortingParameters);// 默认是升序
; i < list.size(); i++) {
System.out.println(list.get(i));
}
redis.flushDB();
RedisUtil.closeJedis(redis);
}
@org.junit.Test
/**
* sort list
* LIST结合hash的排序
*/
public void testSort2() {
Jedis jedis = RedisUtil.getJedis();
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);
}
/**
* 相应的redisclient命令是：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();
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 跳过排序操作。
* 该方法用于你希望获取外部对象而又不希望引起排序开销时使用。 # 确保fake_key不存在 redis> EXISTS fake_key
* (integer) 0 # 以fake_key作BY參数。不排序，仅仅GET name 和 GET password redis> SORT
* user_id BY fake_key GET # GET user_name_* GET user_password_* 1) "222" #
* id 2) "hacker" # user_name 3) "hey,im in" # password 4) "59230" 5) "jack"
* 6) "jack201022" 7) "2" 8) "huangz" 9) "nobodyknows" 10) "1" 11) "admin"
* 12) "a_long_long_password"
*/
public void testSort4() {
}
/**
*
保存排序结果默认情况下， SORT 操作仅仅是简单地返回排序结果，假设你希望保存排序结果，能够给 STORE 选项指定一个 key
* 作为參数。排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在，则覆盖。) redis> EXISTS
* user_info_sorted_by_level # 确保指定key不存在 (integer) 0 redis> SORT user_id BY
* user_level_* GET # GET user_name_* GET user_password_* STORE
* user_info_sorted_by_level # 排序 (integer) 12 # 显示有12条结果被保存了 redis> LRANGE
* user_info_sorted_by_level 0 11 # 查看排序结果 1) "59230" 2) "jack" 3)
* "jack201022" 4) "2" 5) "huangz" 6) "nobodyknows" 7) "222" 8) "hacker" 9)
* "hey,im in" 10) "1" 11) "admin" 12) "a_long_long_password" 一个有趣的使用方法是将 SORT
* 结果保存。用 EXPIRE 为结果集设置生存时间。这样结果集就成了 SORT 操作的一个缓存。

这样就不必频繁地调用 SORT
* 操作了，仅仅有当结果集过期时，才须要再调用一次 SORT 操作。
* 有时候为了正确实现这一使用方法。你可能须要加锁以避免多个client同一时候进行缓存重建(也就是多个client，同一时间进行 SORT
* 操作，并保存为结果集)，详细參见 SETNX 命令。
*/
@Test
public void testSort5() {
// 排序默认以数字作为对象。值被解释为双精度浮点数。然后进行比較
Jedis jedis = RedisUtil.getJedis();
// 一般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
, -1);
; 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");
, -1);
for (String item : result) {
System.out.println("item..." + item);
}
jedis.flushDB();
RedisUtil.closeJedis(jedis);
}
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();
) ;
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();
));// 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();
jedis.flushDB();// 删除当前数据库中全部key,此方法不会失败。慎用
jedis.rpush("ids", "aa");
jedis.rpush("ids", "bb");
jedis.rpush("ids", "cc");
, -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() {
;
;
Jedis jedis = RedisUtil.getJedis();
jedis.del("a");
; i <= 30; i++) {
jedis.rpush("a", i + "");
}
);// 由于redis中list元素位置基数是0
;
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，非常easy得到一个独一无二的自增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();
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");
, -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
* 1000被加了三个标签tag 1,2,5和77，就能够设置以下两个集合： $ redis-cli sadd news:1000:tags 1
* (integer) 1 $ redis-cli sadd news:1000:tags 2 (integer) 1 $ redis-cli
* sadd news:1000:tags 5 (integer) 1 $ redis-cli sadd news:1000:tags 77
* (integer) 1 $ redis-cli sadd tag:1:objects 1000 (integer) 1 $ redis-cli
* sadd tag:2:objects 1000 (integer) 1 $ redis-cli sadd tag:5:objects 1000
* (integer) 1 $ redis-cli sadd tag:77:objects 1000 (integer) 1
* 要获取一个对象的全部标签，如此简单： $ redis-cli smembers news:1000:tags 1. 5 2. 1 3. 77 4.
* 2 而有些看上去并不简单的操作仍然能使用对应的Redis命令轻松实现。

比如我们或许想获得一份同一时候拥有标签1, 2,
* 10和27的对象列表。这能够用SINTER命令来做，他能够在不同集合之间取出交集。因此为达目的我们仅仅需： $ redis-cli sinter
* tag:1:objects tag:2:objects tag:10:objects tag:27:objects ... no result
* in our dataset composed of just one object ...
* 在命令參考文档中能够找到和集合相关的其它命令，令人感兴趣的一抓一大把。一定要留意SORT命令，Redis集合和list都是可排序的。
*/
@Test
public void testSetUsage() {
Jedis jedis = RedisUtil.getJedis();
jedis.sadd("zhongsou:news:1000:tags", "1");
jedis.sadd("zhongsou:news:1000:tags", "2");
jedis.sadd("zhongsou:news:1000:tags", "5");
jedis.sadd("zhongsou:news:1000:tags", "77");
jedis.sadd("zhongsou:news:2000:tags", "1");
jedis.sadd("zhongsou:news:2000:tags", "2");
jedis.sadd("zhongsou:news:2000:tags", "5");
jedis.sadd("zhongsou:news:2000:tags", "77");
jedis.sadd("zhongsou:news:3000:tags", "2");
jedis.sadd("zhongsou:news:4000:tags", "77");
jedis.sadd("zhongsou:news:5000:tags", "1");
jedis.sadd("zhongsou:news:6000:tags", "5");
+ "");
+ "");
+ "");
+ "");
+ "");
+ "");
+ "");
+ "");
Set<String> sets = jedis.sinter("zhongsou:tag:1:objects",
"zhongsou:tag:2:objects", "zhongsou:tag:5:objects",
"zhongsou:tag:77:objects");
System.out.println(sets);
jedis.flushAll();
}
@Test
public void testSortedSetUsage() {
Jedis jedis = RedisUtil.getJedis();
, "Alan Kay");
, "Richard Stallman");
, "Jay");
, "Jellon");
, "Yukihiro Matsumoto");
, "Claude Shannon");
, "Linus Torvalds");
, "Alan Turing");
, -1);
System.out.println(hackers);
, -1);
System.out.println(hackers2);
// 区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素（两个极值也包括了）。
Set<String> hackers3 = jedis.zrangeByScore("zhongsou:hackers", "-inf",
"1920");
System.out.println(hackers3);
// ZREMRANGEBYSCORE 这个名字尽管不算好。但他却很实用，还会返回已删除的元素数量。
long num = jedis.zremrangeByScore("zhongsou:hackers", "-inf", "1920");
System.out.println(num);
jedis.flushAll();
}
}

/**
* 获取连接池.
* @return 连接池实例
*/
private static JedisPool getPool(String ip,int port) {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(RedisConfig.getMaxactive());
config.setMaxIdle(RedisConfig.getMaxidle());
config.setMaxWait(RedisConfig.getMaxwait());
config.setTestOnBorrow(true);
config.setTestOnReturn(true);
try{
/**
*假设你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
*请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
*/
pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());
} catch(Exception e) {
e.printStackTrace();
}
return pool;
}

附加一个工作中经常使用到的Jedis工具类，例如以下：

package com.zhongsou.vertportal.util;
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;
import com.zhongsou.vertportal.conf.BaseConfig;
import com.zhongsou.vertportal.conf.RedisConfig;
/**
* Redis工具类,用于获取RedisPool.
* 參考官网说明例如以下：
* You shouldn't use the same instance from different threads because you'll have strange errors.
* And sometimes creating lots of Jedis instances is not good enough because it means lots of sockets and connections,
* which leads to strange errors as well. A single Jedis instance is not threadsafe!
* To avoid these problems, you should use JedisPool, which is a threadsafe pool of network connections.
* This way you can overcome those strange errors and achieve great performance.
* To use it, init a pool:
* JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
* You can store the pool somewhere statically, it is thread-safe.
* JedisPoolConfig includes a number of helpful Redis-specific connection pooling defaults.
* For example, Jedis with JedisPoolConfig will close a connection after 300 seconds if it has not been returned.
* @author wujintao
*/
public class JedisUtil {
protected Logger log = LoggerFactory.getLogger(getClass());
/**
* 私有构造器.
*/
private JedisUtil() {
}
private static Map<String,JedisPool> maps = new HashMap<String,JedisPool>();
/**
* 获取连接池.
* @return 连接池实例
*/
private static JedisPool getPool(String ip,int port) {
String key = ip+":" +port;
JedisPool pool = null;
if(!maps.containsKey(key)) {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxActive(RedisConfig.getMaxactive());
config.setMaxIdle(RedisConfig.getMaxidle());
config.setMaxWait(RedisConfig.getMaxwait());
config.setTestOnBorrow(true);
config.setTestOnReturn(true);
try{
/**
*假设你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
*请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
*/
pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());
maps.put(key, pool);
} catch(Exception e) {
e.printStackTrace();
}
}else{
pool = maps.get(key);
}
return pool;
}
/**
*类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
*没有绑定关系，并且仅仅有被调用到时才会装载，从而实现了延迟载入。
*/
private static class RedisUtilHolder{
/**
* 静态初始化器，由JVM来保证线程安全
*/
private static JedisUtil instance = new JedisUtil();
}
/**
*当getInstance方法第一次被调用的时候，它第一次读取
*RedisUtilHolder.instance，导致RedisUtilHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静
*态域，从而创建RedisUtil的实例，因为是静态的域，因此仅仅会在虚拟机装载类的时候初始化一次。并由虚拟机来保证它的线程安全性。
*这个模式的优势在于，getInstance方法并没有被同步，而且仅仅是运行一个域的訪问，因此延迟初始化并没有添加不论什么訪问成本。
*/
public static JedisUtil getInstance() {
return RedisUtilHolder.instance;
}
/**
* 获取Redis实例.
* @return Redis工具类实例
*/
public Jedis getJedis(String ip,int port) {
Jedis jedis = null;
;
do{
try{
jedis = getPool(ip,port).getResource();
//log.info("get redis master1!");
} catch (Exception e) {
log.error("get redis master1 failed!", e);
// 销毁对象
getPool(ip,port).returnBrokenResource(jedis);
}
count++;
}while(jedis==null&&count<BaseConfig.getRetryNum());
return jedis;
}
/**
* 释放redis实例到连接池.
* @param jedis redis实例
*/
public void closeJedis(Jedis jedis,String ip,int port) {
if(jedis != null) {
getPool(ip,port).returnResource(jedis);
}
}
}

开发參考资料：

redis官方文档：http://redis.io/documentation

redis命令參考中文版：http://redis.readthedocs.org/en/2.4/index.html

Jedis学习使用（java操作redis）的更多相关文章

Java操作Redis工具类
依赖 jar 包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis< ...
java操作redis之jedis篇
首先来简单介绍一下jedis,其实一句话就可以概括的,就是java操作redis的一种api.我们知道redis提供了基本上所有常用编程语言的clients,大家可以到http://redis.io/ ...
java操作redis学习（一）：安装及连接
文章参考自:http://www.cnblogs.com/edisonfeng/p/3571870.html,在此基础上进行了修改. 一.下载安装Redis redis官网显示暂时不支持Windows ...
java 操作redis
使用Java操作Redis需要jedis-2.1.0.jar,如果需要使用Redis连接池的话,还需commons-pool-1.5.4.jar package com.test; import ja ...
windows下Redis安装及利用java操作Redis
一.windows下Redis安装 1.Redis下载下载地址:https://github.com/MicrosoftArchive/redis 打开下载地址后,选择版本然后选择压缩包下载 R ...
java操作redis集群配置[可配置密码]和工具类（比较好用）
转: java操作redis集群配置[可配置密码]和工具类 java操作redis集群配置[可配置密码]和工具类 <dependency> <groupId>red ...
java操作redis集群配置[可配置密码]和工具类
java操作redis集群配置[可配置密码]和工具类 <dependency> <groupId>redis.clients</groupId> & ...
Linux+Redis实战教程_day02_3、redis数据类型_4、String命令_5、hash命令_6、java操作redis数据库技术
3. redis数据类型[重点] redis 使用的是键值对保存数据.(map) key:全部都是字符串 value:有五种数据类型 Key名:自定义,key名不要过长,否则影响使用效率 Key名不要 ...
Java操作redis【二十】
1.首先需要将redis的绑定地址为127.0.0.1去掉,同时将redis的保护模式去掉,并且开放6379端口. 如果是保护模式需要输入密码才能连接. (1)去掉绑定地址: (2)去掉保护模式: ( ...
使用Java操作Redis（一）
Redis是一款基于key-value的数据库服务器,安装完成后我们可以通过redis-cli使用Redis提供的命令完成各种操作.redis-cli实际上就是一款客户端,和redis-server建 ...

随机推荐

java读取配置文件的推荐方法getResource、getResourceAsStream
在java开发中经常会读取配置文件,如果把文件路径写死,就太LOW了,也不符合编码规范. 在网上找了一些资料后,发现有两种方法:xxx.class.getResource("") ...
API对接中经常会出现的签名获取，这只是某一种，仅供给有需要的人参考
要求: 1.对所有传入参数(含系统参数和接口参数)按照字段名的 ASCII 码从小到大排序(字典序)后,使用 URL 键值对的格式.(即 key1=value1&key2=value2…)拼接 ...
第二章：systemverilog声明的位置
1.package 定义及从package中导入定义(***) verilog中,对于变量.线网.task.function的声明必须在module和endmodule之间.如果task被多个modu ...
用tkinter写出you-get下载器界面，并用pyinstaller打包成exe文件
本文为原创文章,转载请标明出处一.you-get介绍 you-get是一个基于 python 3 的下载工具,使用 you-get 可以很轻松的下载到网络上的视频.图片及音乐.目前支持网易云音乐.A ...
vue项目中设置跨域
config->index.js 'use strict' // Template version: 1.3.1 // see http://vuejs-templates.github.io/ ...
我的java web之路（配置开发环境）
这个学期学习java web开发,当然不能只靠上机的时间来练习,于是,便在自己的电脑上安装一系列的软件... 1.JDK的安装.首先,下载Java JDK,可以到sun公司网站下载.一定要下载适合自己 ...
有关OEP脱壳
首先补充: OEP:(Original Entry Point),程序的入口点,软件加壳就是隐藏了OEP(或者用了假的OEP), 只要我们找到程序真正的OEP,就可以立刻脱壳. PUSHAD (压栈) ...
杭电 4004 The Frog's Games 青蛙跳水（二分法，贪心）
Description The annual Games in frogs' kingdom started again. The most famous game is the Ironfrog T ...
MySQL 慢查询优化
为什么查询速度会慢 1.慢是指一个查询的响应时间长.一个查询的过程: 客户端发送一条查询给服务器服务器端先检查查询缓存,如果命中了缓存,则立可返回存储在缓存中的结果.否则进入下一个阶段服务器端进行 ...
HDU1280前m大的数creat at 9:51,3.13,2016
前m大的数 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Subm ...

Jedis学习使用（java操作redis）

Jedis学习使用（java操作redis）的更多相关文章

随机推荐

热门专题