[关闭]
@sasaki 2016-01-27T10:32:27.000000Z 字数 16879 阅读 3619

NoSQL与Redis分布式缓存数据库

Redis

版本控制

  1.     @Title          NoSQL与Redis分布式缓存数据库
  2.     @Version        v1.0
  3.     @Timestamp      2015-01-19 16:42
  4.     @Author         Nicholas
  5.     @Mail           redskirt@outlook.com

一、NoSQL介绍

  1. 简介
    NoSQL是以key-value形式存储，和传统的关系型数据库不一样，不一定遵循传统数据库的一些基本要求，比如SQL标准、ACID属性、表结构等，这类数据库主要有以下特点：非关系型、分布式、开源、水平可拓展等。

  2. 适用场景

    • 对数据库高并发读写
    • 对海量数据的高效率存储和访问
    • 对数据的高可扩展性和高可用性

二、Redis概述

  1. Redis是一个Key-Value的存储系统。它支持存储的value类型很多，包括string（字符串）、list（链表）、set（集合）、zset（有序集合）。这些数据类型都支持p**ush/pub、add/remove**及取秶和并集及更丰富的操作，Redis支持各种不同方式的排序。为了保证效率，数据都是缓存在内存中，它也可以周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件。

  2. Redis适用场合

    1）应用直接访问Redis
    QQ截图20160119165246.jpg-219.3kB

    2）应用程序直接访问Redis，当Redis访问失败时访问MySQL
    QQ截图20160119165543.jpg-388.1kB

    • 取最新N个数据的操作
    • 排行榜应用，取TopN操作
    • 需要精确设定过期时间的应用
    • 计数器应用
    • Uniq操作，获取某段时间所有数据排重值
    • 实时系统，反垃圾系统
    • Pub/Sub构建实时消息系统
    • 构建队列系统
    • 缓存

  3. Redis主要配置含义

    • daemonize：是否以后台daemon方式运行
    • pidfile：pid文件位置
    • port：监听的端口号
    • timeout：请求超时时间
    • loglevel：log信息级别
    • logfile：log文件位置
    • databases：开启数据库的数量
    • save * ：保存快照的频率，第一个表示多长时间，第三个*表示执行多少次写操作。在一定时间内执行一定数量的写操作时，自动保存快照。可设置多个条件。
    • rdbcompression：是否使用压缩
    • dbfilename：数据快照文件名（只是文件名，不包括目录）
    • dir：数据快照的保存目录（这个是目录）
    • appendonly：是否开启appendonlylog，开启的话每次写操作会记一条log，这会提高数据抗风险能力，但影响效率
    • appendfsync：appendonlylog如何同步到磁盘（三个选项，分别是每次写都强制调用fsync、每秒启用一次fsync、不调用fsync等待系统自己同步）

