<p style="margin-top: 0px; margin-bottom: 1.1em; padding-top: 0px; padding-bottom: 0px; box-sizing: border-box; color: rgb(54, 46, 43); font-family: "microsoft yahei"; font-size: 14px; line-height: 26px;">轉自：http://blog.csdn<a target=_blank href="http://lib.csdn.net/base/dotnet" class="replace_word" title=".NET知識庫" target="_blank" style="text-decoration: none; box-sizing: border-box; color: rgb(223, 52, 52); font-weight: bold;">.NET</a>/helencoder/article/details/51784654</p><p style="margin-top: 0px; margin-bottom: 1.1em; padding-top: 0px; padding-bottom: 0px; box-sizing: border-box; color: rgb(54, 46, 43); font-family: "microsoft yahei"; font-size: 14px; line-height: 26px;">利用<a target=_blank target="_blank" href="http://lib.csdn.net/base/redis" class="replace_word" title="Redis知識庫" style="text-decoration: none; box-sizing: border-box; color: rgb(223, 52, 52); font-weight: bold;">Redis</a>、co-<a target=_blank href="http://lib.csdn.net/base/redis" class="replace_word" title="Redis知識庫" target="_blank" style="text-decoration: none; box-sizing: border-box; color: rgb(223, 52, 52); font-weight: bold;">Redis</a>進行redis操作</p>
/**
 * redis操作示例
 */

// 準備工作：npm install redis co-redis (--save) 
// 開發機ip： 
// 預設埠：6379

// 文件參考：https://www.npmjs.com/package/redis         (node-redis)
// 文件參考：https://www.npmjs.com/package/co-redis      (co-redis)
// 文件參考：http://www.redis.cn/commands.html               (redis命令)

// 開發機測試配置：啟動redis服務後加 --protected-mode no 選項 使其允許遠端連線

var co = require('co');
var redis = require('redis');
var wrapper = require('co-redis');
var log = Log('models.redis');

//var redisClient = redis.createClient();

// redis配置引數
var redis_config = {
    "host": "",
    "port": 6379
};
var redisClient = redis.createClient(redis_config);
// 資料庫選擇/* * redis預設連線資料庫0,可以利用select選擇指定資料庫0~15 * 使用示例： * 
redisClient.select("15", function (err) { * if (err) { * return false; * } else { * console.log('connect success'); * } * }); */
或者直接
var redisClient = redis.createClient('redis://100.131.26.110:8009?database=0');
// 使用co-redis包裝redisClient
var redisCo = wrapper(redisClient);

// 利用co-redis包裝將redis命令以返回值形式直接輸出
/*co(function* () {
  var set = yield redisCo.set('test', 33);
  console.log(set);
  console.log(yield redisCo.get('test')); // logs 33 

  redisClient.quit();
}).catch(function(e) {

});*/

