Java中如何使用Redis做緩存

基本功能測試

　　1、程序基本結構

　　

　　2、主要類

　　　　1）功能類

package com.redis;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.SortingParams;



public class RedisClient {

    private Jedis jedis;//非切片額客戶端連接
    private JedisPool jedisPool;//非切片連接池
    private ShardedJedis shardedJedis;//切片額客戶端連接
    private ShardedJedisPool shardedJedisPool;//切片連接池
    
    public RedisClient() 
    { 
        initialPool(); 
        initialShardedPool(); 
        shardedJedis = shardedJedisPool.getResource(); 
        jedis = jedisPool.getResource(); 
        
        
    } 
 
    /**
     * 初始化非切片池
     */
    private void initialPool() 
    { 
        // 池基本配置 
        JedisPoolConfig config = new JedisPoolConfig(); 
        config.setMaxActive(20); 
        config.setMaxIdle(5); 
        config.setMaxWait(1000l); 
        config.setTestOnBorrow(false); 
        
        jedisPool = new JedisPool(config,"127.0.0.1",6379);
    }
    
    /** 
     * 初始化切片池 
     */ 
    private void initialShardedPool() 
    { 
        // 池基本配置 
        JedisPoolConfig config = new JedisPoolConfig(); 
        config.setMaxActive(20); 
        config.setMaxIdle(5); 
        config.setMaxWait(1000l); 
        config.setTestOnBorrow(false); 
        // slave鏈接 
        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); 
        shards.add(new JedisShardInfo("127.0.0.1", 6379, "master")); 

        // 構造池 
        shardedJedisPool = new ShardedJedisPool(config, shards); 
    } 

    public void show() {     
        KeyOperate(); 
        StringOperate(); 
        ListOperate(); 
        SetOperate();
        SortedSetOperate();
        HashOperate(); 
        jedisPool.returnResource(jedis);
        shardedJedisPool.returnResource(shardedJedis);
    } 

      private void KeyOperate() {
         。。。
      }

      private void StringOperate() {
         。。。
      }

      private void ListOperate() {
         。。。
      }

      private void SetOperate() {
         。。。
      }

      private void SortedSetOperate() {
         。。。
      }
    
      private void HashOperate() {
         。。。
      }
}

　　　　2）測試類

package com.redis;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new RedisClient().show(); 
    }

}

　　3、各個功能函數

　　　　1）key功能

private void KeyOperate() 
    { 
        System.out.println("======================key=========================="); 
        // 清空數據 
        System.out.println("清空庫中所有數據："+jedis.flushDB());
        // 判斷key否存在 
        System.out.println("判斷key999鍵是否存在："+shardedJedis.exists("key999")); 
        System.out.println("新增key001,value001鍵值對："+shardedJedis.set("key001", "value001")); 
        System.out.println("判斷key001是否存在："+shardedJedis.exists("key001"));
        // 輸出系統中所有的key
        System.out.println("新增key002,value002鍵值對："+shardedJedis.set("key002", "value002"));
        System.out.println("系統中所有鍵如下：");
        Set<String> keys = jedis.keys("*"); 
        Iterator<String> it=keys.iterator() ;   
        while(it.hasNext()){   
            String key = it.next();   
            System.out.println(key);   
        }
        // 刪除某個key,若key不存在，則忽略該命令。
        System.out.println("系統中刪除key002: "+jedis.del("key002"));
        System.out.println("判斷key002是否存在："+shardedJedis.exists("key002"));
        // 設置 key001的過期時間
        System.out.println("設置 key001的過期時間為5秒:"+jedis.expire("key001", 5));
        try{ 
            Thread.sleep(2000); 
        } 
        catch (InterruptedException e){ 
        } 
        // 查看某個key的剩余生存時間,單位【秒】.永久生存或者不存在的都返回-1
        System.out.println("查看key001的剩余生存時間："+jedis.ttl("key001"));
        // 移除某個key的生存時間
        System.out.println("移除key001的生存時間："+jedis.persist("key001"));
        System.out.println("查看key001的剩余生存時間："+jedis.ttl("key001"));
        // 查看key所儲存的值的類型
        System.out.println("查看key所儲存的值的類型："+jedis.type("key001"));
        /*
         * 一些其他方法：1、修改鍵名：jedis.rename("key6", "key0");
         *             2、將當前db的key移動到給定的db當中：jedis.move("foo", 1)
         */
    } 

