VUE项目安装配置redis vue操作redis

Redis（全称：Remote Dictionary Server 远程字典服务）
是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，
并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。
这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。
区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，
在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，
Object-C，Python，Ruby，Erlang等客户端，使用很方便。 [1]

Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。
这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。
由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。
同步对读取操作的可扩展性和数据冗余很有帮助。
redis的官网地址，非常好记，是redis.io。（域名后缀io属于国家域名，是british Indian Ocean territory，即英属印度洋领地）
目前，Vmware在资助着redis项目的开发和维护。

就DB来说，Redis成绩已经很惊人了，且不说memcachedb和Tokyo Cabinet之流，就说原版的memcached，

速度似乎也只能达到这个级别。Redis根本是使用内存存储，持久化的关键是这三条指令：SAVE BGSAVE LASTSAVE …

TYPE key — 用来获取某key的类型
KEYS pattern — 匹配所有符合模式的key，比如KEYS * 就列出所有的key了，当然，复杂度O(n)
RANDOMKEY - 返回随机的一个key
RENAME oldkeynewkey— key也可以改名
列表操作，精华
RPUSH key string — 将某个值加入到一个key列表末尾
LPUSH key string — 将某个值加入到一个key列表头部
LLEN key — 列表长度
LRANGE key start end — 返回列表中某个范围的值，相当于mysql里面的分页查询那样
LTRIM key start end — 只保留列表中某个范围的值
LINDEX key index — 获取列表中特定索引号的值，要注意是O(n)复杂度
LSET key index value — 设置列表中某个位置的值
LPOP key
RPOP key — 和上面的LPOP一样，就是类似栈或队列的那种取头取尾指令，可以当成消息队列来使用了
集合操作
SADD key member — 增加元素
SREM key member — 删除元素
SCARD key — 返回集合大小
SISMEMBER key member — 判断某个值是否在集合中
SINTER key1 key2 … keyN — 获取多个集合的交集元素
SMEMBERS key — 列出集合的所有元素
还有Multiple DB的命令，可以更换db，数据可以隔离开，默认是存放在DB 0。

数据模型
Redis的外围由一个键、值映射的字典构成。与其他非关系型数据库主要不同在于：Redis中值的类型 [1] 不仅限于字符串，还支持如下抽象数据类型：
字符串列表
无序不重复的字符串集合
有序不重复的字符串集合
键、值都为字符串的哈希表 [1]
值的类型决定了值本身支持的操作。Redis支持不同无序、有序的列表，无序、有序的集合间的交集、并集等高级服务器端原子操作。

数据结构
redis提供五种数据类型：
string，
hash，
list，
set
及zset(sorted set)。

string（字符串） 一个key对应一个value redis采用结构 sdshdr和sds封装了字符串，字符串相关的操作实现在源文件sds.h/sds.c中。
list(双向链表) list是一个链表结构，主要功能是push、pop
操作中key理解为链表的名字。
dict(hash表)
zset(排序set)

Redis 安装
https://www.runoob.com/redis/redis-install.html

打开文件夹，内容如下：

打开一个 cmd 窗口 使用 cd 命令切换目录到 C:\redis 运行：

把解压缩的文件直接免安装移到c 盘（ 方便操作，无其它含义）

打开一个 cmd 窗口 使用 cd 命令切换目录到 C:\redis 运行：
启动redis：
命令：
redis-server.exe redis.windows.conf

启动成功

操作过程中可能遇到的问题：

解决启动redis出现的creating server tcp listening socket *:6379: listen: unknown error

在启动redis时总是提示unknow error;

与安装运行成功的redis服务进行比较，比较了redis-server.exe和配置文件redis.windows.conf
通过与安装成功的redis配置文件进行对比，发现，配置文件redis.windows.conf存在差异；

注意：去掉#后，不能有空格，否则也会报错

bind 如果是 127.0.0.1的 话，只能本机 访问，如果是 0.0.0.0的话，代表任何机器都可以访问。
解决问题方案：在配置文件redis.windows.conf找到代码# bind 127.0.0.1;去掉前面的”#“;在本地就可以成功运行。如果需要远程连接服务还需要将127…0.0.1改为0.0.0.0。

4，启动redis: 命令行 redis-server.exe redis.windows.conf，

如果不制定配置文件，那么默认是不需要密码的

继续：第二步
这时候另启一个 cmd 窗口，原来的不要关闭，不然就无法访问服务端了。
切换到 redis 目录下运行:

项目所有目录D:\sourcecode\Redis>
redis-cli.exe -h 127.0.0.1 -p 6379

