redis——redis简介及基本交互方法

Redis是一个速度非常快的非关系数据库（non-relational database），它可以存储键（key）与5种不同类型的值（value）之间的映射（mapping），可以将存储在内存的键值对数据持久化到硬盘，可以使用复制特性来扩展读性能，还可以使用客户端分片1来扩展写性能，接下来的几节将分别介绍Redis的这几个特性。

其重点是在内存中存储，所以相比普通数据库，其IO效率会快很多。

在使用类似Redis这样的内存数据库时，一个首先要考虑的问题就是“当服务器被关闭时，服务器存储的数据将何去何从呢？”Redis拥有两种不同形式的持久化方法，它们都可以用小而紧凑的格式将存储在内存中的数据写入硬盘：第一种持久化方法为时间点转储（point-in-time dump），转储操作既可以在“指定时间段内有指定数量的写操作执行”这一条件被满足时执行，又可以通过调用两条转储到硬盘（dump-to-disk）命令中的任何一条来执行；第二种持久化方法将所有修改了数据库的命令都写入一个只追加（append-only）文件里面，用户可以根据数据的重要程度，将只追加写入设置为从不同步（sync）、每秒同步一次或者每写入一个命令就同步一次。

Redis可以存储键与5种不同数据结构类型之间的映射，这5种数据结构类型分别为STRING（字符串）、LIST（列表）、SET（集合）、HASH（散列）和ZSET（有序集合）。有一部分Redis命令对于这5种结构都是通用的，如DEL、TYPE、RENAME等；但也有一部分Redis命令只能对特定的一种或者两种结构使用

redis连接方法与sql等差不多，设置IP，端口，建立连接。

redis = require('redis'),//导入js模块
RDS_PORT = ,        //端口号
RDS_HOST = '',    //服务器IP
RDS_OPTS = {},            //设置项
redisdb = redis.createClient(RDS_PORT, RDS_HOST, RDS_OPTS);//创建连接

redisdb.select(20);//指定分区库

createClient事件中会调用connerct、ready等相关方法，我们可以在此处打日志查看

redisdb.on('ready', function (res) {
    console.log('ready');
});

redisdb.on('connect', function () {
    console.log('connect');
});

redis基本读写数据方法——set，get，del。

redis存储需要一个key（字符型），通过key作为下标从而进行设置、读取、删除等操作。

以下为js里redis模块的方法

