0
点赞
收藏
分享

微信扫一扫

连接池 generic-pool之Redis

邯唐情感 2022-03-21 阅读 68

前言

安装方式

// dao-pool.js

let genericPool = require('generic-pool');
let ioredis = require('ioredis');

let DEFAULT_MIN_POOL_SIZE = 5;
let DEFAULT_MAX_POOL_SIZE = 20;
let DEFAULT_IDLE_TIMEOUT_IN_MILLIS = 30 * 1000; //毫秒

/*
 * 创建redis连接池
 */
module.exports = function () {
    return genericPool.createPool({
        name: 'redis',
        create: function () {
            return new ioredis({
                port: '6379',
                host: '127.0.0.1',
                password: 'auth',
                db: 0,
                family: 4, // 4 (IPv4) or 6 (IPv6)
            });
        },
        destroy: function (client) {
            client.disconnect();
        },
    },{
        max: DEFAULT_MAX_POOL_SIZE,
        min: DEFAULT_MIN_POOL_SIZE,
        idleTimeoutMillis: DEFAULT_IDLE_TIMEOUT_IN_MILLIS,
        priorityRange: 3,
        log: false
    });
};


// redis.js

let redisclient = module.exports;

let _pool;

let NND = {};

NND.init = function () {
    _pool = require('./dao-pool')();
};

/**
 * 获取redis client并执行对应redis命令
 */
NND.opt = function () {
    let args = Array.prototype.slice.call(arguments);
    _pool.acquire().then(function (client) {
        let cmd = args[0];
        let key, val, val2, val3, cb;
        switch (cmd) {
            case 'pipeline':
                val = args[1];
                cb = args[2];
                client.pipeline(val).exec(function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'get':
                key = args[1];
                cb = args[2];
                client.get(key, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'set':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.set(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'incr':
                key = args[1];
                cb = args[2];
                client.incr(key, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'incrby':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.incrby(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'lpush':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.lpush(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'lset':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.lset(key, val, val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'lrange':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.lrange(key, val, val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'hset':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.hset(key, val, val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'hmset':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.hmset(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'hget':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.hget(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'hgetall':
                key = args[1];
                cb = args[2];
                client.hgetall(key, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'hincrby':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.hincrby(key, val, val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'expire':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.expire(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'sadd':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.sadd(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'sismember':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.sismember(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'smembers':
                key = args[1];
                cb = args[2];
                client.smembers(key, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'scard':
                key = args[1];
                cb = args[2];
                client.scard(key, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'zadd':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.zadd(key, val, val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'zcard':
                key = args[1];
                cb = args[2];
                client.zcard(key, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'zrevrange':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.zrevrange(key, val, val2, 'WITHSCORES', function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'zrem':
                key = args[1];
                val = args[2];
                cb = args[3];
                client.zrem(key, val, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'zremrangebyrank':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.zremrangebyrank(key, val, val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'zincrby':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.zincrby(key, val, val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'hscan':
                key = args[1];
                val = args[2];
                val2 = args[3];
                cb = args[4];
                client.hscan(key, val, 'count', val2, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'del':
                key = args[1];
                cb = args[2];
                client.del(key, function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
            case 'bgsave':
                cb = args[1];
                client.bgsave(function (err, res) {
                    _pool.release(client);
                    cb && cb(err, res);
                });
                break;
        }
    }).catch(function (err) {
        console.error(err.stack);
    });
};

/**
 * 封装 Promise
 * @returns {Promise<any>}
 */
NND.promiseOpt = function() {
    return new Promise((resolve)=>{
        NND.opt(...arguments, function (err, reply) {
            if (err){
                resolve({
                    code: 500,
                    msg: err.message
                });
            } else {
                resolve({
                    code: 200,
                    reply: reply
                });
            }
        });
    });
};

/**
 * 销毁连接池
 */
NND.shutdown = function () {
    _pool.drain().then(function () {
        _pool.clear();
    });
};

redisclient.init = function () {
    if (!!_pool) {
        return redisclient;
    } else {
        NND.init();
        redisclient.opt = NND.opt;
        redisclient.promiseOpt = NND.promiseOpt;
        return redisclient;
    }
};

redisclient.shutdown = function () {
    NND.shutdown();
};

结束

举报

相关推荐

0 条评论