设置键值对:

set myKey abc

正确密码如何获得： 在程序里的配置里

在vs里进行配置

Linux 下安装

下载地址：http://redis.io/download，下载最新稳定版本。
本教程使用的最新文档版本为 2.8.17，下载并安装：

略

Redis 配置

Redis 的配置文件位于 **Redis 安装目录下**，文件名为 redis.conf(Windows 名为 redis.windows.conf)。
你可以通过 CONFIG 命令查看或设置配置项。

语法
	Redis CONFIG 命令格式如下：

实例
redis 127.0.0.1:6379> CONFIG GET loglevel

1) "loglevel"
2) "notice"
	使用 * 号获取所有配置项：

实例

redis 127.0.0.1:6379> CONFIG GET *
1. “dbfilename”
2. “dump.rdb”
3. “requirepass”
4. “”
5. “masterauth”
6. “”
7. “unixsocket”
8. “”
9. “logfile”
10. “”
11. “pidfile”
12. “/var/run/redis.pid”
13. “maxmemory”
14. “0”
15. “maxmemory-samples”
16. “3”
17. “timeout”
18. “0”
19. “tcp-keepalive”
20. “0”
21. “auto-aof-rewrite-percentage”
22. “100”
23. “auto-aof-rewrite-min-size”
24. “67108864”
25. “hash-max-ziplist-entries”
26. “512”
27. “hash-max-ziplist-value”
28. “64”
29. “list-max-ziplist-entries”
30. “512”
31. “list-max-ziplist-value”
32. “64”
33. “set-max-intset-entries”
34. “512”
35. “zset-max-ziplist-entries”
36. “128”
37. “zset-max-ziplist-value”
38. “64”
39. “hll-sparse-max-bytes”
40. “3000”
41. “lua-time-limit”
42. “5000”
43. “slowlog-log-slower-than”
44. “10000”
45. “latency-monitor-threshold”
46. “0”
47. “slowlog-max-len”
48. “128”
49. “port”
50. “6379”
51. “tcp-backlog”
52. “511”
53. “databases”
54. “16”
55. “repl-ping-slave-period”
56. “10”
57. “repl-timeout”
58. “60”
59. “repl-backlog-size”
60. “1048576”
61. “repl-backlog-ttl”
62. “3600”
63. “maxclients”
64. “4064”
65. “watchdog-period”
66. “0”
67. “slave-priority”
68. “100”
69. “min-slaves-to-write”
70. “0”
71. “min-slaves-max-lag”
72. “10”
73. “hz”
74. “10”
75. “no-appendfsync-on-rewrite”
76. “no”
77. “slave-serve-stale-data”
78. “yes”
79. “slave-read-only”
80. “yes”
81. “stop-writes-on-bgsave-error”
82. “yes”
83. “daemonize”
84. “no”
85. “rdbcompression”
86. “yes”
87. “rdbchecksum”
88. “yes”
89. “activerehashing”
90. “yes”
91. “repl-disable-tcp-nodelay”
92. “no”
93. “aof-rewrite-incremental-fsync”
94. “yes”
95. “appendonly”
96. “no”
97. “dir”
98. “/home/deepak/Downloads/redis-2.8.13/src”
99. “maxmemory-policy”
100. “volatile-lru”
101. “appendfsync”
102. “everysec”
103. “save”
104. “3600 1 300 100 60 10000”
105. “loglevel”
106. “notice”
107. “client-output-buffer-limit”
108. “normal 0 0 0 slave 268435456 67108864 60 pubsub 33554432 8388608 60”
109. “unixsocketperm”
110. “0”
111. “slaveof”
112. “”
113. “notify-keyspace-events”
114. “”
115. “bind”
116. “”

编辑配置
你可以通过修改 redis.conf 文件或使用 CONFIG set 命令来修改配置。
语法
CONFIG SET 命令基本语法：

redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUE

实例
redis 127.0.0.1:6379> CONFIG SET loglevel “notice”
OK
redis 127.0.0.1:6379> CONFIG GET loglevel

1. “loglevel”
2. “notice”

参数说明
redis.conf 配置项说明如下：
redis.conf 配置项说明如下：

Redis 数据类型

Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

String（字符串）

string 是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。

string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。

string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB。

实例

redis 127.0.0.1:6379> SET runoob “菜鸟教程”

OK

redis 127.0.0.1:6379> GET runoob

“菜鸟教程”

在以上实例中我们使用了 Redis 的 SET 和 GET 命令。键为 runoob，对应的值为 菜鸟教程。

注意：一个键最大能存储 512MB。

