Node.js Redis

服务端

安装redis服务器

$ yum install -y redis

设置密码

$ redis-cli -h 127.0.0.1 -p 6379
127.0.0.1:6379> config get requirepass
127.0.0.1:6379> config set requirepass 123456

$ redis-cli -h 127.0.0.1 -p 3306 -a 123456

客户端

Redis驱动多使用node redis，此模块可搭配官方的hiredis C非阻塞的语言库，比使用JavaScript内置的解释器性能稍好，可选择将hiredis与redis一同安装。

$ npm i redis hiredis

基本用法

//初始化
const redis = require("redis");

//创建客户端
const clientRedis = redis.createClient();
clientRedis.on("error", function(err){
  console.error("ERROR:%s", err);
});

如果在项目中使用redis希望初始化一次后处处可用呢？

1. 将redis客户端存储到node的全局对象global中

global.redisClient = require("redis").createClient();

2. 将redis初始化方法封装后exports出去供其它模块require调用

const redis = require("redis");

const config = {};
config.host = "127.0.0.1";
config.port = 6379;

const redisClient = redis.createClient(config.port, config.host);

redisClient.on("connect", function(opts){
    console.log("redis client connect");
});

redisClient.on("error", function(err){
    console.error("redis client on error: %s", err);
});

//monitor事件可以监听到redis接收到的所有客户端命令
redisClient.monitor(function(err, res){
    console.log("redis client monitor: ", res);//ok
});

redisClient.on("monitor", function(time, args){
   console.log("redis client on monitor:", time, args);
});

module.exports = redisClient;

创建客户端

const redis = require("redis");
const redisClient = redis.createClient(config);

创建客户端可以设置的参数

参数	描述
port	端口，默认为6379
host	主机地址，默认127.0.0.1
path	主机地址:端口
family	协议族，可选IPv6或IPv4
max_attempts	连接最长尝试次数
retry_max_delay	-
socket_nodelay	-
socket_keepalive	-
return_buffers	-
detect_buffers	-
connect_timeout	60 * 60 * 1000 ms
enable_offline_queue	-
password	认证密码
auth	认证用户名
db	默认选取的数据库索引

Redis没有严格意义上的表名和字段名，而是以Key-Value键值对的方式。因此一般采用schema:key的形式作为键名，其中schema可理解为传统意义上数据库表命，而key可认为是表中的主键。

例如：使用redis存放session的键名

sessionid:i4w3axuzyj4nwwg75y6k5us2

Redis支持对键名进行索引，但不支持对键名所存放的Hash Key进行索引。

例如：检索所有session

redisClient.keys("session:*", function(err, keys){
  console.log(err, keys);
});

Redis的一个key键名可以对应一个String字符串类型的值，也可以是hashes、lists、sets、sorted sets、bitmaps等。

封装模块

const redis = require("redis");

//连接配置
const config = {};
config.host = "127.0.0.1";
config.port = 6379;
config.password = "";

//创建客户端
const redisClient = redis.createClient(config.port, config.host);
//密码验证
if(config.password){
    redisClient.auth(config.password, ()=>{
        console.log("redis auth success");
    });
}

redisClient.on("connect", function(opts){
    console.log("redis client connect");
});

redisClient.on("error", function(err){
    console.error("redis client on error: %s", err);
});

//monitor事件可以监听到redis接收到的所有客户端命令
redisClient.monitor(function(err, res){
    console.log("redis client monitor: ", res);//ok
});

redisClient.on("monitor", function(time, args){
   console.log("redis client on monitor:", time, args);
});

let cache = {};

// 填充封装的接口代码

module.exports = cache;

键名key

命令	描述
> KEYS pattern	查找所有符合给定pattern模式的key
> TYPE key	获取指定key所存储值的类型
> TTL key	以秒为单位获取指定key的剩余生存时间（TTL，time to live）
> PTTL key	以毫秒为单位获取指定key的剩余过期时间
> DUMP key	序列化给定key并返回序列化后的值。
> EXISTS key	检查给定key是否存在
> DEL key	删除key
> MOVE key db	将当前数据库索引中的key移动到指定数据库中
> EXPIRE key seconds	为给定的key设置过期秒数时间
> EXPIREAT key timestamp	为给定的key设置秒级的过期UNIX时间戳
> PEXIRE key milliseconds	为给定的key设置毫秒级的过期时间
> PEXIREAT key millisecond-timestamp	为给定的key设置毫秒级的过期时间戳
> PERSIS key	移除key的过期时间，key将持久保存。
> RANDOMKEY	从当前数据库中随机获取一个key
> RENAME oldkey newkey	为指定的oldkey进行重命名
> RENAMENX oldkey newkey	当newkey不存在时为old进行重命名