三、Redis应用

  1. Redis数据类型
    string：一个Key对应一个Value，string类型是二进制安全的。Redis的string可以包含任何对象，比如jpg图片或序列化的对象。

    1. [root@master ~]# netstat -tunpl|grep 6379
    2. tcp        0      0 0.0.0.0:6379                0.0.0.0:*                   LISTEN      28424/redis-server  
    3. tcp        0      0 :::6379                     :::*                        LISTEN      28424/redis-server
    4. [root@master redis-3.0.6]# redis-cli
    6. # set
    8. 127.0.0.1:6379> set str hello
    9. OK
    11. # get
    13. 127.0.0.1:6379> get str
    14. "hello"
    16. # setnx：设置key对应的值为string类型的value，如果key已经存在，返回0，nx是not exist的意思
    18. 127.0.0.1:6379> setnx str hello
    19. (integer) 0
    21. # setex：设置key对应的值为string类型的value，并指定此键值对应的有效期
    23. 127.0.0.1:6379> setex str_ 10 test
    24. OK
    25. 127.0.0.1:6379> get str_
    26. "test"
    27. 127.0.0.1:6379> get str_
    28. (nil)
    30. # setrange：设置指定key的value值的子字符串
    32. 127.0.0.1:6379> set num 123456789
    33. OK
    34. 127.0.0.1:6379> get num
    35. "123456789"
    36. 127.0.0.1:6379> setrange num 6 666
    37. (integer) 9
    38. 127.0.0.1:6379> get num
    39. "123456666"
    41. # mset：设置多个key的值，成功返回ok，失败返回0表示没有任何值被设置
    43. 127.0.0.1:6379> mset key1 liuwei key2 nicholas key3 sasaki
    44. OK
    45. 127.0.0.1:6379> get key1
    46. "liuwei"
    47. 127.0.0.1:6379> get key2
    48. "nicholas"
    49. 127.0.0.1:6379> get key3
    50. "sasaki"
    52. # mset x：设置多个key的值，成功返回ok，失败返回0表示没有任何值被设置，但是不会覆盖已存在的key
    54. 127.0.0.1:6379> msetnx key1 liuwei_ key4 test
    55. (integer) 0
    56. 127.0.0.1:6379> get key1
    57. "liuwei"
    58. 127.0.0.1:6379> get key4
    59. (nil)
    61. # get：获取key的string值，若不存在返回nil
    64. # getset：设置key值并且返回key的旧值
    66. 127.0.0.1:6379> getset key1 test
    67. "liuwei"
    68. 127.0.0.1:6379> get key1
    69. "test"
    71. # getrange：获取key的子字符串
    73. 127.0.0.1:6379> get key2
    74. 127.0.0.1:6379> getrange key2 0 4
    75. "nicho"
    77. # mget：指获取key的子字符串，若不存在刚返回nil
    79. 127.0.0.1:6379> mget key1 key2 key3 0 4
    80. 1) "test"
    81. 2) "nicholas"
    82. 3) "sasaki"
    83. 4) (nil)
    84. 5) (nil)
    86. # incr：对key的值作加加操作，返回新值
    88. 127.0.0.1:6379> set num 10
    89. OK
    90. 127.0.0.1:6379> get num
    91. "10"
    92. 127.0.0.1:6379> incr num
    93. (integer) 11
    94. 127.0.0.1:6379> incr num
    95. (integer) 12
    97. # incrby：同incr，加指定值，key值不存在会设置key，并认为原key值为0
    99. 127.0.0.1:6379> incrby num_ 20
    100. (integer) 20
    101. 127.0.0.1:6379> incrby num__ 6
    102. (integer) 6
    103. 127.0.0.1:6379> incrby num__ 6
    104. (integer) 12
    105. 127.0.0.1:6379> incrby num__ 6
    106. (integer) 18
    108. # decr：对key的值作减减操作，返回新值
    111. # decrby：同decr，减指定值，key值不存在会设置key，并认为原key值为0
    114. # append：给指定key的字符串追加value，返回新字符串值的长度
    116. 127.0.0.1:6379> set head redskirt
    117. OK
    118. 127.0.0.1:6379> append head @outlook.com
    119. (integer) 20
    120. 127.0.0.1:6379> get head
    121. "redskirt@outlook.com"
    123. # strlen：取指定key的value值的长度
    125. 127.0.0.1:6379> strlen head
    126. (integer) 20

    hashes：Redis hash是一个string类型的filed和value的映射表。它的添加、删除操作都是0(1)（平均）。hash特别合适用于存储对象。相比于将对象的每个字段存成单个string类型，将一个对象存储在hash类型中会占用更少的内存，并且可以更方便的存取整个对象。

    2. # hset：设置hash field为指定值，如果key不存在，刚先创建
    4. 127.0.0.1:6379> hset user:001 name nicholas
    5. (integer) 1
    6. 127.0.0.1:6379> hget user:001 name
    7. "nicholas"
    9. # hsetnx：设置hash field为指定值，如果key不存在刚先创建，如果存在返回0
    11. 127.0.0.1:6379> hsetnx user:002 name lamp
    12. (integer) 1
    13. 127.0.0.1:6379> hget user:002 name
    14. "lamp"
    15. 127.0.0.1:6379> hsetnx user:002 name lamp
    16. (integer) 0
    18. # hmset：同时设置hash的多个field
    20. 127.0.0.1:6379> hmset user:003 name nicholas age 20 gender m
    21. OK
    22. 127.0.0.1:6379> hget user:003 age
    23. "20"
    24. 127.0.0.1:6379> hget user:003 gender
    25. "m"
    27. # hget：获取hash field的值
    30. # hmget：获取全部指定的hash filed
    32. 127.0.0.1:6379> hmget user:003 name age gender
    33. 1) "nicholas"
    34. 2) "20"
    35. 3) "m"
    37. # hincrby：给指定的hash filed加上指定值
    39. 127.0.0.1:6379> hincrby user:003 age 3
    40. (integer) 23
    42. # gexists：判断指定filed是否存在
    44. 127.0.0.1:6379> hexists user:003 age
    45. (integer) 1
    46. 127.0.0.1:6379> hexists user:003 age_
    47. (integer) 0
    49. # hlen：返回指定hash的filed的数量
    51. 127.0.0.1:6379> hlen user:003
    52. (integer) 3
    54. # ldel：删除指定hash的filed
    56. 127.0.0.1:6379> hdel user:003 age
    57. (integer) 1
    58. 127.0.0.1:6379> hget user:003 age
    59. (nil)
    61. # hkeys：返回hash的所有filed
    63. 127.0.0.1:6379> hkeys user:003
    64. 1) "name"
    65. 2) "gender"
    67. # hgetall：获取某hash中全部的file及value
    69. 127.0.0.1:6379> hgetall user:003
    70. 1) "name"
    71. 2) "nicholas"
    72. 3) "gender"
    73. 4) "m"

    lists：List是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作中key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。可以通过push、pop操作从链表的头部或者尾部添加删除元素，这样List既可作为栈，又可以作为队列。

    2. # lpush：在key对应list的头部添加字符串元素，模拟栈
    4. 127.0.0.1:6379> lpush list 1
    5. (integer) 1
    6. 127.0.0.1:6379> lpush list 2
    7. (integer) 2
    8. 127.0.0.1:6379> lpush list 3
    9. (integer) 3
    10. 127.0.0.1:6379> lrange list 0 -1
    11. 1) "3"
    12. 2) "2"
    13. 3) "1"
    15. # rpush：在key对应list的尾部添加字符串元素，模拟队列
    17. 127.0.0.1:6379> lpush list_ 1
    18. (integer) 1
    19. 127.0.0.1:6379> lpush list_ 2
    20. (integer) 2
    21. 127.0.0.1:6379> lpush list_ 3
    22. (integer) 3
    23. 127.0.0.1:6379> lrange list_ 0 -1
    24. 1) "1"
    25. 2) "2"
    26. 3) "3"
    28. # linsert：在key对应的list的特定位置前或后添加字符串
    30. 127.0.0.1:6379> lpush list3 1
    31. (integer) 1
    32. 127.0.0.1:6379> lpush list3 2
    33. (integer) 2
    34. 127.0.0.1:6379> lrange list3 0 -1
    35. 1) "2"
    36. 2) "1"
    37. 127.0.0.1:6379> linsert list3 before 1 3
    38. (integer) 3
    39. 127.0.0.1:6379> lrange list3 0 -1
    40. 1) "2"
    41. 2) "3"
    42. 3) "1"
    44. # lset：设置List中指定下标的元素值
    46. 127.0.0.1:6379> lrange list3 0 -1
    47. 1) "2"
    48. 2) "3"
    49. 3) "1"
    50. 127.0.0.1:6379> lset list3 0 4
    51. OK
    52. 127.0.0.1:6379> lrange list3 0 -1
    53. 1) "4"
    54. 2) "3"
    55. 3) "1"
    57. # lrem：从key对应的List中删除n个和value相同的元素。（n<0从尾删除，n=0全部删除）
    59. 127.0.0.1:6379> lrange list3 0 -1
    60. 1) "4"
    61. 2) "3"
    62. 3) "1"
    63. 127.0.0.1:6379> lrem list3 1 4
    64. (integer) 1
    65. 127.0.0.1:6379> lrange list3 0 -1
    66. 1) "3"
    67. 2) "1"
    68. 127.0.0.1:6379> lpush list3 5
    69. (integer) 3
    70. 127.0.0.1:6379> lpush list3 5
    71. (integer) 4
    72. 127.0.0.1:6379> lpush list3 5
    73. (integer) 5
    74. 127.0.0.1:6379> lrange list3 0 -1
    75. 1) "5"
    76. 2) "5"
    77. 3) "5"
    78. 4) "3"
    79. 5) "1"
    80. 127.0.0.1:6379> lrem list3 0 5
    81. (integer) 3
    82. 127.0.0.1:6379> lrange list3 0 -1
    83. 1) "3"
    84. 2) "1"
    86. # ltrim：保留指定key的值范围内的数据
    88. 127.0.0.1:6379> lpush list5 1 2 3 4 5 6
    89. (integer) 6
    90. 127.0.0.1:6379> lrange list5 0 -1
    91. 1) "6"
    92. 2) "5"
    93. 3) "4"
    94. 4) "3"
    95. 5) "2"
    96. 6) "1"
    97. 127.0.0.1:6379> ltrim list5 0 3
    98. OK
    99. 127.0.0.1:6379> lrange list5 0 -1
    100. 1) "6"
    101. 2) "5"
    102. 3) "4"
    103. 4) "3"
    105. # lpop：从List的头部删除元素，并返回删除元素
    107. 127.0.0.1:6379> lrange list5 0 -1
    108. 1) "6"
    109. 2) "5"
    110. 3) "4"
    111. 4) "3"
    112. 127.0.0.1:6379> lpop list5
    113. "6"
    114. 127.0.0.1:6379> lrange list5 0 -1
    115. 1) "5"
    116. 2) "4"
    117. 3) "3"
    119. # rpop：从List的尾部删除元素，并返回删除元素
    121. 127.0.0.1:6379> rpop list5
    122. "3"
    123. 127.0.0.1:6379> lrange list5 0 -1
    124. 1) "5"
    125. 2) "4"
    127. # rpoplpush：从第一个List的尾部移除元素并添加到第二个List的头部
    129. 127.0.0.1:6379> rpush list9 1 2 
    130. (integer) 2
    131. 127.0.0.1:6379> rpush list10 1 2 
    132. (integer) 2
    133. 127.0.0.1:6379> lrange list9 0 -1
    134. 1) "1"
    135. 2) "2"
    136. 127.0.0.1:6379> lrange list10 0 -1
    137. 1) "1"
    138. 2) "2"
    139. 127.0.0.1:6379> rpoplpush list9 list10
    140. "2"
    141. 127.0.0.1:6379> lrange list9 0 -1
    142. 1) "1"
    143. 127.0.0.1:6379> lrange list10 0 -1
    144. 1) "2"
    145. 2) "1"
    146. 3) "2"
    148. # lindex：返回名称为key的List中的index位置的元素
    150. 127.0.0.1:6379> lrange list10 0 -1
    151. 1) "2"
    152. 2) "1"
    153. 3) "2"
    154. 127.0.0.1:6379> lindex list10 0
    155. "2"
    156. 127.0.0.1:6379> lindex list10 1
    157. "1"
    159. # llen：返回key对应的List的长度
    161. 127.0.0.1:6379> llen list10
    162. (integer) 3

    sets：Set是string类型的无序集合，通过hash table实现，添加、删除和查找的复杂度都是0(1)，可以对集合取并集、交集、差集。通过这些操作可以实现SNS好友推荐和Blog的Tag功能。

    2. # sadd：向名称为key的Set中添加元素
    4. 127.0.0.1:6379> sadd set1 1
    5. (integer) 1
    6. 127.0.0.1:6379> sadd set1 2
    7. (integer) 1
    8. 127.0.0.1:6379> sadd set1 2
    9. (integer) 0
    10. 127.0.0.1:6379> smembers set1
    11. 1) "1"
    12. 2) "2"
    14. # srem：删除名称为key的Set中的元素
    16. 127.0.0.1:6379> srem set1 2
    17. (integer) 1
    18. 127.0.0.1:6379> srem set1 2
    19. (integer) 0
    20. 127.0.0.1:6379> smembers set1
    21. 1) "1"
    23. # spop：随机返回并删除名称为key的Set中的一个元素
    25. 127.0.0.1:6379> smembers set2
    26. 1) "1"
    27. 2) "2"
    28. 3) "3"
    29. 4) "4"
    30. 5) "5"
    31. 127.0.0.1:6379> spop set2
    32. "3"
    33. 127.0.0.1:6379> spop set2
    34. "1"
    35. 127.0.0.1:6379> spop set2
    36. "5"
    37. 127.0.0.1:6379> smembers set2
    38. 1) "2"
    39. 2) "4"
    41. # sdiff：返回所有给定key与第一个key的差集
    43. 127.0.0.1:6379> smembers set2
    44. 1) "2"
    45. 2) "4"
    46. 127.0.0.1:6379> smembers set3
    47. 1) "1"
    48. 2) "2"
    49. 3) "3"
    50. 4) "4"
    51. 127.0.0.1:6379> sdiff set2 set3
    52. (empty list or set)
    53. 127.0.0.1:6379> sdiff set3 set2
    54. 1) "1"
    55. 2) "3"
    57. # sinter：返回所有给定key的交集
    59. 127.0.0.1:6379> sinter set2 set3
    60. 1) "2"
    61. 2) "4"
    63. # sinterstore：返回所有给定key的交集，并将结果存为另一个key
    65. 127.0.0.1:6379> smembers set2
    66. 1) "2"
    67. 2) "4"
    68. 127.0.0.1:6379> smembers set3
    69. 1) "1"
    70. 2) "2"
    71. 3) "3"
    72. 4) "4"
    73. 127.0.0.1:6379> sinterstore set4 set2 set3
    74. (integer) 2
    75. 127.0.0.1:6379> smembers set4
    76. 1) "2"
    77. 2) "4"
    79. # sunion：返回所有给定的key的并集
    81. 127.0.0.1:6379> sunion set2 set3
    82. 1) "1"
    83. 2) "2"
    84. 3) "3"
    85. 4) "4"
    87. # sunionstore：返回所有给定key的并集，并将结果存为另一个key
    89. 127.0.0.1:6379> sunionstore set5 set2 set3
    90. (integer) 4
    91. 127.0.0.1:6379> smembers set5
    92. 1) "1"
    93. 2) "2"
    94. 3) "3"
    95. 4) "4"
    97. # smove：从第一个key对应的Set中移除member并添加到第二个对应的Set中
    99. 127.0.0.1:6379> smove set2 set3 2
    100. (integer) 1
    101. 127.0.0.1:6379> smembers set2
    102. 1) "4"
    103. 127.0.0.1:6379> smembers set3
    104. 1) "1"
    105. 2) "2"
    106. 3) "3"
    107. 4) "4"
    109. # scard：返回名称为key的Set的元素个数
    111. 127.0.0.1:6379> scard set3
    112. (integer) 4
    114. # sismember：判断member是否为名称为key的Set的元素
    116. 127.0.0.1:6379> scard set3
    117. (integer) 4
    118. 127.0.0.1:6379> sismember set3 1
    119. (integer) 1
    120. 127.0.0.1:6379> sismember set3 5
    121. (integer) 0
    123. # srandmember：随机返回名称为key的Set的一个元素，但不删除元素
    125. 127.0.0.1:6379> srandmember set3
    126. "2"
    127. 127.0.0.1:6379> srandmember set3
    128. "1"
    129. 127.0.0.1:6379> srandmember set3
    130. "3"
    131. 127.0.0.1:6379> smembers set3
    132. 1) "1"
    133. 2) "2"
    134. 3) "3"
    135. 4) "4"

    sorted set：sorted set在set的基础上增加了顺序属性，在添加元素时可以指定顺序，每次指定后，zset会自动重新按新的值调整顺序。可以理解为有两列的Mysql表，一列存Value，一列存顺序。操作中key理解为zset的名字。

    2. # zadd：向名称为key的Zset中添加元素member,score用于排序。如果该元素存在则更新其顺序。
    4. 127.0.0.1:6379> zadd zset1 1 one
    5. (integer) 1
    6. 127.0.0.1:6379> zadd zset1 2 two
    7. (integer) 1
    8. 127.0.0.1:6379> zadd zset1 3 two
    9. (integer) 0
    10. 127.0.0.1:6379> zadd zset1 4 four 
    11. (integer) 1
    12. 127.0.0.1:6379> zrange zset1 0 -1 withscores
    13. 1) "one"
    14. 2) "1"
    15. 3) "two"
    16. 4) "3"
    17. 5) "four"
    18. 6) "4"
    20. # zrem：删除名称为key的Zset中的元素member
    22. 127.0.0.1:6379> zrem zset1 two
    23. (integer) 1
    24. 127.0.0.1:6379> zrem zset1 two
    25. (integer) 0
    26. 127.0.0.1:6379> zrange zset1 0 -1 withscores
    27. 1) "one"
    28. 2) "1"
    29. 3) "four"
    30. 4) "4"
    32. # zincrby：如果在名称为key的Zset中已经存在元素member，则该元素的score增加incrememt，否则向该集合中添加该元素，其中score的值为increment
    34. 127.0.0.1:6379> zincrby zset1 2 one
    35. "3"
    36. 127.0.0.1:6379> zincrby zset1 4 five
    37. "4"
    38. 127.0.0.1:6379> zrange zset1 0 -1 withscores
    39. 1) "one"
    40. 2) "3"
    41. 3) "five"
    42. 4) "4"
    43. 5) "four"
    44. 6) "4"
    46. # zrank：返回名称为key的Zset中memmber的元素排名（按score升序排序），即下标
    48. 127.0.0.1:6379> zrank zset1 one
    49. (integer) 0
    50. 127.0.0.1:6379> zrank zset1 five
    51. (integer) 1
    52. 127.0.0.1:6379> zrank zset1 four
    53. (integer) 2
    55. # zrevrank：返回名称为key的Zset中memmber的元素排名（按score降序排序），即下标
    57. 127.0.0.1:6379> zrevrank zset1 one
    58. (integer) 2
    59. 127.0.0.1:6379> zrevrank zset1 five
    60. (integer) 1
    61. 127.0.0.1:6379> zrevrank zset1 four
    62. (integer) 0
    64. # zrevrange：返回名称为key的Zset（按score降序）中的index从start到end的所有元素
    66. 127.0.0.1:6379> zrevrange zset2 0 -1 withscores
    67. 1) "four"
    68. 2) "4"
    69. 3) "three"
    70. 4) "3"
    71. 5) "two"
    72. 6) "2"
    73. 7) "one"
    74. 8) "1"
    76. # zrangebyscore：返回集合中score在给定区间的元素
    78. 127.0.0.1:6379> zrangebyscore zset2 2 4 withscores
    79. 1) "two"
    80. 2) "2"
    81. 3) "three"
    82. 4) "3"
    83. 5) "four"
    84. 6) "4"
    86. # zcount：返回集合中score在给定区间的数量
    88. 127.0.0.1:6379> zcount zset2 1 4
    89. (integer) 4
    91. # zcard：返回集合中的元素个数
    93. 127.0.0.1:6379> zcard zset2
    94. (integer) 4
    96. # zremrangebyrank：依据索引删除集合中排名在给定区间的元素
    98. 127.0.0.1:6379> zremrangebyrank zset2 1 3
    99. (integer) 3
    100. 127.0.0.1:6379> zrange zset2 0 -1 withscores
    101. 1) "one"
    102. 2) "1"
    104. # zremrangebyscore：依据顺序删除集合中排名在给定区间的元素
    106. 127.0.0.1:6379> zrange zset3 0 -1 withscores
    107.  1) "one"
    108.  2) "1"
    109.  3) "two"
    110.  4) "2"
    111.  5) "three"
    112.  6) "3"
    113.  7) "four"
    114.  8) "4"
    115.  9) "five"
    116. 10) "5"
    117. 127.0.0.1:6379> zremrangebyscore zset3 1 3
    118. (integer) 3
    119. 127.0.0.1:6379> zrange zset3 0 -1 withscores
    120. 1) "four"
    121. 2) "4"
    122. 3) "five"
    123. 4) "5"

  2. Redis常用命令

    1）键值相关命令

    2. # keys：返回满足给定pattern的所有key
    4. 127.0.0.1:6379> keys *
    5.  1) "num__"
    6.  2) "num"
    7.  3) "head"
    8.  4) "set4"
    9.  5) "zset1"
    10.  6) "hello"
    11.  7) "zset3"
    12.  8) "list3"
    13.  9) "list4"
    14. 10) "set2"
    15. 127.0.0.1:6379> keys set*
    16. 1) "set4"
    17. 2) "set2"
    18. 3) "set1"
    19. 4) "set3"
    20. 5) "set5"
    22. # exists：确认一个key是否存在
    24. 127.0.0.1:6379> exists zset
    25. (integer) 0
    26. 127.0.0.1:6379> exists zset1
    27. (integer) 1
    29. # del：删除一个key
    31. 127.0.0.1:6379> del set3
    32. (integer) 1
    33. 127.0.0.1:6379> exists set3
    34. (integer) 0
    36. # expire：设置一个key的过期时间
    38. 127.0.0.1:6379> expire set1 10
    39. (integer) 1
    40. 127.0.0.1:6379> ttl set1
    41. (integer) -2
    43. # move：移动key到指定数据库
    45. 127.0.0.1:6379> exists set5
    46. (integer) 1
    47. 127.0.0.1:6379> move set5 1
    48. (integer) 1
    49. 127.0.0.1:6379> exists set5
    50. (integer) 0
    51. 127.0.0.1:6379> select 1
    52. OK
    53. 127.0.0.1:6379[1]> exists set5
    54. (integer) 1
    56. # persist：移除给定key的过期时间
    58. 127.0.0.1:6379[1]> expire set5 300
    59. (integer) 1
    60. 127.0.0.1:6379[1]> ttl set5
    61. (integer) 294
    62. 127.0.0.1:6379[1]> persist set5
    63. (integer) 1
    64. 127.0.0.1:6379[1]> ttl set5
    65. (integer) -1
    67. # randomkey：随机返回key空间的一个key
    69. 127.0.0.1:6379> randomkey
    70. "list6"
    71. 127.0.0.1:6379> randomkey
    72. "key3"
    73. 127.0.0.1:6379> randomkey
    74. "list10"
    75. 127.0.0.1:6379> randomkey
    76. "head"
    78. # rename：重命名key
    80. 127.0.0.1:6379> rename key3 key30
    81. OK
    82. 127.0.0.1:6379> exists key3
    83. (integer) 0
    84. 127.0.0.1:6379> exists key30
    85. (integer) 1
    87. # type：返回值的类型
    89. 127.0.0.1:6379> type key30
    90. string
    91. 127.0.0.1:6379> type zset3
    92. zset

    2）服务器相关命令

    2. # ping：测试连接是否存活
    4. 127.0.0.1:6379> ping
    5. PONG
    7. # echo：在命令行打印内容
    9. 127.0.0.1:6379> echo honey
    10. "honey"
    12. # select：选择数据库。Redis数据库编号从0~15
    14. 127.0.0.1:6379> select 0
    15. OK
    16. 127.0.0.1:6379> select 1
    17. OK
    18. 127.0.0.1:6379[1]> keys *
    19. (empty list or set)
    21. # quit：退出连接
    24. # dbsize：返回当前数据库中key的数目
    26. 127.0.0.1:6379> dbsize
    27. (integer) 28
    29. # info：返回Redis服务器信息
    32. # config get：实时转存收到的请求
    34. 127.0.0.1:6379> config get dir
    35. 1) "dir"
    36. 2) "/usr/redis-3.0.6"
    37. 127.0.0.1:6379> config get *
    38.   1) "dbfilename"
    39.   2) "dump.rdb"
    40.   3) "requirepass"
    41.   4) ""
    42.   5) "masterauth"
    43.   6) ""
    44.   7) "unixsocket"
    45.   8) ""
    46.   9) "logfile"
    47.   ...
    49. # flushdb：删除当前选择数据库中的所有key
    51. 127.0.0.1:6379> flushdb
    52. OK
    53. 127.0.0.1:6379> dbsize
    54. (integer) 0
    56. # flushall：删除所有数据库中的所有key
    58. 127.0.0.1:6379> flushall
    59. OK

  3. Redis高级实用特性

    • 安全性
    • 主从复制
    • 事务处理
    • 持久化机制
    • 发布订阅消息
    • 虚拟内存使用

    安全性：设置客户端连接后进行任何其他指定前需要使用的密码。
    警告：因为redis速度相当快，所以在一台比较好的服务器下，一个外部的用户可以在一秒钟进行150K次的密码尝试，这意味着你需要指定非常非常强大的密码来防止暴力破解。

    1. [root@master ~]# vim /usr/redis-3.0.6/redis.conf
    2. ...
    3. requirepass honey
    4. [root@master ~]# pkill redis-server
    5. [root@master ~]# redis-server /usr/redis-3.0.6/redis.conf &
    7. # 进入Redis后用auth授权
    9. **127.0.0.1:6379> auth honey
    10. OK
    11. 127.0.0.1:6379> keys *
    12. (empty list or set)**
    14. # 或者登陆Redis时直接授权
    16. [root@master ~]# redis-cli -a honey

    主从复制：Redis主从复制配置和使用都非常简单。通过主从复制可以允许多个slave server拥有和master server相同的数据库副本。

    主从复制特点：

    • master可以拥有多个slave
    • 多个slave可以连接同一个master外，还可以连接到其他slave
    • 主从复制不会阻塞master，在同步数据时，master可以继续处理client请求
    • 提高系统的伸缩性

    redis主从复制过程：
    当配置好slave后，slave与master建立连接，然后发送sync命令。无论是第一次连接还是重新连接，master都会启动一个后台进程，将数据库快照保存到文件中，同时master主进程会开始收集新的写命令并缓存。后台进程完成写文件后，master就发送文件给slave，slave将文件保存到硬盘上，再加载到内存中，接着master就会把缓存的命令转发给slave，后续master将收到的写命令发送给slave。如果master同时收到多个slave发来的同步连接命令，master只会启动一个进程来写数据库镜像，然后发送给所有的slave。

    配置主从服务器

    1. [root@slave01 ~]# cd /usr/redis-3.0.6/
    2. [root@slave01 redis-3.0.6]# vim redis.conf 
    3. ...
    4. slaveof master 6379
    5. masterauth honey
    7. # 在主数据库中设置key
    9. [root@master ~]# redis-cli -a honey
    10. 127.0.0.1:6379> flushall
    11. 10025:M 26 Jan 15:35:50.769 * DB saved on disk
    12. OK
    13. 127.0.0.1:6379> set key testsync
    14. OK
    16. # 从数据库中会自动同步
    18. [root@slave01 redis-3.0.6]# redis-cli -a honey
    19. 127.0.0.1:6379> keys *
    20. 1) "key"
    21. 127.0.0.1:6379> get key
    22. "testsync"
    24. # info查看主从信息
    26. 127.0.0.1:6379> info
    27. ...
    29. # Replication
    31. role:slave
    32. master_host:master
    33. master_port:6379
    34. master_link_status:up
    35. master_last_io_seconds_ago:1
    36. master_sync_in_progress:0

    事务处理
    redis目前还是支持比较简单的事务处理，redis只能保证一个client发起的事务中的命令连续执行，而中间不会插入其他client的命令。
    一个client在一个连接中发起multi命令,这个链接会进入事务的上下文，该链接后续的命令不会被立即执行；而是先放到一个队列中，当执行exec命令后，redis会顺序执行队列中的命令。
    如果不行执行这个事务的话，可以用discard命令取消事物；队列中的命令会被取消，事务回滚掉。

    2. # multi开启一个事务
    4. 127.0.0.1:6379> multi
    5. OK
    6. 127.0.0.1:6379> set age 10
    7. QUEUED
    8. 127.0.0.1:6379> set age 100
    9. QUEUED
    10. 127.0.0.1:6379> exec
    11. 1) OK
    12. 2) OK
    13. 127.0.0.1:6379> get age
    14. "100"
    16. # discard取消一个事务
    18. 127.0.0.1:6379> get age
    19. "100"
    20. 127.0.0.1:6379> multi
    21. OK
    22. 127.0.0.1:6379> set age 10
    23. QUEUED
    24. 127.0.0.1:6379> set age 23
    25. QUEUED
    26. 127.0.0.1:6379> discard
    27. OK
    28. 127.0.0.1:6379> get age
    29. "100"
    31. # Redis只支持较简单的事务，事务过程中若有异常，整个事务不会回滚
    33. 127.0.0.1:6379> multi
    34. OK
    35. 127.0.0.1:6379> incr age
    36. QUEUED
    37. 127.0.0.1:6379> set name honey
    38. QUEUED
    39. 127.0.0.1:6379> incr name
    40. QUEUED
    41. 127.0.0.1:6379> exec
    42. 1) (integer) 101
    43. 2) OK
    44. 3) (error) ERR value is not an integer or out of range
    45. 127.0.0.1:6379> get age
    46. "101"

    Redis乐观锁的复杂事务
    乐观锁大多是基于数据版本（Version）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个“version”字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此Version+1。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

    2. # 乐观锁实例:对于一个key为name,我们开2个session对这个key进行赋值
    5. # session1中
    7. 127.0.0.1:6379> set name honey
    8. OK
    9. 127.0.0.1:6379> get name
    10. "honey"
    11. 127.0.0.1:6379> watch name
    12. OK
    13. 127.0.0.1:6379> multi
    14. OK
    15. 127.0.0.1:6379> set name honey_
    16. QUEUED
    18. # session2中
    20. 127.0.0.1:6379> set name nicholas
    21. OK
    22. 127.0.0.1:6379> get name
    23. "nicholas"
    25. # 返回session1提交事务
    27. 127.0.0.1:6379> exec
    28. (nil)
    29. 127.0.0.1:6379> get name
    30. "nicholas"

    watch命令会监视给定的key，当exec的时候如果该key在watch后发生过变化的话，则整个事物就会失败；也可以调用watch对多个key进行监视，这样就可以对多个key加乐观锁了。注意watch指定的key只对整个连接有效的，事务也是如此；若连接断开，监视会自动删除。

    悲观锁正如其名，具有强烈的独占和排他特性。它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。

    持久化机制
    redis持久化方式有两种：
    1）snapshotting，默认方式
    默认redis是会以快照的形式将数据持久化到磁盘的（一个二进制文件，dump.rdb，这个文件名字可以指定），在配置文件（redis.conf）中的格式是：save N M表示在N秒之内，redis至少发生M次修改则redis抓快照到磁盘。当然我们也可以手动执行save或者bgsave（异步）做快照。

    2. # Redis会把数据持久化到dump.rdb文件中
    4. [root@master redis-3.0.6]# ll dump.rdb 
    5. -rw-r--r--. 1 root root 18 Jan 26 14:12 dump.rdb

    2）aof（Append-only file）方式
    filesnapshotting方法在redis异常死掉时，最近的数据会丢失（丢失数据的多少视你save策略的配置），所以这是它最大的缺点，当业务量很大时，丢失的数据是很多的。Append-only方法可以做到全部数据不丢失，但redis的性能就要差些。AOF就可以做到全程持久化，只需要在配置文件中开启（默认是no），appendonly yes开启AOF之后，redis每执行一个修改数据的命令，都会把它添加到aof文件中，当redis重启时，将会读取AOF文件进行“重放”以恢复到redis关闭前的最后时刻。
    AOF文件刷新的方式，有三种，在redis.conf参考配置参数appendfsync：
    appendfsync always每提交一个修改命令都调用fsync刷新到AOF文件，非常非常慢，但也非常安全；
    appendfsync everysec每秒钟都调用fsync刷新到AOF文件，很快，但可能会丢失一秒以内的数据；
    appendfsync no依靠OS进行刷新，redis不主动刷新AOF，这样最快，但安全性就差。默认并推荐每秒刷新，这样在速度和安全上都做到了兼顾。

    消息发布订阅(pub/sub)
    消息发布订阅是一种消息通信模式，主要的目的是解耦消息发布者和消息订阅者之间的耦合，这点和设计模式中的观察者模式比较相似。pub /sub不仅仅解决发布者和订阅者直接代码级别耦合也解决两者在物理部署上的耦合。
    redis作为一个pub/sub server，在订阅者和发布者之间起到了消息路由的功能。订阅者可以通过subscribe和psubscribe命令向redis server订阅自己感兴趣的消息类型，redis将消息类型称为通道(channel)。当发布者通过publish命令向redis server发送特定类型的消息时。订阅该消息类型的全部client都会收到此消息。这里消息的传递是多对多的。一个client可以订阅多个 channel，也可以向多个channel发送消息。

    2. # session1
    4. 127.0.0.1:6379> subscribe tv1
    5. Reading messages... (press Ctrl-C to quit)
    6. 1) "subscribe"
    7. 2) "tv1"
    8. 3) (integer) 1
    14. 1) "message"
    15. 2) "tv1"
    16. 3) "message1"
    17. 1) "message"
    18. 2) "tv1"
    19. 3) "hello....."
    21. # session2
    23. 127.0.0.1:6379> subscribe tv1 tv2
    24. Reading messages... (press Ctrl-C to quit)
    25. 1) "subscribe"
    26. 2) "tv1"
    27. 3) (integer) 1
    28. 1) "subscribe"
    29. 2) "tv2"
    30. 3) (integer) 2
    32. 1) "message"
    33. 2) "tv1"
    34. 3) "message1"
    35. 1) "message"
    36. 2) "tv1"
    37. 3) "hello....."
    39. # session3
    41. 127.0.0.1:6379> publish tv1 message1
    42. (integer) 2
    43. 127.0.0.1:6379> publish tv1 hello.....
    44. (integer) 2
    45. 127.0.0.1:6379> publish tv2  hello.....
    46. (integer) 1

    虚拟内存
    Redis的虚拟内存与os的虚拟内存不同，但是思路和目的都是相同的。就是暂时把不经常访问的数据从内存交换到磁盘中，从而腾出宝贵的 内存空间用于其他需要访问的数据。尤其是对于redis这样的内存数据库，内存总是不够用的。除了可以将数据分割到多个redis server外。另外的能够提高数据库容量的办法就是使用vm把那些不经常访问的数据交换的磁盘上。如果我们的存储的数据总是有少部分数据被经常访问，大 部分数据很少被访问，对于网站来说确实总是只有少量用户经常活跃。当少量数据被经常访问时，使用vm不但能提高单台redis server数据库的容量，而且也不会对性能造成太多影响。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注