Hash（哈希）

Redis hash 是一个键值(key=>value)对集合。

Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。

实例

DEL runoob 用于删除前面测试用过的 key，不然会报错：(error) WRONGTYPE Operation against a key holding the wrong kind of value

设置了变量 runoob 对应两个哈希对？ Runoob 哈希表名？

实例中我们使用了 Redis HMSET, HGET 命令，HMSET 设置了两个 field=>value 对, HGET 获取对应 field 对应的 value。
每个 hash 可以存储 232 -1 键值对（40多亿）。

List（列表）
Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
实例

redis 127.0.0.1:6379> DEL runoob
 redis 127.0.0.1:6379> lpush runoob redis
 (integer) 1
 redis 127.0.0.1:6379> lpush runoob mongodb
 (integer) 2
 redis 127.0.0.1:6379> lpush runoob rabitmq
 (integer) 3
 redis 127.0.0.1:6379> lrange runoob 0 101. “rabitmq”
2. “mongodb”
3. “redis”
 redis 127.0.0.1:6379>

列表最多可存储 232 - 1 元素 (4294967295, 每个列表可存储40多亿)。

Set（集合）
Redis 的 Set 是 string 类型的无序集合。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。
sadd 命令
添加一个 string 元素到 key 对应的 set 集合中，成功返回 1，如果元素已经在集合中返回 0。

sadd key member

实例

redis 127.0.0.1:6379> DEL runoob			
redis 127.0.0.1:6379> sadd runoob redis			
(integer) 1			
redis 127.0.0.1:6379> sadd runoob mongodb			
(integer) 1			
redis 127.0.0.1:6379> sadd runoob rabitmq			
(integer) 1			
redis 127.0.0.1:6379> sadd runoob rabitmq			
(integer) 0			
redis 127.0.0.1:6379> smembers runoob			
			
1) "redis"			
2) "rabitmq"			
3) "mongodb"

在以上实例中我们通过 SADD 命令向名为 runoobkey 的集合插入的三个元素。

不同类型的操作命令

Redis 集合命令 集合是S,有序集合是Z
下表列出了 Redis 集合基本命令：

Redis 有序集合(sorted set)

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。	
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。	
有序集合的成员是唯一的,但分数(score)却可以重复。	
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

实例

redis 127.0.0.1:6379> ZADD runoobkey 1 redis
(integer) 1
redis 127.0.0.1:6379> ZADD runoobkey 2 mongodb
(integer) 1
redis 127.0.0.1:6379> ZADD runoobkey 3 mysql
(integer) 1
redis 127.0.0.1:6379> ZADD runoobkey 3 mysql
(integer) 0
redis 127.0.0.1:6379> ZADD runoobkey 4 mysql
(integer) 0
redis 127.0.0.1:6379> ZRANGE runoobkey 0 10 WITHSCORES

1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "mysql"
6) "4"

在以上实例中我们通过命令 ZADD 向 redis 的有序集合中添加了三个值并关联上分数。

Redis 有序集合命令

下表列出了 redis 有序集合的基本命令:

序号 命令及描述

1 ZADD key score1 member1 [score2 member2]

向有序集合添加一个或多个成员，或者更新已存在成员的分数

2 ZCARD key

获取有序集合的成员数

3 ZCOUNT key min max

计算在有序集合中指定区间分数的成员数

4 ZINCRBY key increment member

有序集合中对指定成员的分数加上增量 increment

5 ZINTERSTORE destination numkeys key [key …]

计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中

6 ZLEXCOUNT key min max

在有序集合中计算指定字典区间内成员数量

7 ZRANGE key start stop [WITHSCORES]

通过索引区间返回有序集合指定区间内的成员

8 ZRANGEBYLEX key min max [LIMIT offset count]

通过字典区间返回有序集合的成员

9 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]

通过分数返回有序集合指定区间内的成员

10 ZRANK key member

返回有序集合中指定成员的索引

11 ZREM key member [member …]

移除有序集合中的一个或多个成员

12 ZREMRANGEBYLEX key min max

移除有序集合中给定的字典区间的所有成员

13 ZREMRANGEBYRANK key start stop

移除有序集合中给定的排名区间的所有成员

14 ZREMRANGEBYSCORE key min max

移除有序集合中给定的分数区间的所有成员

15 ZREVRANGE key start stop [WITHSCORES]

返回有序集中指定区间内的成员，通过索引，分数从高到低

16 ZREVRANGEBYSCORE key max min [WITHSCORES]

返回有序集中指定分数区间内的成员，分数从高到低排序

17 ZREVRANK key member

返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序