字符串string

• 字符串类型最大长度为512MB

Redis客户端命令

命令	描述
SET key value	设置指定key的值
GET key	获取指定key的值
MSET key value[key value...]	同时设置一个或多个键值对
MGET key[key...]	获取所有一个或多个给定key的值
INCR key	将key中的存储的数字值增加1
DECR key	将key中存储的数字值减少1
INCRBY key increment	将key所存储的数值增加给定的增量值（increment）
DECRBY key decrement	将key所存储的数值减去给定的减量值（decrement）
STRLEN key	获取key所存储的字符串的长度
APPEND key value	若key存在且是字符串则将指定的value值追加到key原来值得末尾

Node.js中Redis接口用法

set

• set用于设置存储在给定键中的值
• 若设置成功则err返回为null，result返回字符串的OK。
• 若设置失败则err返回错误信息，result返回null。

cache.set = (key, value)=>{
    if(typeof value === "object"){
        value = JSON.stringify(value);
    }
    return new Promise((resolve, reject)=>{
        redisClient.set(key, value, (err, res)=>{
            console.log(err, res);//null null
            if(err){
                reject(err);
            }else{
                if(res === "OK"){
                    res = true;
                }
                resolve(res);
            }
        });
    });
};

get

• get用于获取存储在给定键中的值
• 若Redis中没有存在的键则err返回为null，result返回为null。
• 若获取成功则err返回为null，result返回为目标字符串。

cache.get = (key) => {
    return new Promise((resolve, reject)=>{
        redisClient.get(key, (err, res)=>{
            console.log(err, res);
            if(err){
                reject(err);
            }else{
                resolve(res);
            }
        });
    });
};

哈希hash

• 哈希又称为散列表，适合存储对象类型的数据。
• Redis哈希是一个字符串类型的字段和值的映射表
• Redis中每个哈希可存储2的32次方减1个键值对约40多亿

Redis客户端命令

命令	描述
> HSET key field value	将哈希表key中字段为field的值设置为value
> HSETNX key field value	当哈希表key中字段为field的值不存在时设置其值为value
> HGET key field	获取哈希表key中字段为field的值
> HDEL key field[field...]	删除哈希表key中一个或多个字段
> HLEN key	获取哈希表key中字段的数量
> HEXISTS key field	判断哈希表key中是否存在field字段
> HKEYS key	获取哈希表key中所有的字段
> HVALS key	获取哈希表key中所有的字段值
> HGETALL key	获取哈希表key中所有字段和值
>HINCRBY key field increment	将哈希表key中指定field字段名的值增加increment
>HINCRBYFLOAT key field increment	将哈希表key中field字段的浮点数值增加increment

Node.js中Redis接口

hlen

• hlen 返回哈希散列表中所包含的键值对个数

//哈希散列表 获取键值对数量
cache.hlen = (key)=>{
    return new Promise((resolve, reject)=>{
        redisClient.hlen(key, (err, len)=>{
            if(err){
                reject(err);
            }else{
                resolve(len);
            }
        });
    });
};

hmget

hmget用于从指定键名的哈希散列表中获取指定字段的值，字段使用数组格式。

redisClient.hmget(string key, array field, function(object error, object result){});

例如：获取用户哈希表中指定字段的值

router.post("/userinfo", function(req, res, next){
     const user = req.body.user;
     redisClient.hmget(`user_hash:${user}`, ["nickname", "avatar", "aid"], function(err, ret){
          if(!err){
               let info = {nickname:ret[0], avatar:ret[1], aid:ret[2]};
               res.json({error:false, code:200, message:"success", data:info});
          }
     });
});

使用ES7提供的async/await进行封装

cache.hmget = (key, values)=>{
    return new Promise((resolve, reject)=>{
       redisClient.hmget(key, value, (error, result)=>{
           if(error){
               reject(error);
           }else{
               resolve(result);
           }
       });
    });
};

列表List

• Redis列表是字符串列表会按照插入顺序进行排序
• Redis列表是有序的列表元素是可以重复的
• Redis列表可将元素添加到列表的左侧头部或右侧尾部
• Redis列表可容纳2的32次方减1约40亿个元素

命令	描述
> LLEN key	获取列表key的元素个数
> LSET key index value	设置列表key中索引为index的value值
> LINDEX key index	获取列表key中索引为index的值
> LRANGE key start stop	获取列表key中指定起止索引范围内的元素
> LPUSH key value1 [value2]	将一个或多个值插入列表头部
> LPUSHX key value	将一个值插入到已存在的列表头部