// redis命令使用示例  
/*
 * 基本示例：
 * redisClient.set('key', 'value', function (res, reply) {});
 *
 * 命令引數：
 * 1、字串
 * 2、陣列 (注：非所有命令均可用)
 * (對於hash操作，賦值可使用json)
 * (後跟回撥函式[可選]) (利用co-redis可以將命令以返回值形式輸出) 
 * 
 * 使用示例(不同引數樣式實現相同功能)
 * 
 * client.hmset(["key", "test keys 1", "test val 1", "test keys 2", "test val 2"], function (err, res) {});
 * client.hmset("key", ["test keys 1", "test val 1", "test keys 2", "test val 2"], function (err, res) {});
 * client.hmset("key", "test keys 1", "test val 1", "test keys 2", "test val 2", function (err, res) {});   
 *
 * client.set("some key", "some val");
 * client.set(["some other key", "some val"]);
 *
 * client.hmset(hash, obj[, callback])      (此處可以使用json)    
 * client.hmset(hash, key1, val1, ... keyn, valn, [callback])
 */

 // redis資料型別命令彙總
 /*
  * string 字串
  *     命令                  行為                                              返回值                     使用示例(略去回撥函式)
  *     set         設定儲存在給定鍵中的值                      OK                         set('key', 'value')
  *     get         獲取儲存在給定鍵中的值                     value/null          get('key')
  *     del         刪除儲存在給定鍵中的值(任意型別)    1/0                        del('key')
  *     incrby  將鍵儲存的值加上整數increment                                         incrby('key', increment)
  *     decrby  將鍵儲存的值減去整數increment                                         decrby('key', increment)
  *     incrbyfloat 將鍵儲存的值加上浮點數increment                                incrbyfloat('key', increment)   
  *     append  將值value追加到給定鍵當前儲存值的末尾                           append('key', 'new-value')
  *     getrange    獲取指定鍵的index範圍內的所有字元組成的子串            getrange('key', 'start-index', 'end-index')
  *     setrange    將指定鍵值從指定偏移量開始的子串設為指定值           setrange('key', 'offset', 'new-string')
  *     
  * list 列表
  *   命令                    行為                                              返回值                     使用示例(略去回撥函式)
  *     rpush       將給定值推入列表的右端                     當前列表長度      rpush('key', 'value1' [,'value2']) (支援陣列賦值)
  *     lrange  獲取列表在給定範圍上的所有值          array                       lrange('key', 0, -1) (返回所有值)
  *     lindex  獲取列表在給定位置上的單個元素                                     lindex('key', 1)
  *     lpop        從列表左端彈出一個值，並返回被彈出的值                     lpop('key')
  *     rpop        從列表右端彈出一個值，並返回被彈出的值                     rpop('key')
  *     ltrim       將列表按指定的index範圍裁減                                                ltrim('key', 'start', 'end')
  *
  * set 集合
  *     命令                  行為                                              返回值                     使用示例(略去回撥函式)
  *     sadd            將給定元素新增到集合                      插入元素數量      sadd('key', 'value1'[, 'value2', ...]) (不支援陣列賦值)(元素不允許重複)
  *     smembers    返回集合中包含的所有元素                array(無序)           smembers('key')
  *     sismenber   檢查給定的元素是否存在於集合中 1/0                         sismenber('key', 'value')
  *     srem            如果給定的元素在集合中，則移除此元素 1/0              srem('key', 'value')
  *     scad            返回集合包含的元素的數量                                                sacd('key')   
  *     spop            隨機地移除集合中的一個元素，並返回此元素                spop('key')
  *     smove           集合元素的遷移                                                                 smove('source-key', 'dest-key', 'item')
  *     sdiff           返回那些存在於第一個集合，但不存在於其他集合的元素(差集)   sdiff('key1', 'key2'[, 'key3', ...])   
  *     sdiffstore  將sdiff操作的結果儲存到指定的鍵中                         sdiffstore('dest-key', 'key1', 'key2' [,'key3' ,...])   
  *     sinter      返回那些同事存在於所有集合中的元素(交集)               sinter('key1', 'key2'[, 'key3', ...])
  *     sinterstore 將sinter操作的結果儲存到指定的鍵中                        sinterstore('dest-key', 'key1', 'key2' [,'key3' ,...])  
  *     sunion      返回那些至少存在於一個集合中的元素(並集)               sunion('key1', 'key2'[, 'key3', ...])
  *     sunionstore 將sunion操作的結果儲存到指定的鍵中                        sunionstore('dest-key', 'key1', 'key2' [,'key3' ,...])  
  *
  * hash 雜湊
  *     命令                  行為                                              返回值                     使用示例(略去回撥函式)
  *     hset            在雜湊裡面關聯起給定的鍵值對      1(新增)/0(更新) hset('hash-key', 'sub-key', 'value')    (不支援陣列、字串)
  *     hget            獲取指定雜湊鍵的值                                                           hget('hash-key', 'sub-key')
  *     hgetall     獲取雜湊包含的鍵值對                      json                        hgetall('hash-key')
  *     hdel            如果給定鍵存在於雜湊裡面，則移除這個鍵                 hdel('hash-key', 'sub-key')
  *     hmset           為雜湊裡面的一個或多個鍵設定值 OK                          hmset('hash-key', obj)
  *     hmget           從雜湊裡面獲取一個或多個鍵的值 array                       hmget('hash-key', array)
  *     hlen            返回雜湊包含的鍵值對數量                                                hlen('hash-key')
  *     hexists     檢查給定鍵是否在雜湊中                 1/0                         hexists('hash-key', 'sub-key')
  *     hkeys           獲取雜湊包含的所有鍵                      array                       hkeys('hash-key')
  *     hvals           獲取雜湊包含的所有值                      array                       hvals('hash-key')
  *     hincrby     將儲存的鍵值以指定增量增加           返回增長後的值 hincrby('hash-key', 'sub-key', increment) (注：假如當前value不為為字串，則會無輸出，程式停止在此處)
  *     hincrbyfloat    將儲存的鍵值以指定浮點數增加
  *     
  *     
  * zset 有序集合
  *     命令                  行為                                              返回值                     使用示例(略去回撥函式)
  *     zadd            將一個帶有給定分支的成員新增到有序集合中                zadd('zset-key', score, 'key') (score為int)
  *     zrange      根據元素在有序排列中的位置，從中取出元素
  *     zrangebyscore   獲取有序集合在給定分值範圍內的所有元素
  *     zrem            如果給定成員存在於有序集合，則移除
  *     zcard           獲取一個有序集合中的成員數量      有序集的元素個數    zcard('key')
  *
  */

  // redis其他常用命令彙總
  /*
     * keys命令組
     *  命令                  行為                                              返回值                     使用示例(略去回撥函式)
     *  del             刪除一個(或多個)keys           被刪除的keys的數量     del('key1'[, 'key2', ...])
     *  exists      查詢一個key是否存在                             1/0                     exists('key')
     *  expire      設定一個key的過期的秒數                       1/0                     expire('key', seconds)
     *  pexpire     設定一個key的過期的毫秒數                  1/0                     pexpire('key', milliseconds)    
     *  expireat    設定一個UNIX時間戳的過期時間            1/0                     expireat('key', timestamp)
     *  pexpireat   設定一個UNIX時間戳的過期時間(毫秒) 1/0                    pexpireat('key', milliseconds-timestamp)
     *  persist     移除key的過期時間                                  1/0                     persist('key')
     *  sort            對佇列、集合、有序集合排序       排序完成的佇列等  sort('key'[, pattern, limit offset count])
     *  
     *  flushdb     清空當前資料庫
     *  
   */