18 ZSCORE key member

返回有序集中，成员的分数值

19 ZUNIONSTORE destination numkeys key [key …]

计算给定的一个或多个有序集的并集，并存储在新的 key 中

20 ZSCAN key cursor [MATCH pattern] [COUNT count]

迭代有序集合中的元素（包括元素成员和元素分值）

Redis HyperLogLog

Redis 在 2.8.9 版本添加了 HyperLogLog 结构。					新的结构							
Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定 的、并且是很小的。												
在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。												
但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。												
									
												
什么是基数?												
比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。

实例
以下实例演示了 HyperLogLog 的工作过程：

redis 127.0.0.1:6379> PFADD runoobkey “redis”
1. (integer) 1
 redis 127.0.0.1:6379> PFADD runoobkey “mongodb”2. (integer) 1
 redis 127.0.0.1:6379> PFADD runoobkey “mysql”3. (integer) 1
 redis 127.0.0.1:6379> PFCOUNT runoobkey
 (integer) 3

Redis HyperLogLog 命令

下表列出了 redis HyperLogLog 的基本命令：

序号 命令及描述
1 PFADD key element [element …]
添加指定元素到 HyperLogLog 中。
2 PFCOUNT key [key …]
返回给定 HyperLogLog 的基数估算值。
3 PFMERGE destkey sourcekey [sourcekey …]
将多个 HyperLogLog 合并为一个 HyperLogLog

Redis 发布订阅

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。

Redis 客户端可以订阅任意数量的频道。

下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

实例

以下实例演示了发布订阅是如何工作的。在我们实例中我们创建了订阅频道名为 redisChat:

redis 127.0.0.1:6379> SUBSCRIBE redisChat

Reading messages… (press Ctrl-C to quit)

1. “subscribe”
2. “redisChat”
3. (integer) 1

现在，我们先重新开启个 redis 客户端，然后在同一个频道 redisChat 发布两次消息，订阅者就能接收到消息。

redis 127.0.0.1:6379> PUBLISH redisChat “Redis is a great caching technique”

(integer) 1

redis 127.0.0.1:6379> PUBLISH redisChat “Learn redis by runoob.com”

(integer) 1

订阅者的客户端会显示如下消息

1. “message”
2. “redisChat”
3. “Redis is a great caching technique”
4. “message”
5. “redisChat”
6. “Learn redis by runoob.com”

https://www.runoob.com/redis/redis-pub-sub.html

Redis 发布订阅命令

下表列出了 redis 发布订阅常用命令：

序号 命令及描述
1 PSUBSCRIBE pattern [pattern …]
订阅一个或多个符合给定模式的频道。
2 PUBSUB subcommand [argument [argument …]]
查看订阅与发布系统状态。
3 PUBLISH channel message
将信息发送到指定的频道。
4 PUNSUBSCRIBE [pattern [pattern …]]
退订所有给定模式的频道。
5 SUBSCRIBE channel [channel …]
订阅给定的一个或多个频道的信息。
6 UNSUBSCRIBE [channel [channel …]]
指退订给定的频道。

Redis 事务
Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：

批量操作在发送 EXEC 命令前被放入队列缓存。
收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：

开始事务。

命令入队。

执行事务。

实例
以下是一个事务的例子， 它先以 MULTI 开始一个事务， 然后将多个命令入队到事务中， 最后由 EXEC 命令触发事务， 一并执行事务中的所有命令：

redis 127.0.0.1:6379> MULTI	
OK	
	
redis 127.0.0.1:6379> SET book-name "Mastering C++ in 21 days"	
QUEUED	
	
redis 127.0.0.1:6379> GET book-name	
QUEUED	
	
redis 127.0.0.1:6379> SADD tag "C++" "Programming" "Mastering Series"	
QUEUED	
	
redis 127.0.0.1:6379> SMEMBERS tag	
QUEUED	
	
redis 127.0.0.1:6379> EXEC	
1) OK	
2) "Mastering C++ in 21 days"	
3) (integer) 3	
4) 1) "Mastering Series"	
   2) "C++"	
   3) "Programming"

单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。

事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

这是官网上的说明 From redis docs on transactions:

It’s important to note that even when a command fails, all the other commands in the queue are processed – Redis will not stop the processing of commands.

比如：

redis 127.0.0.1:7000> multi 
 OK 
 redis 127.0.0.1:7000> set a aaa 
 QUEUED 
 redis 127.0.0.1:7000> set b bbb 
 QUEUED 
 redis 127.0.0.1:7000> set c ccc 
 QUEUED 
 redis 127.0.0.1:7000> exec1. OK
