javaJedis使用示例

程式界小強發表於2016-05-15
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的有效期,並儲存資料  
        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();  
    }  
  
} 

附加一個工作中常用到的Jedis工具類,如下:

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);  
        }  
    }  
}  

開發參考資料:

redis官方文件:http://redis.io/documentation

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


相關文章