　　　　運行結果：

======================key==========================
清空庫中所有數據：OK
判斷key999鍵是否存在：false
新增key001,value001鍵值對：OK
判斷key001是否存在：true
新增key002,value002鍵值對：OK
系統中所有鍵如下：
key002
key001
系統中刪除key002: 1
判斷key002是否存在：false
設置 key001的過期時間為5秒:1
查看key001的剩余生存時間：3
移除key001的生存時間：1
查看key001的剩余生存時間：-1
查看key所儲存的值的類型：string

　　　　2）String功能

private void StringOperate() 
    {  
        System.out.println("======================String_1=========================="); 
        // 清空數據 
        System.out.println("清空庫中所有數據："+jedis.flushDB());
        
        System.out.println("=============增=============");
        jedis.set("key001","value001");
        jedis.set("key002","value002");
        jedis.set("key003","value003");
        System.out.println("已新增的3個鍵值對如下：");
        System.out.println(jedis.get("key001"));
        System.out.println(jedis.get("key002"));
        System.out.println(jedis.get("key003"));
        
        System.out.println("=============刪=============");  
        System.out.println("刪除key003鍵值對："+jedis.del("key003"));  
        System.out.println("獲取key003鍵對應的值："+jedis.get("key003"));
        
        System.out.println("=============改=============");
        //1、直接覆蓋原來的數據
        System.out.println("直接覆蓋key001原來的數據："+jedis.set("key001","value001-update"));
        System.out.println("獲取key001對應的新值："+jedis.get("key001"));
        //2、直接覆蓋原來的數據  
        System.out.println("在key002原來值后面追加："+jedis.append("key002","+appendString"));
        System.out.println("獲取key002對應的新值"+jedis.get("key002")); 
   
        System.out.println("=============增，刪，查（多個）=============");
        /** 
         * mset,mget同時新增，修改，查詢多個鍵值對 
         * 等價於：
         * jedis.set("name","ssss"); 
         * jedis.set("jarorwar","xxxx"); 
         */  
        System.out.println("一次性新增key201,key202,key203,key204及其對應值："+jedis.mset("key201","value201",
                        "key202","value202","key203","value203","key204","value204"));  
        System.out.println("一次性獲取key201,key202,key203,key204各自對應的值："+
                        jedis.mget("key201","key202","key203","key204"));
        System.out.println("一次性刪除key201,key202："+jedis.del(new String[]{"key201", "key202"}));
        System.out.println("一次性獲取key201,key202,key203,key204各自對應的值："+
                jedis.mget("key201","key202","key203","key204")); 
        System.out.println();
                
            
        //jedis具備的功能shardedJedis中也可直接使用，下面測試一些前面沒用過的方法
        System.out.println("======================String_2=========================="); 
        // 清空數據 
        System.out.println("清空庫中所有數據："+jedis.flushDB());       
       
        System.out.println("=============新增鍵值對時防止覆蓋原先值=============");
        System.out.println("原先key301不存在時，新增key301："+shardedJedis.setnx("key301", "value301"));
        System.out.println("原先key302不存在時，新增key302："+shardedJedis.setnx("key302", "value302"));
        System.out.println("當key302存在時，嘗試新增key302："+shardedJedis.setnx("key302", "value302_new"));
        System.out.println("獲取key301對應的值："+shardedJedis.get("key301"));
        System.out.println("獲取key302對應的值："+shardedJedis.get("key302"));
        
        System.out.println("=============超過有效期鍵值對被刪除=============");
        // 設置key的有效期，並存儲數據 
        System.out.println("新增key303，並指定過期時間為2秒"+shardedJedis.setex("key303", 2, "key303-2second")); 
        System.out.println("獲取key303對應的值："+shardedJedis.get("key303")); 
        try{ 
            Thread.sleep(3000); 
        } 
        catch (InterruptedException e){ 
        } 
        System.out.println("3秒之后，獲取key303對應的值："+shardedJedis.get("key303")); 
        
        System.out.println("=============獲取原值，更新為新值一步完成=============");
        System.out.println("key302原值："+shardedJedis.getSet("key302", "value302-after-getset"));
        System.out.println("key302新值："+shardedJedis.get("key302"));
        
        System.out.println("=============獲取子串=============");
        System.out.println("獲取key302對應值中的子串："+shardedJedis.getrange("key302", 5, 7));         
    } 