2. OK
3. OK

如果在 set b bbb 处失败，set a 已成功不会回滚，set c 还会继续执行。 非原子化，即执行过程中出现意外不会回滚

Redis 事务命令
下表列出了 redis 事务的相关命令：

序号 命令及描述
1 DISCARD discard 取消事务
取消事务，放弃执行事务块内的所有命令。
2 EXEC exec 执行事务内的命令
执行所有事务块内的命令。
3 MULTI multi 标记一个事务块的开始
标记一个事务块的开始。
4 UNWATCH unwatch 取消watch对所有key的监视
取消 WATCH 命令对所有 key 的监视。
5 WATCH key [key …]
监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。 监视一个key

Redis 脚本
Redis 脚本使用 Lua 解释器来执行脚本。 Redis 2.6 版本通过内嵌支持 Lua 环境。执行脚本的常用命令为 EVAL。
语法
Eval 命令的基本语法如下：

redis 127.0.0.1:6379> EVAL script numkeys key [key …] arg [arg …]

实例
以下实例演示了 redis 脚本工作过程：
redis 127.0.0.1:6379> EVAL “return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}” 2 key1 key2 first second

1. “key1”
2. “key2”
3. “first”
4. “second”

Redis 脚本命令
下表列出了 redis 脚本常用命令：

序号 命令及描述
1 EVAL script numkeys key [key …] arg [arg …]
执行 Lua 脚本。
2 EVALSHA sha1 numkeys key [key …] arg [arg …]
执行 Lua 脚本。
3 SCRIPT EXISTS script [script …]
查看指定的脚本是否已经被保存在缓存当中。
4 SCRIPT FLUSH
从脚本缓存中移除所有脚本。
5 SCRIPT KILL
杀死当前正在运行的 Lua 脚本。
6 SCRIPT LOAD script
将脚本 script 添加到脚本缓存中，但并不立即执行这个脚本。

Redis 连接
Redis 连接命令主要是用于连接 redis 服务。

实例					
以下实例演示了客户端如何通过密码验证连接到 redis 服务，并检测服务是否在运行：					
					
redis 127.0.0.1:6379> AUTH "password"					
OK					
redis 127.0.0.1:6379> PING					
PONG

Redis 连接命令
下表列出了 redis 连接的基本命令：

序号 命令及描述
1 AUTH password
验证密码是否正确
2 ECHO message
打印字符串
3 PING
查看服务是否运行
4 QUIT
关闭当前连接
5 SELECT index
切换到指定的数据库

Redis 服务器
Redis 服务器命令主要是用于管理 redis 服务。
实例
以下实例演示了如何获取 redis 服务器的统计信息：

127.0.0.1:6379> info
 #Server
 redis_version:3.2.100
 redis_git_sha1:00000000
 redis_git_dirty:0
 redis_build_id:dd26f1f93c5130ee
 redis_mode:standalone
 os:Windows
 arch_bits:64
 multiplexing_api:WinSock_IOCP
 process_id:174204
 run_id:8355c43c0119471c76e8a82d84321b6600f60e86
 tcp_port:6379
 uptime_in_seconds:10522
 uptime_in_days:0
 hz:10
 lru_clock:14637076
 executable:D:\sourcecode\Redis\redis-server.exe
 config_file:D:\sourcecode\Redis\redis.windows.conf
#Clients
 connected_clients:1
 client_longest_output_list:0
 client_biggest_input_buf:0
 blocked_clients:0#Memory
 used_memory:690920
 used_memory_human:674.73K
 used_memory_rss:653016
 used_memory_rss_human:637.71K
 used_memory_peak:690920
 used_memory_peak_human:674.73K
 total_system_memory:0
 total_system_memory_human:0B
 used_memory_lua:40960
 used_memory_lua_human:40.00K
 maxmemory:0
 maxmemory_human:0B
 maxmemory_policy:noeviction
 mem_fragmentation_ratio:0.95
 mem_allocator:jemalloc-3.6.0#Persistence
 loading:0
 rdb_changes_since_last_save:5
 rdb_bgsave_in_progress:0
 rdb_last_save_time:1574907642
 rdb_last_bgsave_status:ok
 rdb_last_bgsave_time_sec:-1
 rdb_current_bgsave_time_sec:-1
 aof_enabled:0
 aof_rewrite_in_progress:0
 aof_rewrite_scheduled:0
 aof_last_rewrite_time_sec:-1
 aof_current_rewrite_time_sec:-1
 aof_last_bgrewrite_status:ok
 aof_last_write_status:ok#Stats
 total_connections_received:1
 total_commands_processed:19
 instantaneous_ops_per_sec:0
 total_net_input_bytes:833
 total_net_output_bytes:586
 instantaneous_input_kbps:0.00
 instantaneous_output_kbps:0.00
 rejected_connections:0
 sync_full:0
 sync_partial_ok:0
 sync_partial_err:0
 expired_keys:0
 evicted_keys:0
 keyspace_hits:2
 keyspace_misses:0
 pubsub_channels:0
 pubsub_patterns:0
 latest_fork_usec:0
 migrate_cached_sockets:0#Replication
 role:master
 connected_slaves:0
 master_repl_offset:0
 repl_backlog_active:0
 repl_backlog_size:1048576
 repl_backlog_first_byte_offset:0
 repl_backlog_histlen:0#CPU
 used_cpu_sys:0.17
 used_cpu_user:0.05
 used_cpu_sys_children:0.00
 used_cpu_user_children:0.00#Cluster
 cluster_enabled:0#Keyspace
 db0:keys=2,expires=0,avg_ttl=0
 127.0.0.1:6379>