co(function* () {
  //var set = yield redisCo.sadd('set-key', [item, item1, item2, item3, item4]);
  var json = {
    'sub-key5': 'value6',
    'sub-key7': 'value7'
  };
  var array = ['sub-key4', 'sub-key5'];
  //var hash = yield redisCo.hset('hash-key', 'sub-key4', 'value4');
    var hash = yield redisCo.hgetall('hash-key');
    console.log(hash);

  redisClient.quit();
});

// redis事務(支援連貫操作)
/*
 * 常用命令
 *  multi() 事務
 *  exec([callback]) 執行事務
 *  discard 放棄事務
 *  watch 監視指定的鍵值
 *  unwatch 取消監視
 * 
 * 命令用法：
 *  MULTI
 *      MULTI 命令用於開啟一個事務，它總是返回 OK 。 
 *      MULTI 執行之後， 客戶端可以繼續向伺服器傳送任意多條命令， 
 *      這些命令不會立即被執行， 而是被放到一個佇列中， 當 EXEC命令被呼叫時， 所有佇列中的命令才會被執行。
 *      另一方面， 通過呼叫 DISCARD ， 客戶端可以清空事務佇列， 並放棄執行事務。
 *  EXEC
 *      EXEC 命令的回覆是一個數組， 陣列中的每個元素都是執行事務中的命令所產生的回覆。 
 *      其中， 回覆元素的先後順序和命令傳送的先後順序一致。
 *  DISCARD
 *      當執行 DISCARD 命令時， 事務會被放棄， 事務佇列會被清空， 並且客戶端會從事務狀態中退出
 *  WATCH
 *      WATCH 命令可以為 Redis 事務提供 check-and-set （CAS）行為。
 *      被 WATCH 的鍵會被監視，並會發覺這些鍵是否被改動過了。 
 *      如果有至少一個被監視的鍵在 EXEC 執行之前被修改了， 那麼整個事務都會被取消， 
 *      EXEC 返回nil-reply來表示事務已經失敗。
 *  
 *      WATCH 使得 EXEC 命令需要有條件地執行： 
 *      事務只能在所有被監視鍵都沒有被修改的前提下執行， 如果這個前提不能滿足的話，事務就不會被執行。
 *  
 *      WATCH 命令可以被呼叫多次。 對鍵的監視從 WATCH 執行之後開始生效， 直到呼叫 EXEC 為止。
 *
 *      當 EXEC 被呼叫時， 不管事務是否成功執行， 對所有鍵的監視都會被取消。
 *      另外， 當客戶端斷開連線時， 該客戶端對鍵的監視也會被取消。
 *  UNWATCH
 *      使用無引數的 UNWATCH 命令可以手動取消對所有鍵的監視。
 *
 * 使用示例：
 *  1、連貫操作
 *      client.multi().incr('key').incr('key').exec(function (err, reply) {});
 *
 *  2、常規操作
 *      multi = client.multi();
 *      multi.incr('key');
 *      multi.incr('key');
 *      multi.exec(function (err, replies) {});
 *
 *  3、取巧操作
 *      client.multi([
 *          ["mget", "multifoo", "multibar", redis.print],
 *          ["incr", "multifoo"],
 *          ["incr", "multibar"]
 *      ]).exec(function (err, replies) {
 *          console.log(replies);
 *      }); 
 *
 */