　　　　　　運行結果:

======================String_1==========================
清空庫中所有數據：OK
=============增=============
已新增的3個鍵值對如下：
value001
value002
value003
=============刪=============
刪除key003鍵值對：1
獲取key003鍵對應的值：null
=============改=============
直接覆蓋key001原來的數據：OK
獲取key001對應的新值：value001-update
在key002原來值后面追加：21
獲取key002對應的新值value002+appendString
=============增，刪，查（多個）=============
一次性新增key201,key202,key203,key204及其對應值：OK
一次性獲取key201,key202,key203,key204各自對應的值：[value201, value202, value203, value204]
一次性刪除key201,key202：2
一次性獲取key201,key202,key203,key204各自對應的值：[null, null, value203, value204]

======================String_2==========================
清空庫中所有數據：OK
=============新增鍵值對時防止覆蓋原先值=============
原先key301不存在時，新增key301：1
原先key302不存在時，新增key302：1
當key302存在時，嘗試新增key302：0
獲取key301對應的值：value301
獲取key302對應的值：value302
=============超過有效期鍵值對被刪除=============
新增key303，並指定過期時間為2秒OK
獲取key303對應的值：key303-2second
3秒之后，獲取key303對應的值：null
=============獲取原值，更新為新值一步完成=============
key302原值：value302
key302新值：value302-after-getset
=============獲取子串=============
獲取key302對應值中的子串：302

　　　　3）List功能