Redis 服务器命令

下表列出了 redis 服务器的相关命令:

Redis 数据备份与恢复

Redis SAVE 命令用于创建当前数据库的备份。

语法

redis Save 命令基本语法如下：

redis 127.0.0.1:6379> SAVE

实例
redis 127.0.0.1:6379> SAVE 
OK

该命令将在 redis 安装目录中创建dump.rdb文件。

恢复数据
如果需要恢复数据，只需将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可。获取 redis 目录可以使用 CONFIG 命令，如下所示：

以上命令 CONFIG GET dir 输出的 redis 安装目录为 /usr/local/redis/bin。

redis 127.0.0.1:6379> CONFIG GET dir

1. “dir”
2. “/usr/local/redis/bin”

以上命令 CONFIG GET dir 输出的 redis 安装目录为 /usr/local/redis/bin。

Bgsave

创建 redis 备份文件也可以使用命令 BGSAVE，该命令在后台执行。

实例

127.0.0.1:6379> BGSAVE

Background saving started

Redis 安全
我们可以通过 redis 的配置文件设置密码参数，这样客户端连接到 redis 服务就需要密码验证，这样可以让你的 redis 服务更安全。
实例
我们可以通过以下命令查看是否设置了密码验证：

127.0.0.1:6379> CONFIG get requirepass

1. “requirepass”
2. “”

说明设置了密码

默认情况下 requirepass 参数是空的，这就意味着你无需通过密码验证就可以连接到 redis 服务。

你可以通过以下命令来修改该参数：设置密码

设置密码后，客户端连接 redis 服务就需要密码验证，否则无法执行命令。

语法

AUTH 命令基本语法格式如下：

127.0.0.1:6379> AUTH password

实例
127.0.0.1:6379> AUTH “runoob”
OK
127.0.0.1:6379> SET mykey “Test value”
OK
127.0.0.1:6379> GET mykey
“Test value”

Redis 性能测试
Redis 性能测试是通过同时执行多个命令实现的。
语法
redis 性能测试的基本命令如下：

注意：该命令是在 redis 的目录下执行的，而不是 redis 客户端的内部指令。

实例
以下实例同时执行 10000 个请求来检测性能：

$ redis-benchmark -n 10000 -q
PING_INLINE: 141043.72 requests per second
 PING_BULK: 142857.14 requests per second
 SET: 141442.72 requests per second
 GET: 145348.83 requests per second
 INCR: 137362.64 requests per second
 LPUSH: 145348.83 requests per second
 LPOP: 146198.83 requests per second
 SADD: 146198.83 requests per second
 SPOP: 149253.73 requests per second
 LPUSH (needed to benchmark LRANGE): 148588.42 requests per second
 LRANGE_100 (first 100 elements): 58411.21 requests per second
 LRANGE_300 (first 300 elements): 21195.42 requests per second
 LRANGE_500 (first 450 elements): 14539.11 requests per second
 LRANGE_600 (first 600 elements): 10504.20 requests per second
 MSET (10 keys): 93283.58 requests per second

Dos窗口下，不是在redis 的客户端

redis 性能测试工具可选参数如下所示：

实例
以下实例我们使用了多个参数来测试 redis 性能：
$ redis-benchmark -h 127.0.0.1 -p 6379 -t set,lpush -n 10000 -q

SET: 146198.83 requests per second
LPUSH: 145560.41 requests per second

