Jedis使用示例

時間 2019-12-10

標籤 jedis 使用示例简体版

原文原文鏈接

Jedis 是 Redis 官方首選的 Java 客戶端開發包。html

工做過程總結的一個示例，貼出來，以下：java

Java代碼 redis

package com.wujintao.redis; 數據庫
import java.util.Date; 數組
import java.util.HashMap; 緩存
import java.util.Iterator; 安全
import java.util.List; 網絡
import java.util.Map; app
import java.util.Set; dom
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);
// 二、直接覆蓋原來的數據
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的有效期，並存儲數據
jedis.setex("foo", 2, "foo not exits");
System.out.println(jedis.get("foo"));
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
}
System.out.println(jedis.get("foo"));
// 獲取並更改數據
jedis.set("foo", "foo update");
System.out.println(jedis.getSet("foo", "foo modify"));
// 截取value的值
System.out.println(jedis.getrange("foo", 1, 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表示取得全部
List<String> values = jedis.lrange("messages", 0, -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"));
// 字串
System.out.println(jedis.lrange("lists", 0, 3));
// 修改列表中單個值
jedis.lset("lists", 0, "hello list!");
// 獲取列表指定下標的值
System.out.println(jedis.lindex("lists", 1));
// 刪除列表指定下標的值
System.out.println(jedis.lrem("lists", 1, "vector"));
// 刪除區間之外的數據
System.out.println(jedis.ltrim("lists", 0, 1));
// 列表出棧
System.out.println(jedis.lpop("lists"));
// 整個列表值
System.out.println(jedis.lrange("lists", 0, -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 {
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);
System.out.println(setValues);
Set<String> setValues2 = jedis.zrevrange("hackers", 0, -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"));
// 集合子集
System.out.println(jedis.zrange("zset", 0, -1));
// 刪除元素
System.out.println(jedis.zrem("zset", "zset!"));
System.out.println(jedis.zcount("zset", 9.5, 10.5));
// 整個集合值
System.out.println(jedis.zrange("zset", 0, -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));
}
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().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則表示永遠有效
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().returnResource(jedis);
}
}
@org .junit.Test
public void testUnUsePipeline() {
long start = new Date().getTime();
Jedis jedis = RedisUtil.getJedis();
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().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();
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().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)進行排序。
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);
}
@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);
}
/**
* 對應的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();
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 操做。
* 有時候爲了正確實現這一用法，你可能須要加鎖以免多個客戶端同時進行緩存重建(也就是多個客戶端，同一時間進行 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
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);
}
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();
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();
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();
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();
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();
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
* 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");
jedis.sadd("zhongsou:tag:1:objects", 1000 + "");
jedis.sadd("zhongsou:tag:2:objects", 1000 + "");
jedis.sadd("zhongsou:tag:5:objects", 1000 + "");
jedis.sadd("zhongsou:tag:77:objects", 1000 + "");
jedis.sadd("zhongsou:tag:1:objects", 2000 + "");
jedis.sadd("zhongsou:tag:2:objects", 2000 + "");
jedis.sadd("zhongsou:tag:5:objects", 2000 + "");
jedis.sadd("zhongsou:tag:77:objects", 2000 + "");
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();
jedis.zadd("zhongsou:hackers", 1940, "Alan Kay");
jedis.zadd("zhongsou:hackers", 1953, "Richard Stallman");
jedis.zadd("zhongsou:hackers", 1943, "Jay");
jedis.zadd("zhongsou:hackers", 1920, "Jellon");
jedis.zadd("zhongsou:hackers", 1965, "Yukihiro Matsumoto");
jedis.zadd("zhongsou:hackers", 1916, "Claude Shannon");
jedis.zadd("zhongsou:hackers", 1969, "Linus Torvalds");
jedis.zadd("zhongsou:hackers", 1912, "Alan Turing");
Set<String> hackers = jedis.zrange("zhongsou:hackers", 0, -1);
System.out.println(hackers);
Set<String> hackers2 = jedis.zrevrange("zhongsou:hackers", 0, -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();
}
}

Java代碼

/**
* 獲取鏈接池.
* @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工具類，以下：

Java代碼

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;
int count =0;
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);
}
}
}