private void ListOperate() 
    { 
        System.out.println("======================list=========================="); 
        // 清空數據 
        System.out.println("清空庫中所有數據："+jedis.flushDB()); 

        System.out.println("=============增=============");
        shardedJedis.lpush("stringlists", "vector"); 
        shardedJedis.lpush("stringlists", "ArrayList"); 
        shardedJedis.lpush("stringlists", "vector");
        shardedJedis.lpush("stringlists", "vector");
        shardedJedis.lpush("stringlists", "LinkedList");
        shardedJedis.lpush("stringlists", "MapList");
        shardedJedis.lpush("stringlists", "SerialList");
        shardedJedis.lpush("stringlists", "HashList");
        shardedJedis.lpush("numberlists", "3");
        shardedJedis.lpush("numberlists", "1");
        shardedJedis.lpush("numberlists", "5");
        shardedJedis.lpush("numberlists", "2");
        System.out.println("所有元素-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
        System.out.println("所有元素-numberlists："+shardedJedis.lrange("numberlists", 0, -1));
        
        System.out.println("=============刪=============");
        // 刪除列表指定的值 ，第二個參數為刪除的個數（有重復時），后add進去的值先被刪，類似於出棧
        System.out.println("成功刪除指定元素個數-stringlists："+shardedJedis.lrem("stringlists", 2, "vector")); 
        System.out.println("刪除指定元素之后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
        // 刪除區間以外的數據 
        System.out.println("刪除下標0-3區間之外的元素："+shardedJedis.ltrim("stringlists", 0, 3));
        System.out.println("刪除指定區間之外元素后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
        // 列表元素出棧 
        System.out.println("出棧元素："+shardedJedis.lpop("stringlists")); 
        System.out.println("元素出棧后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
        
        System.out.println("=============改=============");
        // 修改列表中指定下標的值 
        shardedJedis.lset("stringlists", 0, "hello list!"); 
        System.out.println("下標為0的值修改后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));
        System.out.println("=============查=============");
        // 數組長度 
        System.out.println("長度-stringlists："+shardedJedis.llen("stringlists"));
        System.out.println("長度-numberlists："+shardedJedis.llen("numberlists"));
        // 排序 
        /*
         * list中存字符串時必須指定參數為alpha，如果不使用SortingParams，而是直接使用sort("list")，
         * 會出現"ERR One or more scores can't be converted into double"
         */
        SortingParams sortingParameters = new SortingParams();
        sortingParameters.alpha();
        sortingParameters.limit(0, 3);
        System.out.println("返回排序后的結果-stringlists："+shardedJedis.sort("stringlists",sortingParameters)); 
        System.out.println("返回排序后的結果-numberlists："+shardedJedis.sort("numberlists"));
        // 子串：  start為元素下標，end也為元素下標；-1代表倒數一個元素，-2代表倒數第二個元素
        System.out.println("子串-第二個開始到結束："+shardedJedis.lrange("stringlists", 1, -1));
        // 獲取列表指定下標的值 
        System.out.println("獲取下標為2的元素："+shardedJedis.lindex("stringlists", 2)+"\n");
    } 

　　　　　　運行結果:

======================list==========================
清空庫中所有數據：OK
=============增=============
所有元素-stringlists：[HashList, SerialList, MapList, LinkedList, vector, vector, ArrayList, vector]
所有元素-numberlists：[2, 5, 1, 3]
=============刪=============
成功刪除指定元素個數-stringlists：2
刪除指定元素之后-stringlists：[HashList, SerialList, MapList, LinkedList, ArrayList, vector]
刪除下標0-3區間之外的元素：OK
刪除指定區間之外元素后-stringlists：[HashList, SerialList, MapList, LinkedList]
出棧元素：HashList
元素出棧后-stringlists：[SerialList, MapList, LinkedList]
=============改=============
下標為0的值修改后-stringlists：[hello list!, MapList, LinkedList]
=============查=============
長度-stringlists：3
長度-numberlists：4
返回排序后的結果-stringlists：[LinkedList, MapList, hello list!]
返回排序后的結果-numberlists：[1, 2, 3, 5]
子串-第二個開始到結束：[MapList, LinkedList]
獲取下標為2的元素：LinkedList

　　　　4）Set功能

 private void SetOperate() 
    { 

        System.out.println("======================set=========================="); 
        // 清空數據 
        System.out.println("清空庫中所有數據："+jedis.flushDB());
        
        System.out.println("=============增=============");
        System.out.println("向sets集合中加入元素element001："+jedis.sadd("sets", "element001")); 
        System.out.println("向sets集合中加入元素element002："+jedis.sadd("sets", "element002")); 
        System.out.println("向sets集合中加入元素element003："+jedis.sadd("sets", "element003"));
        System.out.println("向sets集合中加入元素element004："+jedis.sadd("sets", "element004"));
        System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets")); 
        System.out.println();
        
        System.out.println("=============刪=============");
        System.out.println("集合sets中刪除元素element003："+jedis.srem("sets", "element003"));
        System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));
        /*System.out.println("sets集合中任意位置的元素出棧："+jedis.spop("sets"));//注：出棧元素位置居然不定？--無實際意義
        System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));*/
        System.out.println();
        
        System.out.println("=============改=============");
        System.out.println();
        
        System.out.println("=============查=============");
        System.out.println("判斷element001是否在集合sets中："+jedis.sismember("sets", "element001"));
        System.out.println("循環查詢獲取sets中的每個元素：");
        Set<String> set = jedis.smembers("sets");   
        Iterator<String> it=set.iterator() ;   
        while(it.hasNext()){   
            Object obj=it.next();   
            System.out.println(obj);   
        }  
        System.out.println();
        
        System.out.println("=============集合運算=============");
        System.out.println("sets1中添加元素element001："+jedis.sadd("sets1", "element001")); 
        System.out.println("sets1中添加元素element002："+jedis.sadd("sets1", "element002")); 
        System.out.println("sets1中添加元素element003："+jedis.sadd("sets1", "element003")); 
        System.out.println("sets1中添加元素element002："+jedis.sadd("sets2", "element002")); 
        System.out.println("sets1中添加元素element003："+jedis.sadd("sets2", "element003")); 
        System.out.println("sets1中添加元素element004："+jedis.sadd("sets2", "element004"));
        System.out.println("查看sets1集合中的所有元素:"+jedis.smembers("sets1"));
        System.out.println("查看sets2集合中的所有元素:"+jedis.smembers("sets2"));
        System.out.println("sets1和sets2交集："+jedis.sinter("sets1", "sets2"));
        System.out.println("sets1和sets2並集："+jedis.sunion("sets1", "sets2"));
        System.out.println("sets1和sets2差集："+jedis.sdiff("sets1", "sets2"));//差集：set1中有，set2中沒有的元素
        
    }

　　　　　　運行結果:

======================set==========================
清空庫中所有數據：OK
=============增=============
向sets集合中加入元素element001：1
向sets集合中加入元素element002：1
向sets集合中加入元素element003：1
向sets集合中加入元素element004：1
查看sets集合中的所有元素:[element001, element002, element003, element004]

=============刪=============
集合sets中刪除元素element003：1
查看sets集合中的所有元素:[element001, element002, element004]

=============改=============

=============查=============
判斷element001是否在集合sets中：true
循環查詢獲取sets中的每個元素：
element001
element002
element004

=============集合運算=============
sets1中添加元素element001：1
sets1中添加元素element002：1
sets1中添加元素element003：1
sets1中添加元素element002：1
sets1中添加元素element003：1
sets1中添加元素element004：1
查看sets1集合中的所有元素:[element001, element002, element003]
查看sets2集合中的所有元素:[element002, element003, element004]
sets1和sets2交集：[element002, element003]
sets1和sets2並集：[element001, element002, element003, element004]
sets1和sets2差集：[element001]

　　　　5）SortedSet功能（有序集合）

private void SortedSetOperate() 
    { 
        System.out.println("======================zset=========================="); 
        // 清空數據 
        System.out.println(jedis.flushDB()); 
        
        System.out.println("=============增=============");
        System.out.println("zset中添加元素element001："+shardedJedis.zadd("zset", 7.0, "element001")); 
        System.out.println("zset中添加元素element002："+shardedJedis.zadd("zset", 8.0, "element002")); 
        System.out.println("zset中添加元素element003："+shardedJedis.zadd("zset", 2.0, "element003")); 
        System.out.println("zset中添加元素element004："+shardedJedis.zadd("zset", 3.0, "element004"));
        System.out.println("zset集合中的所有元素："+shardedJedis.zrange("zset", 0, -1));//按照權重值排序
        System.out.println();
        
        System.out.println("=============刪=============");
        System.out.println("zset中刪除元素element002："+shardedJedis.zrem("zset", "element002"));
        System.out.println("zset集合中的所有元素："+shardedJedis.zrange("zset", 0, -1));
        System.out.println();
        
        System.out.println("=============改=============");
        System.out.println();
        
        System.out.println("=============查=============");
        System.out.println("統計zset集合中的元素中個數："+shardedJedis.zcard("zset"));
        System.out.println("統計zset集合中權重某個范圍內（1.0——5.0），元素的個數："+shardedJedis.zcount("zset", 1.0, 5.0));
        System.out.println("查看zset集合中element004的權重："+shardedJedis.zscore("zset", "element004"));
        System.out.println("查看下標1到2范圍內的元素值："+shardedJedis.zrange("zset", 1, 2));

    }

　　　　　　運行結果:

======================zset==========================
OK
=============增=============
zset中添加元素element001：1
zset中添加元素element002：1
zset中添加元素element003：1
zset中添加元素element004：1
zset集合中的所有元素：[element003, element004, element001, element002]

=============刪=============
zset中刪除元素element002：1
zset集合中的所有元素：[element003, element004, element001]

=============改=============

=============查=============
統計zset集合中的元素中個數：3
統計zset集合中權重某個范圍內（1.0——5.0），元素的個數：2
查看zset集合中element004的權重：3.0
查看下標1到2范圍內的元素值：[element004, element001]

　　　　6）Hash功能

private void HashOperate() 
    { 
        System.out.println("======================hash==========================");
        //清空數據 
        System.out.println(jedis.flushDB()); 
        
        System.out.println("=============增=============");
        System.out.println("hashs中添加key001和value001鍵值對："+shardedJedis.hset("hashs", "key001", "value001")); 
        System.out.println("hashs中添加key002和value002鍵值對："+shardedJedis.hset("hashs", "key002", "value002")); 
        System.out.println("hashs中添加key003和value003鍵值對："+shardedJedis.hset("hashs", "key003", "value003"));
        System.out.println("新增key004和4的整型鍵值對："+shardedJedis.hincrBy("hashs", "key004", 4l));
        System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));
        System.out.println();
        
        System.out.println("=============刪=============");
        System.out.println("hashs中刪除key002鍵值對："+shardedJedis.hdel("hashs", "key002"));
        System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));
        System.out.println();
        
        System.out.println("=============改=============");
        System.out.println("key004整型鍵值的值增加100："+shardedJedis.hincrBy("hashs", "key004", 100l));
        System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));
        System.out.println();
        
        System.out.println("=============查=============");
        System.out.println("判斷key003是否存在："+shardedJedis.hexists("hashs", "key003"));
        System.out.println("獲取key004對應的值："+shardedJedis.hget("hashs", "key004"));
        System.out.println("批量獲取key001和key003對應的值："+shardedJedis.hmget("hashs", "key001", "key003")); 
        System.out.println("獲取hashs中所有的key："+shardedJedis.hkeys("hashs"));
        System.out.println("獲取hashs中所有的value："+shardedJedis.hvals("hashs"));
        System.out.println();
              
    }