以上实例中主机为 127.0.0.1，端口号为 6379，执行的命令为 set,lpush，请求数为 10000，通过 -q 参数让结果只显示每秒执行的请求数。

Redis 客户端连接

Redis 通过监听一个 TCP 端口或者 Unix socket 的方式来接收来自客户端的连接，当一个连接建立后，Redis 内部会进行以下一些操作：

首先，客户端 socket 会被设置为非阻塞模式，因为 Redis 在网络事件处理上采用的是非阻塞多路复用模型。

然后为这个 socket 设置 TCP_NODELAY 属性，禁用 Nagle 算法

然后创建一个可读的文件事件用于监听这个客户端 socket 的数据发送

最大连接数
在 Redis2.4 中，最大连接数是被直接硬编码在代码里面的，而在2.6版本中这个值变成可配置的。
maxclients 的默认值是 10000，你也可以在 redis.conf 中对这个值进行修改。
config get maxclients

1. “maxclients”
2. “10000”

实例
以下实例我们在服务启动时设置最大连接数为 100000：
redis-server --maxclients 100000

客户端命令

S.N.
1
2
3
4
5

Redis 管道技术
Redis是一种基于客户端-服务端模型以及请求/响应协议的TCP服务。这意味着通常情况下一个请求会遵循以下步骤：

客户端向服务端发送一个查询请求，并监听Socket返回，通常是以阻塞模式，等待服务端响应。

服务端处理命令，并将结果返回给客户端。

Redis 管道技术
Redis 管道技术可以在服务端未响应时，客户端可以继续向服务端发送请求，并最终一次性读取所有服务端的响应。
实例
查看 redis 管道，只需要启动 redis 实例并输入以下命令：

$(echo -en “PING\r\n SET runoobkey redis\r\n GET runoobkey\r\n INCR visitor\r\n INCR visitor\r\n INCR visitor\r\n”; sleep 10)|nc localhost 6379

+PONG
+OK
redis
:1
:2
:3

以上实例中我们通过使用 PING 命令查看redis服务是否可用， 之后我们设置了 runoobkey 的值为 redis，然后我们获取 runoobkey 的值并使得 visitor 自增 3 次。

在返回的结果中我们可以看到这些命令一次性向 redis 服务提交，并最终一次性读取所有服务端的响应

没成功

管道技术的优势

管道技术最显著的优势是提高了 redis 服务的性能。

一些测试数据

在下面的测试中，我们将使用Redis的Ruby客户端，支持管道技术特性，测试管道技术对速度的提升效果。

require ‘rubygems’
 require ‘redis’
 def bench(descr)
 start = Time.now
 yield
 puts “#{descr} #{Time.now-start} seconds”
 end
 def without_pipelining
 r = Redis.new
 10000.times {
 r.ping
 }
 end
 def with_pipelining
 r = Redis.new
 r.pipelined {
 10000.times {
 r.ping
 }
 }
 end
 bench(“without pipelining”) {
 without_pipelining
 }
 bench(“with pipelining”) {
 with_pipelining
 }

Ruby安装和Redis集成

1. 下载Ruby， 地址：https://rubyinstaller.org/downloads/

2. 安装Ruby，以rubyinstaller-2.2.6-x64.exe为例，注意：安装时记得选上添加系统路径，否则需要手工修改Path
3. 确认安装是否成功

安装路径：

3. 确认安装是否成功

4. 替换gem源，参考地址：https://gems.ruby-china.com/
   （1）删掉原来所有的源，默认外国源，国内无法访问

（2）添加国内的镜像源（或者其他源或本地源）

注意：如果报一下错误使用 “http” 替换 “https” 即可。

5. 导入Redis，出现以下图片即导入成功。

6.

7. 安装Redis，地址: https://github.com/tporadowski/redis/releases

redis的安装与配置(一)

这是官方的定义。说它是一个数据库，且是把数据存到内存中，能用作cache(缓存)和消息队列。

说到数据库，可能大家用得最多的是关系型数据库，比如MySQL，PostgreSQL等。这种数据库是把数据存到磁盘中的，这种能存大量的数据，

然而我们的应用是经常需要访问数据库来查找数据，每次访问，无论怎样，都是需要消耗CPU和IO等待。

当应用的数据积累到很庞大时，这种性能的问题更严重，所以有一种解决方法是这样的，把经常被访问的数据放到内存中，因为内存的访问速度比磁盘快太多了，

而这部分数据可能不会是全部的数据，因为内存的价格比磁盘贵多了。所以有了memcached，这种就是把数据放到内存中，

但它支持一种最简单的数据结构，就是键值对，这种数据库又不同于传统结构型的关系型数据库，所以又被称为nosql。

