Nodejs 分享一个原创memcache客户端 原来可以插入code的 重新编辑了下

Nodejs 分享一个原创memcache客户端

原来可以插入code的 重新编辑了下

在这个教程中，我们将创建一个简单的memcached客户端。该客户端将支持基本的操作，如设置、获取、删除键值对等。

var net = require('net');

exports.connect = function(port, host) {
    return new MemcachedClient(port, host);
}

function MemcachedClient(port, host) {
    this.conn = null;
    this.port = port || 11211;
    this.host = host || 'localhost';
    this.error = ['ERROR', 'NOT_FOUND', 'CLIENT_ERROR', 'SERVER_ERROR'];
    this.crlf = "\r\n";
    this.queue = [];
    this.nextData = '';
    this.init();
}

MemcachedClient.prototype = {
    init: function() {
        this.buffer = new Buffer('');
        this.cmd = null;
        this.callback = null;
        this.receiveTimes = 0;
        this.headLength = 0;
        this.bodyLength = 0;
        if (this.nextData.length > 0) this.receive(new Buffer(this.nextData));
    },
    connect: function(callback) {
        if (this.conn) return callback.call(this);
        var conn = net.connect(this.port, this.host),
            self = this;
        conn.on('connect', function() {
            self.conn = conn;
            callback.call(self);
        });
        conn.on('data', function(data) {
            self.receive(data);
        });
        conn.on('error', function(e) {
            console.log(e);
            setTimeout(function() {
                self.connect(callback);
            }, 10);
        });
    },
    fixKey: function(key) {
        return key.substr(0, 250).replace(/\s/g, '_');
    },
    query: function(data, callback, cmd) {
        var idx = data.indexOf(' '),
            cmd = cmd || (idx == -1 ? data : data.substr(0, idx)).toLowerCase();
        this.connect(function() {
            this.queue.push({
                cmd: cmd,
                callback: callback
            });
            this.conn.write(data + this.crlf);
        });
    },
    send: function(cmd, key, value, callback, lifetime, flags) {
        if (typeof(callback) !== 'function') {
            lifetime = callback;
            callback = null;
        }
        try {
            value = JSON.stringify(value);
        } catch (e) {
            try {
                value = value.toString();
            } catch (e) {
                value = '';
            }
        }
        var flags = flags || 0,
            lifetime = lifetime || 0,
            buffer = new Buffer(value),
            bufferLength = buffer.length || 0,
            query = [cmd, this.fixKey(key), flags, lifetime, bufferLength];
        this.query(query.join(' ') + this.crlf + value, callback);
    },
    receive: function(data) {
        if (this.receiveTimes === 0) {
            var last = this.queue.shift();
            this.cmd = last.cmd;
            this.callback = last.callback;
        }
        this.buffer = Buffer.concat([this.buffer, data]);
        this.receiveTimes++;
        var result = this[this.cmd + 'Handler']();
        if (result === null || result === undefined) return;
        try {
            this.callback(result);
        } catch (e) {}
        this.init();
    },
    add: function(key, value, callback, lifetime, flags) {
        this.send('add', key, value, callback, lifetime, flags);
    },
    set: function(key, value, callback, lifetime, flags) {
        this.send('set', key, value, callback, lifetime, flags);
    },
    replace: function(key, value, callback, lifetime, flags) {
        this.send('replace', key, value, callback, lifetime, flags);
    },
    get: function(key, callback) {
        this.query('get ' + this.fixKey(key), callback);
    },
    delete: function(key, callback) {
        this.query('delete ' + this.fixKey(key), callback);
    },
    flush: function(callback) {
        this.query('flush_all', callback, 'flush');
    },
    stats: function(callback) {
        this.query('stats', callback);
    },
    version: function(callback) {
        this.query('version', callback);
    },
    close: function() {
        var self = this;
        if (this.queue.length === 0) {
            this.conn.end();
            this.conn.destroy();
            this.conn = null;
        } else {
            setTimeout(function() {
                self.close();
            }, 10);
        }
    },
    getLine: function(data, line) {
        if (Buffer.isBuffer(data)) data = data.toString();
        var line = line ? parseInt(line) : 0,
            data = data.split("\n");
        return data[line] ? data[line] + "\n" : false;
    },
    storeHandler: function() {
        var line = this.getLine(this.buffer);
        this.nextData = this.buffer.slice(new Buffer(line).length);
        if (line.toLowerCase().trim() === 'stored') {
            return true;
        } else {
            return false;
        }
    },
    addHandler: function() {
        return this.storeHandler();
    },
    setHandler: function() {
        return this.storeHandler();
    },
    replaceHandler: function() {
        return this.storeHandler();
    },
    getHandler: function() {
        if (this.receiveTimes === 1) {
            var line = this.getLine(this.buffer),
                header = line.split(/\s+/g);
            if (header[0].toLowerCase() === 'end') return false;
            this.headLength = new Buffer(line).length;
            this.bodyLength = parseInt(header[3]);
        }
        var bufferLength = this.buffer.length,
            dataLength = this.headLength + this.bodyLength + 'END'.length + 2 * this.crlf.length;
        if (bufferLength >= dataLength) {
            var body = this.buffer.slice(this.headLength, this.headLength + this.bodyLength).toString();
            this.nextData = this.buffer.slice(dataLength).toString();
            try {
                return JSON.parse(body);
            } catch (e) {
                return body;
            }
        }
        return null;
    },
    deleteHandler: function() {
        var line = this.getLine(this.buffer);
        this.nextData = this.buffer.slice(new Buffer(line).length);
        if (line.toLowerCase().trim() === 'deleted') {
            return true;
        } else {
            return false;
        }
    },
    flushHandler: function() {
        var line = this.getLine(this.buffer);
        this.nextData = this.buffer.slice(new Buffer(line).length);
        if (line.toLowerCase().trim() === 'ok') {
            return true;
        } else {
            return false;
        }
    },
    statsHandler: function() {
        var buffer = this.buffer.toString(),
            idx = buffer.indexOf('END');
        if (idx !== -1) {
            var lines = buffer.trim().split("\n");
            var stats = {};
            for (var i = 0; i < lines.length - 1; i++) {
                var line = lines[i].trim().split(/\s+/g);
                stats[line[1]] = line[2];
            }
            this.nextData = new Buffer(buffer.substr(idx + 'END'.length + this.crlf.length));
            return stats;
        }
        return null;
    },
    versionHandler: function() {
        var line = this.getLine(this.buffer),
            header = line.split(/\s+/);
        this.nextData = this.buffer.slice(new Buffer(line).length);
        return header[1];
    }
}

示例用法

var client = require('./memcached').connect(11211, 'localhost');

client.set('key', 'value', function(err, result) {
    if (err) {
        console.error('Set failed:', err);
    } else {
        console.log('Set successful:', result);
    }
});

client.get('key', function(err, result) {
    if (err) {
        console.error('Get failed:', err);
    } else {
        console.log('Get successful:', result);
    }
});

client.delete('key', function(err, result) {
    if (err) {
        console.error('Delete failed:', err);
    } else {
        console.log('Delete successful:', result);
    }
});

总结

通过上述代码，我们实现了一个基本的memcached客户端，能够执行常见的操作如set、get和delete。希望这个简单的示例能帮助你更好地理解如何使用Node.js编写memcached客户端。