　　　　　　運行結果:

======================hash==========================
OK
=============增=============
hashs中添加key001和value001鍵值對：1
hashs中添加key002和value002鍵值對：1
hashs中添加key003和value003鍵值對：1
新增key004和4的整型鍵值對：4
hashs中的所有值：[value001, value002, value003, 4]

=============刪=============
hashs中刪除key002鍵值對：1
hashs中的所有值：[value001, value003, 4]

=============改=============
key004整型鍵值的值增加100：104
hashs中的所有值：[value001, value003, 104]

=============查=============
判斷key003是否存在：true
獲取key004對應的值：104
批量獲取key001和key003對應的值：[value001, value003]
獲取hashs中所有的key：[key004, key003, key001]
獲取hashs中所有的value：[value001, value003, 104]

三、常用命令
    1）連接操作命令
    quit：關閉連接（connection）
    auth：簡單密碼認證
    help cmd： 查看cmd幫助，例如：help quit
    
    2）持久化
    save：將數據同步保存到磁盤
    bgsave：將數據異步保存到磁盤
    lastsave：返回上次成功將數據保存到磁盤的Unix時戳
    shundown：將數據同步保存到磁盤，然后關閉服務
    
    3）遠程服務控制
    info：提供服務器的信息和統計
    monitor：實時轉儲收到的請求
    slaveof：改變復制策略設置
    config：在運行時配置Redis服務器
    
    4）對value操作的命令
    exists(key)：確認一個key是否存在
    del(key)：刪除一個key
    type(key)：返回值的類型
    keys(pattern)：返回滿足給定pattern的所有key
    randomkey：隨機返回key空間的一個
    keyrename(oldname, newname)：重命名key
    dbsize：返回當前數據庫中key的數目
    expire：設定一個key的活動時間（s）
    ttl：獲得一個key的活動時間
    select(index)：按索引查詢
    move(key, dbindex)：移動當前數據庫中的key到dbindex數據庫
    flushdb：刪除當前選擇數據庫中的所有key
    flushall：刪除所有數據庫中的所有key
    
    5）String
    set(key, value)：給數據庫中名稱為key的string賦予值value
    get(key)：返回數據庫中名稱為key的string的value
    getset(key, value)：給名稱為key的string賦予上一次的value
    mget(key1, key2,…, key N)：返回庫中多個string的value
    setnx(key, value)：添加string，名稱為key，值為value
    setex(key, time, value)：向庫中添加string，設定過期時間time
    mset(key N, value N)：批量設置多個string的值
    msetnx(key N, value N)：如果所有名稱為key i的string都不存在
    incr(key)：名稱為key的string增1操作
    incrby(key, integer)：名稱為key的string增加integer
    decr(key)：名稱為key的string減1操作
    decrby(key, integer)：名稱為key的string減少integer
    append(key, value)：名稱為key的string的值附加value
    substr(key, start, end)：返回名稱為key的string的value的子串
    
    6）List 
    rpush(key, value)：在名稱為key的list尾添加一個值為value的元素
    lpush(key, value)：在名稱為key的list頭添加一個值為value的 元素
    llen(key)：返回名稱為key的list的長度
    lrange(key, start, end)：返回名稱為key的list中start至end之間的元素
    ltrim(key, start, end)：截取名稱為key的list
    lindex(key, index)：返回名稱為key的list中index位置的元素
    lset(key, index, value)：給名稱為key的list中index位置的元素賦值
    lrem(key, count, value)：刪除count個key的list中值為value的元素
    lpop(key)：返回並刪除名稱為key的list中的首元素
    rpop(key)：返回並刪除名稱為key的list中的尾元素
    blpop(key1, key2,… key N, timeout)：lpop命令的block版本。
    brpop(key1, key2,… key N, timeout)：rpop的block版本。
    rpoplpush(srckey, dstkey)：返回並刪除名稱為srckey的list的尾元素，