而redis也是nosql的一种，但它相比memcached不仅支持键值对，还支持列表，集合，排序集合等结构，而且它还是可持久化的。
持久化就是说在内存中的数据会以文件的形式同步到磁盘中，当下次重启时还能恢复，这点相比memcached，就能存相对重要的数据，
毕竟，如果数据不能持久化，丢失了也是件麻烦的事，谁也保证不了不会出问题。
还有一个很重要的特征就是redis支持分布式集群，用它可以轻易地部署到多台机器中，成为一个集群。特别是3.0开始，redis对集群的支持比较健全了。
redis比较常见的作用，第一个是cache，这是由于它的数据存在内存中，访问速度比较快，它能让数据在一定时间后过期，
且又有丰富的数据结构的支持，所以它能作为一个高性能的cache。
第二个是作为消息队列，用的是它的sub/pub的功能，能具有消息费生产者的模式，且是数据存在内存中，访问速度高。

2. 安装
   比较常见的有两种安装方式，第一是命令安装，第二是源码编译安装。命令安装可能并不会安装到最新的版本，因为软件源的redis版本也未必是最新的，但是胜在方面快速。
   如果是ubuntu系统，可以这样。
   2.1 命令安装
   如果是ubuntu系统，可以这样。
   $ sudo apt-get install redis-server
   mac系统用以下命令。
   $ brew install redis

2.2 编译安装
首先下载官方稳定版的tar包。
$ wget http://download.redis.io/releases/redis-3.0.5.tar.gz
解压缩编译安装。
$ tar xvf redis-3.0.5.tar.gz
$ cd redis-3.0.5
$ make
$ sudo make install
这样就安装好了，接下来启动服务器。

$ src/redis-server 我执行的时候是从此步开始执行： 启动命令 redis-server.exe redis.windows.conf

测试。
src/redis-cli
redis> set foo bar
OK
redis> get foo
“bar”

这样很不方便。每次都要进到那个目录才能执行redis-server或redis-cli。
其实redis的源码提供了一个工具，让你能够使用类似/etc/init.d/server start这样的命令来启动redis服务。
只要运行utils目录下的install_server.sh脚本文件就好了。
$ cd utils
$ sudo ./install_server.sh

https://jingyan.baidu.com/article/27fa732658373a46f9271f73.html windows下安装redis服务端

五.Redis的可视化工具安装(RedisDesktopManager)
首先下载下来之后双击打开之后出现，如图所示的界面：

官网下载：https://redisdesktop.com/download

github地址：https://github.com/uglide/RedisDesktopManager/releases

6、将redis加入到windows的服务中（都是两个-）

redis-server --service-install redis.windows.conf --loglevel verbose

7、安装成功

8、但是安装好之后，Redis并没有启动，
（1）启动命令如下：

1. redis-server --service-start

（2）停止命令：
2. redis-server --service-stop

（3）还可以安装多个实例
3. redis-server --service-install –service-name redisService1 –port 10001

4. redis-server --service-start –service-name redisService1
5. redis-server --service-install –service-name redisService2 –port 10002
6. redis-server --service-start –service-name redisService2
7. redis-server --service-install –service-name redisService3 –port 10003
8. redis-server --service-start –service-name redisService3

（4）卸载命令：

1. redis-server --service-uninstall

http://docs.redisdesktop.com/en/latest/quick-start/

How to start using RDM

After you've installed Redis Desktop Manager, the first thing you need to do in order to get going is to										
 create a connection to your Redis server. On the main window, press the button labelled Connect to Redis Server.

Connect to a local or public redis-server

On the first tab (Connection Settings), put in general information regarding the connection that you are creating.
Name - the name of new connection (example: my_local_redis)
Host - redis-server host (example: localhost)
Port - redis-server port (example: 6379)
Auth - redis-server authentication password (if any) (http://redis.io/commands/AUTH)

Connect to a public redis-server with SSL

If you want to connect to a redis-server instance with SSL
you need to enable SSL on the second tab and provide a public key in PEM format.
Instructions for certain cloud services are below:

Create a connection with all requested information.

1. Make sure that the “Use SSL Protocol” checkbox is enabled.
2. Your Azure Redis connection is ready to use.

To connect to a Redis Labs instance with SSL/TLS encryption, follow the steps below:

个人执行结果

正确的执行顺序：

1、启动 redis

2、启动服务器程序 （后台服务器程序 ，api （对应的服务器项目）设置为启动项）

3、启动vue网站 先用命令 npm run dev

再单击启动按钮 “绿三角”