// 事件監聽 
/*
 * 事件：ready、connect、reconnecting、end、warning、error
 * 執行順序： ready > connect > end(quit觸發)
 * error事件需要設定監聽(必選)
 *
 * 使用示例：
 * redisClient.on("ready", function(err) {  
 *  if (err) return false;
 *  console.log("ready");
 * });
 */

redisClient.on("error", function (err) {
  console.log("Error " + err);
});

// 資料操作(未用co-redis包裝的寫法)

// string(增、刪、改、查)
/*redisClient.set('string key', 'string value', function (err, reply) {
    if (err) return false;
    console.log(reply);     // 設定成功,返回值為OK,資料更改直接更改對應的value即可，返回值也為OK。
});
redisClient.set('string key1', 'string value1', redis.print);       // 此種方式直接在命令列列印返回值。
redisClient.get('string key', function (err, reply) {
    if (err) return false;
    console.log(reply);     // 取值成功，返回指定鍵值對應的value,若鍵值不存在，返回null
});
redisClient.exists('string key2', function (err, reply) {
    if (err) return false;
    console.log(reply);     // 鍵存在，返回1，否則返回0
});
redisClient.del('string key1', function (err, reply) {
    if (err) return false;
    console.log(reply);     // 刪除成功，返回1，否則返回0(對於不存在的鍵進行刪除操作，同樣返回0)
});
redisClient.randomkey(function (err, reply) {
    if (err) return false;
    console.log(reply);     // 隨機返回一個鍵
});

redisClient.set('string key', 'string value', function(err, reply) {
    if (err) return false;
    console.log(reply);
});

redisClient.expire('string key', 1, function(err, reply) {
    if (err) return false;
    console.log(reply);
});

redisClient.get('string key', function (err, reply) {
    if (err) return false;
    console.log(reply);     // 取值成功，返回指定鍵值對應的value,若鍵值不存在，返回null
});

setTimeout(function () {
    redisClient.get('string key', function (err, reply) {
        if (err) console.log(err);
        console.log(reply);     // 取值成功，返回指定鍵值對應的value,若鍵值不存在，返回null
    });
}, 1100);*/

// list

// set 

// sorted set

// hash 

//redisClient.end(true);
//redisClient.quit();

exports.redisClient = function() {
    var redisClient = redis.createClient(redis_config);
    var redisCo = wrapper(redisClient);
    return redisCo;
};

exports.redisSave = function() {
    return co(function * () {
        var redisClient = exports.redisClient();

    }).catch(function(error) {
        log.error('models.redis.order.add(' + JSON.stringify(order) + ')', error);
    return false;
    });
};

exports.add = function(order) {
    return co(function * () {
    var result = yield exports.redisSave();
    return result;
  }).catch(function(error) {
    log.error('models.redis.order.add(' + JSON.stringify(order) + ')', error);
    return false;
  });
};