const min = 100000;
const max = 1000000;
const id = min + Math.round((max - min) * Math.random());
redisClient.lpush("aid_list", id, function(error, result){
     console.log(error, result);//null 1
});

集合set

• Redis的集合是字符串类型的无需集合
• Redis的集合成员是唯一的，集合中不能出现重复的数据。
• Redis的集合是通过哈希表实现的，添加、删除、查找的复杂度都是O(1)。
• Redis的集合最大成员数是2的32次方减1约40亿

命令	描述
> SADD key member1 [member2]	向集合添加一个或多个成员
> SISMEMBER key member	判断member元素是否为集合key的成员
> SPOP key	移除并返回集合中的一个随机元素

例如：向集合中循环插入随机编号获得具有唯一编号的集合

const min = 100000;
const max = 1000000;
const id = min + Math.round((max - min) * Math.random());
redisClient.sadd("aid_set", id, function(error, result){
  console.log(error, result);//null 1
});

封装

使用ES7的async/await封装

const redis = require("redis");

//连接配置
const config = {};
config.host = "127.0.0.1";
config.port = 6379;
config.password = "";

//创建客户端
const redisClient = redis.createClient(config.port, config.host);

//密码验证
if(config.password){
    redisClient.auth(config.password, ()=>{
        console.log("redis auth success");
    });
}

redisClient.on("connect", function(opts){
    console.log("redis client connect");
});

redisClient.on("error", function(error){
    console.error("redis client on error: %s", error);
});

//monitor事件可以监听到redis接收到的所有客户端命令
redisClient.monitor(function(error, result){
    console.log("redis client monitor: ", result);//ok
});

redisClient.on("monitor", function(time, args){
   console.log("redis client on monitor:", time, args);
});


let cache = {};

//字符串 根据键名获取键值，字符串解析为JSON对象。
cache.get = (key) => {
    return new Promise((resolve, reject)=>{
        redisClient.get(key, (error, result)=>{
            console.log(error, result);//null null
            if(error){
                reject(error);
            }else{
                resolve(result);
            }
        });
    });
};

//字符串 设置键值对
cache.set = (key, value)=>{
    if(typeof value === "object"){
        value = JSON.stringify(value);
    }
    return new Promise((resolve, reject)=>{
        redisClient.set(key, value, (error, result)=>{
            console.log(error, result);
            if(error){
                reject(error);
            }else{
                if(result === "OK"){
                    result = true;
                }
                resolve(result);
            }
        });
    });
};


//哈希散列表 获取键值对数量
cache.hlen = (key)=>{
    return new Promise((resolve, reject)=>{
        redisClient.hlen(key, (error, length)=>{
            if(error){
                reject(error);
            }else{
                resolve(length);
            }
        });
    });
};
//哈希散列表 根据键名获取中所有的键值对
cache.hgetall = (key)=>{
    return new Promise((resolve, reject)=>{
       redisClient.hgetall(key, (error, result)=>{
            if(error){
                reject(error);
            }else{
                resolve(result);
            }
       });
    });
};
//哈希散列表 设置中的键值对
cache.hmset = (key, values)=>{
    return new Promise((resolve, reject)=>{
       redisClient.hmset(key, values, (error, result)=>{
            if(error){
                reject(error);
            }else{
                if(result === "OK"){
                    result = true;
                }
                resolve(result);
            }
       });
    });
};
cache.hmget = (key, values)=>{
    return new Promise((resolve, reject)=>{
       redisClient.hmget(key, value, (error, result)=>{
           if(error){
               reject(error);
           }else{
               resolve(result);
           }
       });
    });
};
module.exports = cache;

使用方式

const cache = require("../utils/redis");
router.post("/login", async (req, res, next)=>{
     //REDIS
     let values = {};
     values.active = 1;
     values.logintime = timestamp;

     let key = `user_hash:${aid}`;
     result = await cache.hgetall(key);
     if(!result){
          values.aid = aid;
          values.username = username;
          values.nickname = nickname;
          values.avatar = avatar;
     }
     result = await cache.hmset(key, values);
     if(!result){
          res.json({error:true, code:500, message:"缓存失败！"});
          return;
     }
});

此处有一个疑问，使用require在不同文件中引入redis时，使用redis.createClient创建的对象，应该会存在多项，如果是这样的话，如何利用类似于数据库连接池的方式，只创建一个redis客户端对象，亦或者是采用单例模式，以节省内存资源。