get：get(key, function (err, data)  第一个返回值为错误码，第二个为数据。

set：set(key,value, function (err,result)返回错误码及操作情况，若成功返回OK

del：del(key, function (err, result) 返回错误码及影响行数，通常为1，如key不存在则返回0

顺便一提，由于js是异步的，所以像redis这种io相关操作要采用回调的方式实现。

我们简单做一个测试函数：

exports.redisdb = redisdb;

function redis_opt(opt, key, value, callback) {

    if (opt == 'get') {
        redisdb.get(key, function (err, data) {
            if (err == null) {
                callback(data);
            }
            else {
                callback(err);
            }
        });
    }
    else if (opt == 'set')
    {
        redisdb.set(key,value, function (err,result) {
            if (err == null) {
                callback(result);
            }
            else {
                callback(err);
            }
        });
    }
    else if (opt == 'del')
    {
        redisdb.del(key, function (err, result) {
            if (err == null) {
                callback(result);
            }
            else {
                callback(err);
            }
        });
    }
    else
    {
        callback("error opt!");
    }
    
}


function testmain()
{
    console.log(redisdb);

    //var opt = "set";
    var key = "order1";
    var value ="hello word";
    redis_opt("set", key, value, function (data)
    { 
        console.log(data);    
    });


    redis_opt("get", key, value, function (data) {
        console.log(data);
    });


    redis_opt("del", key, value, function (data) {
        console.log(data);
    });


}

testmain();

输出：

RedisClient {
  domain: null,
  _events:
   { newListener: [Function],
     ready: [Function],
     connect: [Function] },
  _eventsCount: 3,
  _maxListeners: undefined,
  address: '主机IP:端口',
  connection_options: { port: 端口, ho
  connection_id: 0,
  connected: false,
  ready: false,
  should_buffer: true,
  max_attempts: 0,
  command_queue: { [String: ''] _capac
  offline_queue: { [String: '[object O
: 0 },
  pipeline_queue: { [String: ''] _capa
  connect_timeout: 3600000,
  enable_offline_queue: true,
  retry_max_delay: null,
  retry_timer: null,
  retry_totaltime: 0,
  retry_delay: 200,
  retry_backoff: 1.7,
  attempts: 1,
  pub_sub_mode: 0,
  subscription_set: {},
  monitoring: false,
  message_buffers: false,
  closing: false,
  server_info: {},
  auth_pass: undefined,
  selected_db: undefined,
  old_state: null,
  fire_strings: true,
  pipeline: false,
  sub_commands_left: 0,
  times_connected: 0,
  buffers: false,
  options:
   { port: 端口,
     host: '主机IP',
     socket_nodelay: true,
     socket_keepalive: true,
     return_buffers: false,
     detect_buffers: false },
  reply: 'ON',
  reply_parser:
   JavascriptRedisParser {
     optionReturnBuffers: false,
     optionStringNumbers: false,
     returnError: [Function: returnErr
     returnFatalError: [Function: retu
     returnReply: [Function: returnRep
     name: 'javascript',
     offset: 0,
     buffer: null,
     bigStrSize: 0,
     bigOffset: 0,
     totalChunkSize: 0,
     bufferCache: [],
     arrayCache: [],
     arrayPos: [] },
  stream:
   Socket {
     connecting: true,
     _hadError: false,
     _handle:
      TCP {
        bytesRead: 0,
        _externalStream: {},
        fd: -1,
        reading: false,
        owner: [Circular],
        onread: [Function: onread],
        onconnection: null,
        writeQueueSize: 0 },
     _parent: null,
     _host: null,
     _readableState:
      ReadableState {
        objectMode: false,
        highWaterMark: 16384,
        buffer: [Object],
        length: 0,
        pipes: null,
        pipesCount: 0,
        flowing: true,
        ended: false,
        endEmitted: false,
        reading: false,
        sync: true,
        needReadable: false,
        emittedReadable: false,
        readableListening: false,
        resumeScheduled: true,
        defaultEncoding: 'utf8',
        ranOut: false,
        awaitDrain: 0,
        readingMore: false,
        decoder: null,
        encoding: null },
     readable: false,
     domain: null,
     _events:
      { end: [Object],
        finish: [Function: onSocketFin
        _socketEnd: [Function: onSocke
        connect: [Object],
        data: [Function],
        error: [Function],
        clientError: [Function],
        close: [Object],
        drain: [Function] },
     _eventsCount: 9,
     _maxListeners: undefined,
     _writableState:
      WritableState {
        objectMode: false,
        highWaterMark: 16384,
        needDrain: false,
        ending: false,
        ended: false,
        finished: false,
        decodeStrings: false,
        defaultEncoding: 'utf8',
        length: 0,
        writing: false,
        corked: 0,
        sync: true,
        bufferProcessing: false,
        onwrite: [Function],
        writecb: null,
        writelen: 0,
        bufferedRequest: null,
        lastBufferedRequest: null,
        pendingcb: 0,
        prefinished: false,
        errorEmitted: false,
        bufferedRequestCount: 0,
        corkedRequestsFree: [Object] }
     writable: true,
     allowHalfOpen: false,
     destroyed: false,
     _bytesDispatched: 0,
     _sockname: null,
     _pendingData: null,
     _pendingEncoding: '',
     server: null,
     _server: null } }
connect
ready
OK
hello word
1

注：

前面的为redisdb成员

connect、ready为自发事件里的日志内容

set返回OK

get返回hello word

del 返回 1

插入数据成功后：