　　　　　　　　　　　　　　並將該元素添加到名稱為dstkey的list的頭部
    
    7）Set
    sadd(key, member)：向名稱為key的set中添加元素member
    srem(key, member) ：刪除名稱為key的set中的元素member
    spop(key) ：隨機返回並刪除名稱為key的set中一個元素
    smove(srckey, dstkey, member) ：移到集合元素
    scard(key) ：返回名稱為key的set的基數
    sismember(key, member) ：member是否是名稱為key的set的元素
    sinter(key1, key2,…key N) ：求交集
    sinterstore(dstkey, (keys)) ：求交集並將交集保存到dstkey的集合
    sunion(key1, (keys)) ：求並集
    sunionstore(dstkey, (keys)) ：求並集並將並集保存到dstkey的集合
    sdiff(key1, (keys)) ：求差集
    sdiffstore(dstkey, (keys)) ：求差集並將差集保存到dstkey的集合
    smembers(key) ：返回名稱為key的set的所有元素
    srandmember(key) ：隨機返回名稱為key的set的一個元素
    
    8）Hash
    hset(key, field, value)：向名稱為key的hash中添加元素field
    hget(key, field)：返回名稱為key的hash中field對應的value
    hmget(key, (fields))：返回名稱為key的hash中field i對應的value
    hmset(key, (fields))：向名稱為key的hash中添加元素field 
    hincrby(key, field, integer)：將名稱為key的hash中field的value增加integer
    hexists(key, field)：名稱為key的hash中是否存在鍵為field的域
    hdel(key, field)：刪除名稱為key的hash中鍵為field的域
    hlen(key)：返回名稱為key的hash中元素個數
    hkeys(key)：返回名稱為key的hash中所有鍵
    hvals(key)：返回名稱為key的hash中所有鍵對應的value
    hgetall(key)：返回名稱為key的hash中所有的鍵（field）及其對應的value

 

Redis高級應用

1、安全性

    設置客戶端連接后進行任何操作指定前需要密碼，一個外部用戶可以再一秒鍾進行150W次訪問，具體操作密碼修改設置redis.conf里面的requirepass屬性給予密碼，當然我這里給的是primos 

之后如果想操作可以采用登陸的時候就授權使用:

sudo /opt/java/redis/bin/redis-cli -a primos

或者是進入以后auth primos然后就可以隨意操作了

 

2、主從復制

做這個操作的時候我准備了兩個 虛擬機，ip分別是192.168.15.128和192.168.15.133

    通過主從復制可以允許多個slave server擁有和master server相同的 數據庫副本

具體配置是在slave上面配置slave

slaveof 192.168.15.128 6379

masterauth primos

如果沒有主從同步那么就檢查一下是不是防火牆的問題，我用的是ufw，設置一下sudo ufw allow 6379就可以了

這個時候可以通過info查看具體的情況

 

3、事務處理

redis對事務的支持還比較簡單，redis只能保證一個client發起的事務中的命令可以連續執行，而中間不會插入其他client的命令。當一個client在一個連接中發出multi命令時，這個連接會進入一個事務的上下文，連接后續命令不會立即執行，而是先放到一個隊列中，當執行exec命令時，redis會順序的執行隊列中的所有命令。

比如我下面的一個例子

set age 100

multi

set age 10

set age 20

exec

get age --這個內容就應該是20

multi

set age 20

set age 10

exec 

get age --這個時候的內容就成了10，充分體現了一下按照隊列順序執行的方式

discard  取消所有事務，也就是事務回滾

不過在redis事務執行有個別錯誤的時候，事務不會回滾，會把不錯誤的內容執行，錯誤的內容直接放棄，目前最新的是2.6.7也有這個問題的

樂觀鎖

watch key如果沒watch的key有改動那么outdate的事務是不能執行的

 

4、持久化機制 

redis是一個支持持久化的內存數據庫

snapshotting快照方式，默認的存儲方式，默認寫入dump.rdb的二進制文件中，可以配置redis在n秒內如果超過m個key被修改過就自動做快照

append-only file aof方式，使用aof時候redis會將每一次的函 數都追加到文件中，當redis重啟時會重新執行文件中的保存的寫命

令在內存中。

5、發布訂閱消息 sbusribe publish操作，其實就類似linux下面的消息發布

6、虛擬內存的使用

可以配置vm功能，保存路徑，最大內存上線，頁面多少，頁面大小，最大工作線程

臨時修改ip地址ifconfig eth0 192.168.15.129

 

redis-cli參數

Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]
  -h <hostname>    Server hostname (default: 127.0.0.1)
  -p <port>        Server port (default: 6379)
  -s <socket>      Server socket (overrides hostname and port)
  -a <password>    Password to use when connecting to the server
  -r <repeat>      Execute specified command N times
  -i <interval>    When -r is used, waits <interval> seconds per command.
                   It is possible to specify sub-second times like -i 0.1
  -n <db>          Database number
  -x               Read last argument from STDIN
  -d <delimiter>   Multi-bulk delimiter in for raw formatting (default: \n)
  -c               Enable cluster mode (follow -ASK and -MOVED redirections)
  --raw            Use raw formatting for replies (default when STDOUT is not a  tty)
  --latency        Enter a special mode continuously sampling latency
  --slave          Simulate a slave showing commands received from the master
  --pipe           Transfer raw Redis protocol from stdin to server
  --bigkeys        Sample Redis keys looking for big keys
  --eval <file>    Send an EVAL command using the Lua script at <file>
  --help           Output this help and exit
  --version        Output version and exit

Examples:
  cat /etc/passwd | redis-cli -x set mypasswd
  redis-cli get mypasswd
  redis-cli -r 100 lpush mylist x
  redis-cli -r 100 -i 1 info | grep used_memory_human:
  redis-cli --eval myscript.lua key1 key2 , arg1 arg2 arg3
  (Note: when using --eval the comma separates KEYS[] from ARGV[] items)

 

 

常用命令：

1） 查看keys個數

keys *      // 查看所有keys

keys prefix_*     // 查看前綴為"prefix_"的所有keys

 

2） 清空數據庫

flushdb   // 清除當前數據庫的所有keys

flushall    // 清除所有數據庫的所有keys