辛星Redis教程(2015年win版)
windows安装redis并启动命令
windows安装redis并启动命令windows 安装redis并启动命令⼀、下载windows版本的Redis去官⽹找了很久，发现原来在官⽹上可以下载的windows版本的，现在官⽹以及没有下载地址，只能在github上下载，官⽹只提供linux版本的下载⼆、安装Redis1.这⾥下载的是Redis-x64-3.2.100版本，我的电脑是win7 64位，所以下载64位版本的，在运⾏中输⼊cmd，然后把⽬录指向解压的Redis⽬录。
2、启动命令redis-server redis.windows.conf，出现下图显⽰表⽰启动成功了。
三、设置Redis服务1、由于上⾯虽然启动了redis，但是只要⼀关闭cmd窗⼝，redis就会消失。
所以要把redis设置成windows下的服务。
也就是设置到这⾥，⾸先发现是没⽤这个Redis服务的。
2、设置服务命令redis-server --service-install redis.windows-service.conf --loglevel verbose输⼊命令之后没有报错，表⽰成功了，刷新服务，会看到多了⼀个redis服务。
**启动报错1067的话，在刚才redis的⽬录下新建⽂件夹Logs然后再次启动即可。
3、常⽤的redis服务命令。
卸载服务：redis-server --service-uninstall开启服务：redis-server --service-start停⽌服务：redis-server --service-stop4、启动服务5、测试Redis安装测试成功。
在下载的解压包⾥⾯有⼀份⽂档，有详细的说明，。
Windows下Redis的安装方法
Windows下Redis的安装方法
Windows下Redis的安装方法
1、首先，Redis官方是支持Linux系统的.，我这里不多说，需要的可以参考：/article/96234.htm
3、下载后的Redis解压到自己目录下面，解压后
4、这里你可以直接点击redis-server.exe启动，默认配置（无密码）启动
红框内可以看到，no config file specified, using the default config，这样启动没问题，可以自己检测一下，在安装目录下打开命令窗口，运行命令 redis-cli.exe -h 127.0.0.1
成功则可以看到上图效果。
5、我们再来设置Redis密码，打开redis.windows.conf文件，找到# requirepass foobared这一行去掉注释，foobared替换成自己的密码，保存。
6、运行命令：redis-server.exe redis.windows.conf
可以看到是用我们配置文件启动，然后测试，这里必须输入密码了，不输入密码会报错
这里说明没输入密码，无权限，所以我们需要输入密码了，redis-cli.exe -h 127.0.0.1 -a 密码
7、到这里，Windows下安装Redis就大功告成了。
这里有个快捷点，将启动命令redis-server.exe redis.windows.conf，新建txt文本，将命令保存在文件中，
然后将文本格式转换成.bat文件，直接运行bat文件。
Windows下Redis集群搭建
Windows下搭建Redis集群Redis 集群简介Redis 是一个开源的 key-value 存储系统，由于出众的性能，大部分互联网企业都用来做服务器端缓存。
Redis 在3.0版本前只支持单实例模式，虽然支持主从模式、哨兵模式部署来解决单点故障，但是现在互联网企业动辄大几百G的数据，可完全是没法满足业务的需求，所以，Redis 在 3.0 版本以后就推出了集群模式。
Redis 集群采用了P2P的模式，完全去中心化。
Redis 把所有的 Key 分成了16384 个 slot，每个 Redis 实例负责其中一部分 slot 。
集群中的所有信息（节点、端口、slot等），都通过节点之间定期的数据交换而更新。
Redis 客户端可以在任意一个 Redis 实例发出请求，如果所需数据不在该实例中，通过重定向命令引导客户端访问所需的实例。
集群搭建要让集群正常运作至少需要三个主节点，不过在刚开始试用集群功能时，强烈建议使用六个节点：其中三个为主节点，而其余三个则是各个主节点的从节点。
主节点崩溃，从节点的Redis就会提升为主节点，代替原来的主节点工作，崩溃的主Redis回复工作后，会成为从节点1). 创建Redis集群目录在redis安装的根目录下通过命令行创建6个以端口命名的文件夹mkdir 7000 7001 7002 7003 7004 7005将安装的redis文件夹中的redis.windows.conf以及redis-server,分别拷贝到新建的六个文件夹中2). 更改配置将六个文件夹下的redis.windows.conf文件中以下属性进行修改：port 7001（对应文件夹的端口号）cluster-enabled yes(开启实例的集群模式)去掉注释cluster-config-file nodes.conf(保存节点配置文件，默认值为nodes.conf )去掉注释cluster-node-timeout 5000(是集群中各节点相互通讯时，允许"失联"的最大毫秒数，上面的配置为5秒，如果超过5秒某个节点没向其它节点汇报成功，认为该节点挂了。
redis使用流程
redis使用流程（原创版）目录1.Redis 简介2.Redis 的使用流程2.1 安装 Redis2.2 启动 Redis 服务2.3 客户端连接 Redis 服务器2.4 创建和操作 Redis 数据库2.5 关闭 Redis 服务正文【Redis 简介】Redis 是一个基于内存的开源数据库系统，它支持多种数据结构，如字符串、哈希表、列表、集合和有序集合等。
Redis 以其高性能、可扩展性和灵活性而广受欢迎，被广泛应用于缓存、消息队列、排行榜和实时计数器等场景。
【Redis 的使用流程】2.1 安装 Redis在使用 Redis 之前，首先需要在计算机上安装 Redis。
可以访问Redis 官方网站 (https://redis.io/download) 下载适用于不同操作系统的 Redis 版本。
下载完成后，按照官方文档的指引进行安装。
2.2 启动 Redis 服务安装完成后，需要启动 Redis 服务。
在命令行中输入“redis-server”命令，回车后即可启动 Redis 服务。
如果需要设置 Redis 的配置文件，可以使用“redis-server /path/to/redis.conf”命令启动。
2.3 客户端连接 Redis 服务器要与 Redis 服务器进行交互，需要使用 Redis 客户端。
可以使用Redis 官方提供的客户端，也可以使用第三方客户端。
在命令行中输入“redis-cli”命令，回车后即可启动 Redis 客户端。
在客户端中，使用“connect”命令连接 Redis 服务器，如“connect 127.0.0.1:6379”。
2.4 创建和操作 Redis 数据库连接到 Redis 服务器后，可以创建和操作 Redis 数据库。
Redis 中的数据库是以数字命名的，使用“db”命令切换数据库，如“db 0”。
在数据库中，可以使用多种命令来操作数据，如“set”命令设置键值对，“get”命令获取键的值，“del”命令删除键等。
Windows下Redis的安装使用教程
Windows下Redis的安装使⽤教程本⽂主要为⼤家介绍缓存技术中的⼀种Redis的安装和使⽤，供⼤家参考，具体内容如下⼀、下载Redis for windows在⽹络中搜索Redis fow windows,就可以下载Redis的压缩包。
解压包。
会发现其中有32位和64位的不同版本的包，根据需要，使⽤对应的压缩包即可。
⼆、解压我使⽤的是redisbin_x64.zip的压缩包，将其解压到redis的⽂件夹中。
解压之后，会发现内容只有⼀些.exe的⽂件。
到这⾥，redis就算做好了⼀半了。
三、配置在redis下新建⼀个conf的⽂件夹，并创建 redis.conf ⽂本⽂件。
将⼀下内容复制到配置⽂件中。
# Redis configuration file example# By default Redis does not run as a daemon. Use 'yes' if you need it.# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.# 是否以后台进程的形式运⾏，默认为nodaemonize no# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.# You can specify a custom pid file location here.# 如果指定以后台形式执⾏，则需要指定⼀个pid⽂件pidfile /var/run/redis.pid# Accept connections on the specified port, default is 6379#监听端⼝号port 6379# If you want you can bind a single interface, if the bind option is not# specified all the interfaces will listen for connections.# 绑定主机IP# bind 127.0.0.1# Close the connection after a client is idle for N seconds (0 to disable)# 客户端空闲超时时间，设置为0，则没有超时。
Redis教程（Windows）
Redis教程（Windows）
安装
1)下载redis压缩包并 , 推荐地址：
Redis ⽀持 32 位和 64 位。
这个需要根据你系统平台的实际情况选择
2) 命令⾏下的使⽤
打开⼀个 cmd 窗⼝使⽤cd命令切换到Redis⽬录并运⾏redis-server.exe redis.windows.conf
这时候另启⼀个cmd窗⼝，原来的不要关闭，不然就⽆法访问服务端了。
切换到redis⽬录下运⾏
redis-cli.exe -h 127.0.0.1 -p 6379
进⾏测试⼯作:
127.0.0.1:6379>set key value
OK
127.0.0.1:6379> get key
'value'
127.0.0.1:6379>
如果设置了密码:
//进⼊客户端之后
auth 密码
退出当前终端
quit
3)将Redis添加到服务中
1.有时候我们开发中经常会⽤到redis,那么将其作为Windows的⼀种服务.不⽤⼿动的来进⾏启动.
redis-server --service-install redis.windows-service.conf --loglevel verbose
可以查看服务是否已经添加: Win + R -> services.msc 查找Redis
2. 进⾏redis启动
redis-server --service-start
注意:。
redis的使用及方法
redis的使⽤及⽅法⼀、redis(1)、redis是⼀个key-value。
和Memcached类似，它⽀持存储的value类型相对更多，包括string(字符串)、list()、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。
这些都⽀持push/pop、add/remove及取交集并集和差集及更丰富的操作，⽽且这些操作都是原⼦性的。
在此基础上，redis⽀持各种不同⽅式的排序。
与memcached⼀样，为了保证效率，数据都是缓存在内存中。
区别的是redis会周期性的把更新的数据写⼊磁盘或者把修改操作写⼊追加的记录⽂件，并且在此基础上实现了master-slave(主从)同步。
View Code(2)、redis的⽤途a、redis可以做缓存b、redis可以做消息队列(3)、redis的本质a、将数据保存到内存中(4)、redis特性a、可做持久化b、⽀持存放数据格式多（5种格式）{"k1": "oldboyedu"# "666" 字符串"k2": [11,22,33,44,11], 列表"k3": {11,22,33,44},"k4": {"n1":'xxx',"n2":"iii",'k1':'v1','k2': 'v2','num': 1,}, # 迭代取值"k5": {(11,1),("alex",5)}}⼆、redis的安装和基本使⽤a、下载解压wget http://download.redis.io/releases/redis-3.0.6.tar.gztar xzf redis-3.0.6.tar.gzcd redis-3.0.6makeb、启动服务端src/redis-serverc、启动客户端src/redis-cliredis> set foo barOKredis> get foo"bar"d、安装包yum install redis启动：/etc/init.d/redis start配置：/etc/redis/redis.confe、如果不⼩⼼把没有把redis退出，把开启redis的界⾯关了，那么⽤下⾯的代码：找服务并杀掉：ps -e|grep rediskill -9 端⼝号三、Python操作redis(1)、远程操作redis的模块（socket）sudo pip install redisorsudo easy_install redisor源码安装详见：https:///WoLpH/redis-py(2)、string操作a、set(name, value, ex=None, px=None, nx=False, xx=False)在Redis中设置值，默认，不存在则创建，存在则修改参数：ex，过期时间（秒）px，过期时间（毫秒）nx，如果设置为True，则只有name不存在时，当前set操作才执⾏xx，如果设置为True，则只有name存在时，岗前set操作才执⾏b、setnx(name, value)设置值，只有name不存在时，执⾏设置操作（添加）c、setex(name, value, time)# 设置值# 参数：# time，过期时间（数字秒或 timedelta对象）d、psetex(name, time_ms, value)# 设置值# 参数：# time_ms，过期时间（数字毫秒或 timedelta对象）e、mset(*args, **kwargs)批量设置值如：mset(k1='v1', k2='v2')或mget({'k1': 'v1', 'k2': 'v2'})f、get(name)获取值g、mget(keys, *args)批量获取如：mget('ylr', 'wupeiqi')或r.mget(['ylr', 'wupeiqi'])h、getset(name, value)设置新值并获取原来的值j、getrange(key, start, end)# 获取⼦序列（根据字节获取，⾮字符）# 参数：# name，Redis 的 name# start，起始位置（字节）# end，结束位置（字节）# 如： "黎明" ，0-3表⽰ "黎"k、setrange(name, offset, value)# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）# 参数：# offset，字符串的索引，字节（⼀个汉字三个字节）# value，要设置的值l、setbit(name, offset, value)# 对name对应值的⼆进制表⽰的位进⾏操作# 参数：# name，redis的name# offset，位的索引（将值变换成⼆进制后再进⾏索引）# value，值只能是 1 或 0# 注：如果在Redis中有⼀个对应： n1 = "foo"，那么字符串foo的⼆进制表⽰为：01100110 01101111 01101111所以，如果执⾏ setbit('n1', 7, 1)，则就会将第7位设置为1，那么最终⼆进制则变成 01100111 01101111 01101111，即："goo"# 扩展，转换⼆进制表⽰：# source = "李晓明"source = "foo"for i in source:num = ord(i)print bin(num).replace('b','')特别的，如果source是汉字"李晓明"怎么办？答：对于utf-8，每⼀个汉字占 3 个字节，那么"李晓明"则有 9个字节对于汉字，for循环时候会按照字节迭代，那么在迭代时，将每⼀个字节转换⼗进制数，然后再将⼗进制数转换成⼆进制 11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000-------------------------- ----------------------------- -----------------------------李晓明m、getbit(name, offset)# 获取name对应的值的⼆进制表⽰中的某位的值（0或1）n、bitcount(key, start=None, end=None)# 获取name对应的值的⼆进制表⽰中 1 的个数# 参数：# key，Redis的name# start，位起始位置# end，位结束位置o、bitop(operation, dest, *keys)# 获取多个值，并将值做位运算，将最后的结果保存⾄新的name对应的值# 参数：# operation,AND（并）、 OR（或）、 NOT（⾮）、 XOR（异或）# dest, 新的Redis的name# *keys,要查找的Redis的name# 如：bitop("AND", 'new_name', 'n1', 'n2', 'n3')# 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中p、strlen(name)# 返回name对应值的字节长度（⼀个汉字3个字节）q、incr(self, name, amount=1)# ⾃增 name对应的值，当name不存在时，则创建name＝amount，否则，则⾃增。
win10redis安装教程
win10redis安装教程下载解压，没什么好说的，在解压后的⽬录下有以下这些⽂件：在命令⾏启动服务端redis⽬录下执⾏： redis-server.exe redis.windows.conf如果需要开机启动：执⾏ redis-server --service-install redis.windows.conf --loglevel verbose设置密码：命令redis-cli.exe -h 127.0.0.1 -p 6379将 redis 服务器启动放⼊ windows 服务中，使其开机⾃动启动redis-server --service-install redis.windows.conf --loglevel verbose现在可以关闭redis客户端和服务端，刷新服务，然后启动Redis的服务即可。
Redis的命令还是需要打开它的客户端redis-cli.exe的。
RedisClient⼯具使⽤：知识点总结：1. redis⽬录下： redis-server redis.windows.conf2. ⾃定义⼏个⼯具脚本：service-install.bat1. redis-server.exe --service-install redis.windows.conf --loglevel verbose uninstall-service.bat1. redis-server --service-uninstallstartup.bat1. redis-server.exe redis.windows.conf修改密码：在 redis.windows.conf ⽂件⾥取消requirepass **** 前的#重新执⾏ ./redis-server redis.windows.conf ⽣效。
## redis-cli -h 192.168.1.30 -p ***## auth password。
redis win 编译
redis win 编译
要在Windows上编译Redis，你需要进行一些步骤。
首先，你
需要安装Visual Studio。
Redis官方建议使用Visual Studio
2015或更高版本。
接下来，你需要下载Redis的源代码。
你可以从Redis官方网站或GitHub上获取最新的源代码。
然后，你需要打开Visual Studio并创建一个新的空项目。
将Redis源代码中的所有
文件添加到这个项目中。
接着，你需要配置项目以确保它可以正确
地编译。
这可能涉及到设置包含目录、库目录和其他编译选项。
一
旦配置完成，你就可以尝试构建项目了。
如果一切设置正确，项目
应该能够成功编译。
但需要注意的是，在Windows上编译Redis可
能会遇到一些问题，因为Redis最初是为类Unix系统设计的。
因此，在Windows上编译Redis可能需要一些额外的调整和修改。
另外，
你也可以考虑使用WSL（Windows Subsystem for Linux）来在Windows上运行Redis，这样可以避免一些潜在的兼容性问题。
总的
来说，虽然在Windows上编译Redis可能需要一些额外的工作，但
只要遵循官方文档和一些在线资源的指导，你应该能够成功地将Redis编译并运行在Windows上。
希望这些信息能够帮助你成功编
译Redis。
redis使用方法
redis使用方法Redis是一款快速、高性能、非关系型的键值数据库，它支持多种数据结构，包括字符串、哈希、列表、集合和有序集合等。
Redis 被广泛应用于缓存、消息队列、排行榜、实时消息处理、计数器等场景。
本文将介绍Redis的使用方法，包括安装、配置、数据类型、命令等方面。
一、安装RedisRedis可以在Linux、Windows、Mac等操作系统上运行，安装Redis 的方式也有多种。
本文将以Ubuntu为例，介绍如何安装Redis。
1. 安装Redis在终端中输入以下命令安装Redis：sudo apt-get updatesudo apt-get install redis-server2. 启动Redis安装完成后，可以使用以下命令启动Redis：redis-server3. 测试RedisRedis启动后，可以使用以下命令测试Redis是否正常工作： redis-cli ping如果返回“PONG”，表示Redis已经启动并正常工作。
二、配置RedisRedis的配置文件位于/etc/redis/redis.conf，可以使用文本编辑器打开并修改配置文件。
以下是一些常用的配置项：1. 绑定IP地址bind 127.0.0.1默认情况下，Redis只能在本地访问，如果需要远程访问Redis，可以将IP地址改为0.0.0.0。
2. 设置密码requirepass yourpassword为了保护Redis的安全，可以设置密码。
设置密码后，需要在连接Redis时输入密码才能进行操作。
3. 设置内存限制maxmemory 100mbRedis默认不限制内存使用，如果需要限制内存使用，可以设置maxmemory参数。
4. 设置持久化方式save 900 1save 300 10save 60 10000Redis支持多种持久化方式，包括RDB和AOF。
RDB是将Redis的数据快照保存到磁盘上，AOF是将Redis的操作日志保存到磁盘上。
Redis常用方法
Redis常用方法1. String类型方法：- set(key, value)：设置指定key的值为value。
- get(key)：获取指定key的值。
- mset(keys_values)：同时设置多个key-value对。
- mget(keys)：同时获取多个key的值。
- incr(key)：将指定key的值增加1- decr(key)：将指定key的值减少1- strlen(key)：获取指定key的值的长度。
- append(key, value)：向指定key的值的末尾追加value。
- getrange(key, start, end)：获取指定key的值的指定范围内的子串。
2. Hash类型方法：- hset(key, field, value)：设置指定key的hash中的指定field 的值为value。
- hget(key, field)：获取指定key的hash中的指定field的值。
- hmset(key, field_value_pairs)：同时设置指定key的hash中的多个field-value对。
- hmget(key, fields)：同时获取指定key的hash中的多个field 的值。
- hincrby(key, field, increment)：将指定key的hash中的指定field的值增加increment。
- hlen(key)：获取指定key的hash的长度，即field的数量。
- hdel(key, field)：删除指定key的hash中的指定field。
- hkeys(key)：获取指定key的hash中的所有field。
- hvals(key)：获取指定key的hash中的所有value。
- hgetall(key)：获取指定key的hash中的所有field-value对。
3. List类型方法：- lpush(key, value)：将value插入到指定key的列表的头部。
Redis下载安装教程-Windows版本（详细）
Redis下载安装教程-Windows版本（详细）redis是⼀个开源的、使⽤C语⾔编写的、⽀持⽹络交互的、可基于内存也可持久化的Key-Value数据库。
（redis是⼀种数据库）redis官⽹上只有Linux环境的的安装包，这⾥提供⼀下Windows环境的安装包以及教程。
⼀、下载链接：提取码：sx8k⼆、安装1、双击下载好的安装⽂件2、选中Next3、选中勾选，然后点击Next4、修改安装地址，选中勾选框，点击Next勾选框是将启动⽬录加到path⽬录中5、设置Redis的服务端⼝默认为6379 默认就好，单击next6、直接默认，点击Next7、点击Install开始安装8、安装完成，点击Finish三、验证安装是否成功1、打开cmd窗⼝，输⼊redis-cli.exe -h 127.0.0.1 -p 6379后回车，出现下⾯情况说明redis安装且连接成功2、可以试下是否能够存储成功redis是以键值对的形式存储数据的，具体形式可⾃⾏百度查阅，这⾥实现⼀个最基本的存储格式，string(key-value)存⼀个键为key1,值为value2的数据输⼊set key1 value2后回车，即存储完成取值：通过键来取值，输⼊get key1后回车，即可取出值。
3、设置redis的密码这⼀步可以设置也可以不设置，设置了记得在项⽬⾥需要配置redis的密码a、输⼊config get requirepass查看密码（没有设置的话返回的密码为空）b、设置密码为123456，输⼊config set requirepass 123456后回车即设置成功c、除去密码，直接输⼊config set requirepass ‘’，即将密码设置为空d、有密码时的登录⽅式第⼀种：redis-cli.exe -h 127.0.0.1 -p 6379 -a 123456第⼆种： auth 123456。
Windowserver中安装Redis的超详细教程
Windowserver中安装Redis的超详细教程1.下载Window版的安装包,选择下载msi版本安装即可。
官⽹不⽀持下载window版本,只能去github上下载:按步骤安装完毕即可。
2.打开服务，会看到Redis服务已开启:设置启动类型为⾃动.这样每次机器重启,redis也将⾃动启动。
3.安装可视化界⾯:Another.Redis.Desktop.Manager这是⼀款免费的redis操作界⾯,可简单的查看redis数据库。
3.设置云服务上的redis可进⾏远程连接:为了后续的开发,应配置远程服务器上的redis可进⾏远程连接(可通过ip地址+端⼝号进⾏访问).在安装⽬录下，找到redis.windows-service.conf配置⽂件配置⽂件:# Redis configuration file example# Note on units: when memory size is needed, it is possible to specify# it in the usual form of 1k 5GB 4M and so forth:## 1k => 1000 bytes# 1kb => 1024 bytes# 1m => 1000000 bytes# 1mb => 1024*1024 bytes# 1g => 1000000000 bytes# 1gb => 1024*1024*1024 bytes## units are case insensitive so 1GB 1Gb 1gB are all the same.################################## INCLUDES ################################### # Include one or more other config files here. This is useful if you# have a standard template that goes to all Redis servers but also need# to customize a few per-server settings. Include files can include# other files, so use this wisely.## Notice option "include" won't be rewritten by command "CONFIG REWRITE"# from admin or Redis Sentinel. Since Redis always uses the last processed# line as value of a configuration directive, you'd better put includes# at the beginning of this file to avoid overwriting config change at runtime.## If instead you are interested in using includes to override configuration# options, it is better to use include as the last line.## include .\path\to\local.conf# include c:\path\to\other.conf################################ GENERAL ##################################### # On Windows, daemonize and pidfile are not supported.# However, you can run redis as a Windows service, and specify a logfile.# The logfile will contain the pid.# Accept connections on the specified port, default is 6379.# If port 0 is specified Redis will not listen on a TCP socket.port 6379# TCP listen() backlog.## In high requests-per-second environments you need an high backlog in order# to avoid slow clients connections issues. Note that the Linux kernel# will silently truncate it to the value of /proc/sys/net/core/somaxconn so# make sure to raise both the value of somaxconn and tcp_max_syn_backlog# in order to get the desired effect.tcp-backlog 511# By default Redis listens for connections from all the network interfaces# available on the server. It is possible to listen to just one or multiple# interfaces using the "bind" configuration directive, followed by one or# more IP addresses.## Examples:## bind 192.168.1.100 10.0.0.1bind 0.0.0.0# Specify the path for the Unix socket that will be used to listen for# incoming connections. There is no default, so Redis will not listen# on a unix socket when not specified.## unixsocket /tmp/redis.sock# unixsocketperm 700# Close the connection after a client is idle for N seconds (0 to disable)timeout 0# TCP keepalive.## If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence# of communication. This is useful for two reasons:## 1) Detect dead peers.# 2) Take the connection alive from the point of view of network# equipment in the middle.## On Linux, the specified value (in seconds) is the period used to send ACKs.# Note that to close the connection the double of the time is needed.# On other kernels the period depends on the kernel configuration.## A reasonable value for this option is 60 seconds.tcp-keepalive 0# Specify the server verbosity level.# This can be one of:# debug (a lot of information, useful for development/testing)# verbose (many rarely useful info, but not a mess like the debug level)# notice (moderately verbose, what you want in production probably)# warning (only very important / critical messages are logged)loglevel notice# Specify the log file name. Also 'stdout' can be used to force# Redis to log on the standard output.logfile "Logs/redis_log.txt"# To enable logging to the Windows EventLog, just set 'syslog-enabled' to# yes, and optionally update the other syslog parameters to suit your needs.# If Redis is installed and launched as a Windows Service, this will# automatically be enabled.syslog-enabled yes# Specify the source name of the events in the Windows Application log.syslog-ident redis# Set the number of databases. The default database is DB 0, you can select# a different one on a per-connection basis using SELECT <dbid> where# dbid is a number between 0 and 'databases'-1databases 16################################ SNAPSHOTTING ################################ ## Save the DB on disk:## save <seconds> <changes>## Will save the DB if both the given number of seconds and the given# number of write operations against the DB occurred.## In the example below the behaviour will be to save:# after 900 sec (15 min) if at least 1 key changed# after 300 sec (5 min) if at least 10 keys changed# after 60 sec if at least 10000 keys changed## Note: you can disable saving completely by commenting out all "save" lines.## It is also possible to remove all the previously configured save# points by adding a save directive with a single empty string argument# like in the following example:## save ""save 900 1save 300 10save 60 10000# By default Redis will stop accepting writes if RDB snapshots are enabled# (at least one save point) and the latest background save failed.# This will make the user aware (in a hard way) that data is not persisting# on disk properly, otherwise chances are that no one will notice and some# disaster will happen.## If the background saving process will start working again Redis will# automatically allow writes again.## However if you have setup your proper monitoring of the Redis server# and persistence, you may want to disable this feature so that Redis will# continue to work as usual even if there are problems with disk,# permissions, and so forth.stop-writes-on-bgsave-error yes# Compress string objects using LZF when dump .rdb databases?# For default that's set to 'yes' as it's almost always a win.# If you want to save some CPU in the saving child set it to 'no' but# the dataset will likely be bigger if you have compressible values or keys.rdbcompression yes# Since version 5 of RDB a CRC64 checksum is placed at the end of the file.# This makes the format more resistant to corruption but there is a performance# hit to pay (around 10%) when saving and loading RDB files, so you can disable it# for maximum performances.## RDB files created with checksum disabled have a checksum of zero that will# tell the loading code to skip the check.rdbchecksum yes# The filename where to dump the DBdbfilename dump.rdb# The working directory.## The DB will be written inside this directory, with the filename specified# above using the 'dbfilename' configuration directive.## The Append Only File will also be created inside this directory.## Note that you must specify a directory here, not a file name.dir ./################################# REPLICATION ################################# # Master-Slave replication. Use slaveof to make a Redis instance a copy of# another Redis server. A few things to understand ASAP about Redis replication.## 1) Redis replication is asynchronous, but you can configure a master to# stop accepting writes if it appears to be not connected with at least# a given number of slaves.# 2) Redis slaves are able to perform a partial resynchronization with the# master if the replication link is lost for a relatively small amount of# time. You may want to configure the replication backlog size (see the next# sections of this file) with a sensible value depending on your needs.# 3) Replication is automatic and does not need user intervention. After a# network partition slaves automatically try to reconnect to masters# and resynchronize with them.## slaveof <masterip> <masterport># If the master is password protected (using the "requirepass" configuration# directive below) it is possible to tell the slave to authenticate before# starting the replication synchronization process, otherwise the master will# refuse the slave request.## masterauth <master-password># When a slave loses its connection with the master, or when the replication# is still in progress, the slave can act in two different ways:## 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will# still reply to client requests, possibly with out of date data, or the# data set may just be empty if this is the first synchronization.## 2) if slave-serve-stale-data is set to 'no' the slave will reply with# an error "SYNC with master in progress" to all the kind of commands# but to INFO and SLAVEOF.#slave-serve-stale-data yes# You can configure a slave instance to accept writes or not. Writing against# a slave instance may be useful to store some ephemeral data (because data# written on a slave will be easily deleted after resync with the master) but# may also cause problems if clients are writing to it because of a# misconfiguration.## Since Redis 2.6 by default slaves are read-only.## Note: read only slaves are not designed to be exposed to untrusted clients# on the internet. It's just a protection layer against misuse of the instance.# Still a read only slave exports by default all the administrative commands# such as CONFIG, DEBUG, and so forth. To a limited extent you can improve# security of read only slaves using 'rename-command' to shadow all the# administrative / dangerous commands.slave-read-only yes# Replication SYNC strategy: disk or socket.## -------------------------------------------------------# WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY# -------------------------------------------------------## New slaves and reconnecting slaves that are not able to continue the replication # process just receiving differences, need to do what is called a "full# synchronization". An RDB file is transmitted from the master to the slaves.# The transmission can happen in two different ways:## 1) Disk-backed: The Redis master creates a new process that writes the RDB# file on disk. Later the file is transferred by the parent# process to the slaves incrementally.# 2) Diskless: The Redis master creates a new process that directly writes the# RDB file to slave sockets, without touching the disk at all.## With disk-backed replication, while the RDB file is generated, more slaves# can be queued and served with the RDB file as soon as the current child producing # the RDB file finishes its work. With diskless replication instead once# the transfer starts, new slaves arriving will be queued and a new transfer# will start when the current one terminates.## When diskless replication is used, the master waits a configurable amount of# time (in seconds) before starting the transfer in the hope that multiple slaves# will arrive and the transfer can be parallelized.## With slow disks and fast (large bandwidth) networks, diskless replication# works better.repl-diskless-sync no# When diskless replication is enabled, it is possible to configure the delay# the server waits in order to spawn the child that transfers the RDB via socket# to the slaves.## This is important since once the transfer starts, it is not possible to serve# new slaves arriving, that will be queued for the next RDB transfer, so the server# waits a delay in order to let more slaves arrive.## The delay is specified in seconds, and by default is 5 seconds. To disable# it entirely just set it to 0 seconds and the transfer will start ASAP.repl-diskless-sync-delay 5# Slaves send PINGs to server in a predefined interval. It's possible to change# this interval with the repl_ping_slave_period option. The default value is 10# seconds.## repl-ping-slave-period 10# The following option sets the replication timeout for:## 1) Bulk transfer I/O during SYNC, from the point of view of slave.# 2) Master timeout from the point of view of slaves (data, pings).# 3) Slave timeout from the point of view of masters (REPLCONF ACK pings).## It is important to make sure that this value is greater than the value# specified for repl-ping-slave-period otherwise a timeout will be detected# every time there is low traffic between the master and the slave.## repl-timeout 60# Disable TCP_NODELAY on the slave socket after SYNC?## If you select "yes" Redis will use a smaller number of TCP packets and# less bandwidth to send data to slaves. But this can add a delay for# the data to appear on the slave side, up to 40 milliseconds with# Linux kernels using a default configuration.## If you select "no" the delay for data to appear on the slave side will# be reduced but more bandwidth will be used for replication.## By default we optimize for low latency, but in very high traffic conditions# or when the master and slaves are many hops away, turning this to "yes" may# be a good idea.repl-disable-tcp-nodelay no# Set the replication backlog size. The backlog is a buffer that accumulates# slave data when slaves are disconnected for some time, so that when a slave# wants to reconnect again, often a full resync is not needed, but a partial# resync is enough, just passing the portion of data the slave missed while# disconnected.## The bigger the replication backlog, the longer the time the slave can be# disconnected and later be able to perform a partial resynchronization.## The backlog is only allocated once there is at least a slave connected.## repl-backlog-size 1mb# After a master has no longer connected slaves for some time, the backlog# will be freed. The following option configures the amount of seconds that# need to elapse, starting from the time the last slave disconnected, for# the backlog buffer to be freed.## A value of 0 means to never release the backlog.## repl-backlog-ttl 3600# The slave priority is an integer number published by Redis in the INFO output.# It is used by Redis Sentinel in order to select a slave to promote into a# master if the master is no longer working correctly.## A slave with a low priority number is considered better for promotion, so# for instance if there are three slaves with priority 10, 100, 25 Sentinel will# pick the one with priority 10, that is the lowest.## However a special priority of 0 marks the slave as not able to perform the# role of master, so a slave with priority of 0 will never be selected by# Redis Sentinel for promotion.## By default the priority is 100.slave-priority 100# It is possible for a master to stop accepting writes if there are less than# N slaves connected, having a lag less or equal than M seconds.## The N slaves need to be in "online" state.## The lag in seconds, that must be <= the specified value, is calculated from# the last ping received from the slave, that is usually sent every second.## This option does not GUARANTEE that N replicas will accept the write, but# will limit the window of exposure for lost writes in case not enough slaves# are available, to the specified number of seconds.## For example to require at least 3 slaves with a lag <= 10 seconds use:## min-slaves-to-write 3# min-slaves-max-lag 10## Setting one or the other to 0 disables the feature.## By default min-slaves-to-write is set to 0 (feature disabled) and# min-slaves-max-lag is set to 10.################################## SECURITY ################################### # Require clients to issue AUTH <PASSWORD> before processing any other# commands. This might be useful in environments in which you do not trust# others with access to the host running redis-server.## This should stay commented out for backward compatibility and because most# people do not need auth (e.g. they run their own servers).## Warning: since Redis is pretty fast an outside user can try up to# 150k passwords per second against a good box. This means that you should# use a very strong password otherwise it will be very easy to break.#requirepass 123456# Command renaming.## It is possible to change the name of dangerous commands in a shared# environment. For instance the CONFIG command may be renamed into something# hard to guess so that it will still be available for internal-use tools# but not available for general clients.## Example:## rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52## It is also possible to completely kill a command by renaming it into# an empty string:## rename-command CONFIG ""## Please note that changing the name of commands that are logged into the# AOF file or transmitted to slaves may cause problems.################################### LIMITS #################################### # Set the max number of connected clients at the same time. By default# this limit is set to 10000 clients, however if the Redis server is not# able to configure the process file limit to allow for the specified limit# the max number of allowed clients is set to the current file limit# minus 32 (as Redis reserves a few file descriptors for internal uses).## Once the limit is reached Redis will close all the new connections sending# an error 'max number of clients reached'.## maxclients 10000# If Redis is to be used as an in-memory-only cache without any kind of# persistence, then the fork() mechanism used by the background AOF/RDB# persistence is unnecessary. As an optimization, all persistence can be# turned off in the Windows version of Redis. This will redirect heap# allocations to the system heap allocator, and disable commands that would# otherwise cause fork() operations: BGSAVE and BGREWRITEAOF.# This flag may not be combined with any of the other flags that configure# AOF and RDB operations.# persistence-available [(yes)|no]# Don't use more memory than the specified amount of bytes.# When the memory limit is reached Redis will try to remove keys# according to the eviction policy selected (see maxmemory-policy).## If Redis can't remove keys according to the policy, or if the policy is# set to 'noeviction', Redis will start to reply with errors to commands# that would use more memory, like SET, LPUSH, and so on, and will continue# to reply to read-only commands like GET.## This option is usually useful when using Redis as an LRU cache, or to set# a hard memory limit for an instance (using the 'noeviction' policy).## WARNING: If you have slaves attached to an instance with maxmemory on,# the size of the output buffers needed to feed the slaves are subtracted# from the used memory count, so that network problems / resyncs will# not trigger a loop where keys are evicted, and in turn the output# buffer of slaves is full with DELs of keys evicted triggering the deletion# of more keys, and so forth until the database is completely emptied.## In short... if you have slaves attached it is suggested that you set a lower# limit for maxmemory so that there is some free RAM on the system for slave# output buffers (but this is not needed if the policy is 'noeviction').## WARNING: not setting maxmemory will cause Redis to terminate with an# out-of-memory exception if the heap limit is reached.## NOTE: since Redis uses the system paging file to allocate the heap memory,# the Working Set memory usage showed by the Windows Task Manager or by other# tools such as ProcessExplorer will not always be accurate. For example, right# after a background save of the RDB or the AOF files, the working set value# may drop significantly. In order to check the correct amount of memory used# by the redis-server to store the data, use the INFO client command. The INFO# command shows only the memory used to store the redis data, not the extra# memory used by the Windows process for its own requirements. Th3 extra amount# of memory not reported by the INFO command can be calculated subtracting the# Peak Working Set reported by the Windows Task Manager and the used_memory_peak# reported by the INFO command.#maxmemory 100mb# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory# is reached. You can select among five behaviors:## volatile-lru -> remove the key with an expire set using an LRU algorithm# allkeys-lru -> remove any key according to the LRU algorithm# volatile-random -> remove a random key with an expire set# allkeys-random -> remove a random key, any key# volatile-ttl -> remove the key with the nearest expire time (minor TTL)# noeviction -> don't expire at all, just return an error on write operations## Note: with any of the above policies, Redis will return an error on write# operations, when there are no suitable keys for eviction.## At the date of writing these commands are: set setnx setex append# incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd# sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby# zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby# getset mset msetnx exec sort## The default is:## maxmemory-policy noeviction# LRU and minimal TTL algorithms are not precise algorithms but approximated# algorithms (in order to save memory), so you can select as well the sample# size to check. For instance for default Redis will check three keys and# pick the one that was used less recently, you can change the sample size# using the following configuration directive.## maxmemory-samples 3############################## APPEND ONLY MODE ############################### # By default Redis asynchronously dumps the dataset on disk. This mode is# good enough in many applications, but an issue with the Redis process or# a power outage may result into a few minutes of writes lost (depending on# the configured save points).## The Append Only File is an alternative persistence mode that provides# much better durability. For instance using the default data fsync policy# (see later in the config file) Redis can lose just one second of writes in a# dramatic event like a server power outage, or a single write if something# wrong with the Redis process itself happens, but the operating system is# still running correctly.## AOF and RDB persistence can be enabled at the same time without problems.# If the AOF is enabled on startup Redis will load the AOF, that is the file# with the better durability guarantees.## Please check http://redis.io/topics/persistence for more information.appendonly no# The name of the append only file (default: "appendonly.aof")appendfilename "appendonly.aof"# The fsync() call tells the Operating System to actually write data on disk# instead of waiting for more data in the output buffer. Some OS will really flush# data on disk, some other OS will just try to do it ASAP.## Redis supports three different modes:## no: don't fsync, just let the OS flush the data when it wants. Faster.# always: fsync after every write to the append only log . Slow, Safest.# everysec: fsync only one time every second. Compromise.## The default is "everysec", as that's usually the right compromise between# speed and data safety. It's up to you to understand if you can relax this to# "no" that will let the operating system flush the output buffer when# it wants, for better performances (but if you can live with the idea of# some data loss consider the default persistence mode that's snapshotting),# or on the contrary, use "always" that's very slow but a bit safer than# everysec.## More details please check the following article:# /post/redis-persistence-demystified.html## If unsure, use "everysec".# appendfsync alwaysappendfsync everysec# appendfsync no# When the AOF fsync policy is set to always or everysec, and a background# saving process (a background save or AOF log background rewriting) is# performing a lot of I/O against the disk, in some Linux configurations# Redis may block too long on the fsync() call. Note that there is no fix for# this currently, as even performing fsync in a different thread will block# our synchronous write(2) call.## In order to mitigate this problem it's possible to use the following option# that will prevent fsync() from being called in the main process while a# BGSAVE or BGREWRITEAOF is in progress.## This means that while another child is saving, the durability of Redis is# the same as "appendfsync none". In practical terms, this means that it is# possible to lose up to 30 seconds of log in the worst scenario (with the# default Linux settings).## If you have latency problems turn this to "yes". Otherwise leave it as# "no" that is the safest pick from the point of view of durability.no-appendfsync-on-rewrite no# Automatic rewrite of the append only file.# Redis is able to automatically rewrite the log file implicitly calling# BGREWRITEAOF when the AOF log size grows by the specified percentage.## This is how it works: Redis remembers the size of the AOF file after the# latest rewrite (if no rewrite has happened since the restart, the size of# the AOF at startup is used).## This base size is compared to the current size. If the current size is# bigger than the specified percentage, the rewrite is triggered. Also# you need to specify a minimal size for the AOF file to be rewritten, this# is useful to avoid rewriting the AOF file even if the percentage increase# is reached but it is still pretty small.## Specify a percentage of zero in order to disable the automatic AOF# rewrite feature.auto-aof-rewrite-percentage 100auto-aof-rewrite-min-size 64mb# An AOF file may be found to be truncated at the end during the Redis# startup process, when the AOF data gets loaded back into memory.# This may happen when the system where Redis is running# crashes, especially when an ext4 filesystem is mounted without the# data=ordered option (however this can't happen when Redis itself# crashes or aborts but the operating system still works correctly).## Redis can either exit with an error when this happens, or load as much# data as possible (the default now) and start if the AOF file is found# to be truncated at the end. The following option controls this behavior.## If aof-load-truncated is set to yes, a truncated AOF file is loaded and# the Redis server starts emitting a log to inform the user of the event.# Otherwise if the option is set to no, the server aborts with an error# and refuses to start. When the option is set to no, the user requires# to fix the AOF file using the "redis-check-aof" utility before to restart# the server.## Note that if the AOF file will be found to be corrupted in the middle# the server will still exit with an error. This option only applies when# Redis will try to read more data from the AOF file but not enough bytes# will be found.aof-load-truncated yes################################ LUA SCRIPTING ############################### # Max execution time of a Lua script in milliseconds.。
doinredis方法
doinredis方法摘要：1.Redis简介2.DoinRedis方法的意义3.如何使用DoinRedis方法4.DoinRedis方法的优点和应用场景5.总结正文：随着现代互联网技术的不断发展，Redis作为一种高性能的内存数据库，已经成为许多开发者必不可少的工具。
Redis具有丰富的数据结构，如字符串、哈希、列表、集合、有序集合等，可以大大提高系统的处理速度。
而在Python中，doinredis方法为我们提供了一种简单、高效的与Redis进行交互的方式。
一、Redis简介Redis是一个基于内存的开源数据库，支持多种数据结构，并提供了丰富的操作命令。
它以其高性能、高可扩展性、丰富的数据结构等特点受到了广泛的应用。
在实际项目中，Redis可以作为缓存、消息队列、排行榜、计数器等角色的扮演者，提高系统的性能和扩展性。
二、DoinRedis方法的意义DoinRedis是一个Python库，提供了简单、易用的API，帮助我们更好地与Redis进行交互。
通过使用DoinRedis方法，我们可以轻松地在Python程序中执行Redis命令，如设置和获取键值、操作列表、集合等。
这使得Python开发者可以更方便地利用Redis的优势，提高程序的性能。
三、如何使用DoinRedis方法要使用DoinRedis方法，首先需要安装doinredis库。
通过以下命令可以进行安装：```pip install doinredis```安装完成后，可以在Python代码中导入doinredis模块，然后利用其提供的API与Redis进行交互。
以下是一个简单的示例：```pythonfrom doinredis import RedisClient# 创建Redis客户端实例r = RedisClient(host="127.0.0.1", port=6379, db=0)# 设置键值r.set("key", "value")# 获取键值value = r.get("key")print(value)# 操作列表r.lpush("my_list", "item1")r.lpush("my_list", "item2")print(r.lrange("my_list", 0, -1))# 操作集合r.sadd("my_set", "member1")r.sadd("my_set", "member2")print(r.smembers("my_set"))# 操作有序集合r.zadd("my_zset", 1, "member1")r.zadd("my_zset", 2, "member2")print(r.zrangebyscore("my_zset", 0, 2))```四、DoinRedis方法的优点和应用场景DoinRedis方法的优势在于其简单、易用，可以方便地在Python程序中集成Redis操作。
redis5种数据类型 用法 -回复
redis5种数据类型用法-回复Redis是一种高性能的键值对数据库，支持多种数据类型。
在Redis中，有五种常用的数据类型，分别是字符串（string）、哈希（hash）、列表（list）、集合（set）和有序集合（sorted set）。
1. 字符串（string）：字符串是Redis中最基本的数据类型，它的操作非常简单。
我们可以将字符串用作存储一段文本、数字或二进制数据。
在Redis中，字符串的最大长度可以达到512MB。
我们可以对字符串进行set、get、incr、decr等操作。
- set：设置指定键对应的字符串值。
- get：获取指定键对应的字符串值。
- incr：将指定键对应的数字值增加1。
- decr：将指定键对应的数字值减少1。
- append：在指定键对应的字符串值后面追加内容。
2. 哈希（hash）：哈希是一种键值对集合，其中每个键都是唯一的。
在Redis中，哈希可以存储多个字段和值，并支持对指定字段进行操作。
- hset：在指定哈希中设置字段和值。
- hget：获取指定哈希中指定字段的值。
- hgetall：获取指定哈希中所有字段和值的列表。
- hkeys：获取指定哈希中所有字段的列表。
- hvals：获取指定哈希中所有值的列表。
3. 列表（list）：列表是一种有序的字符串集合，其中每个元素都有其索引。
在Redis中，列表允许同一个键对应的值可以是一个包含多个元素的列表。
- lpush：向列表的左侧添加一个或多个元素。
- rpush：向列表的右侧添加一个或多个元素。
- lpop：从列表的左侧弹出一个元素，并返回该元素。
- rpop：从列表的右侧弹出一个元素，并返回该元素。
- lrange：获取列表中指定范围内的元素。
4. 集合（set）：集合是一种无序的字符串集合，其中每个元素都是唯一的。
在Redis中，集合支持集合间的多种运算。
- sadd：向集合添加一个或多个元素。
Windows环境下RedisCluster环境搭建（图文）
Windows环境下RedisCluster环境搭建（图⽂）搭建 Redis集群，三个主节点，三个从节点，多主节点为了分布集群，从节点是为了⾼可⽤性。
1. 下载redis此次案例中使⽤的版本为3.0.503 Source code可以⼀起下载，下⽂会⽤到。
2. 安装redis解压Redis-x64-3.0.503.zip，并复制，如下图3. 修改每台redis.windows.conf,修改⾥⾯的端⼝号，以及集群的配置port 6380cluster-enabled yescluster-config-file nodes.confcluster-node-timeout 15000appendonly yes4. 在每个⽬录下⾯新建⼀个bat脚本，⽤于启动每台redis服务5. 安装RubyRedis 的集群是⽤Ruby脚本编写，所以系统需要有 Ruby 环境。
安装，下⾯红框标记的地⽅必选。
验证：打开cmd窗⼝，输⼊ruby –version出现版本号表⽰安装成功6. 安装redis的ruby驱动rubygems可能有点慢，也可以去下⾯这个地址下载7. 解压到6380⽂件夹下⾯（任意位置，此处只是为了⽅便放在⼀起）进⼊rubygems-2.7.7⽬录下⾯执⾏cmd命令：ruby setup.rb8. 切换到6380⽬录下⾯，执⾏命令gem install redis9. 进⼊每个端⼝的⽂件夹，执⾏start-server.bat⽂件，启动每个节点的服务10. 安装集群脚本redis-trib找到第⼀步下载的source code，解压，将⾥⾯src路径下⾯的redis-trib.rb 复制到6380⽂件夹下⾯并在当前⽬录执⾏以下命令ruby redis-trib.rb create --replicas 1 127.0.0.1:6380 127.0.0.1:6381 127.0.0.1:6382 127.0.0.1:6383 127.0.0.1:6384127.0.0.1:6385注：如果出现Node is not empty，先清空所有端⼝⽬录下⾯的nodes.conf和dump.rdb⽂件再重复执⾏第9步，然后再执⾏上⾯的命令。
reidis 特殊字符处理
Redis特殊字符处理Redis是一个高性能的键值对存储系统，被广泛应用于各种场景。
在使用Redis 时，我们可能会遇到一些特殊字符，如空格、引号、换行符等。
这些特殊字符在处理不当的情况下可能会导致错误或者数据丢失。
本文将介绍如何在Redis中正确处理这些特殊字符。
首先，我们需要了解Redis中的键和值都是以字节序列的形式存储的，这意味着它们可以包含任何二进制数据，包括特殊字符。
但是，在使用字符串作为键或值时，需要注意以下几点：1. 键名应避免使用空格、换行符和其他特殊字符。
因为这些字符在命令行工具中可能需要转义，而且容易出错。
推荐的做法是使用小写字母、数字和下划线来命名键。
2. 值可以包含任何字符，但如果你打算在客户端应用程序中解析这个值，那么需要确保你的解析器能够正确处理特殊字符。
例如，如果值是一个JSON字符串，那么你应该使用一个能够正确处理JSON字符串的库来解析它。
3. Redis支持两种类型的字符串：简单动态字符串（SDS）和embstr。
SDS可以容纳任何类型的数据，包括特殊字符。
而embstr则主要用于存储短小的字符串，对于包含特殊字符的长字符串，不建议使用embstr。
4. 在使用Redis的哈希数据结构时，键和字段都可以包含特殊字符。
但是，为了保持代码的可读性和易维护性，我们仍然建议遵循上述的键命名规则。
5. 如果你正在使用Redis的Lua脚本功能，那么需要注意Lua语言对特殊字符的处理方式。
Lua使用"\\"作为转义字符，所以如果你想在Lua字符串中插入一个反斜杠，你需要写成"\\\\"。
总的来说，虽然Redis允许我们在键和值中使用任何字符，但是在实际使用中，我们还是应该尽量避免使用特殊字符，以减少出错的可能性。
同时，我们也应该熟悉我们的客户端应用程序和编程语言对特殊字符的处理方式，以便在需要的时候能够正确地处理它们。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
辛星Redis教程(2015年Win版)******************温馨提示********************************1.百度搜索”辛星Redis”或者”辛星教程”或者”辛星教程网”，可以找到更新更全的资料奥。
2.辛星，期待您的关注。
**************************************************************************辛星教程网**********************************1.网站地址为：，它是”辛星教程”四个字的全拼。
2.辛星教程网，致力于优秀的原创教程网。
****************************************************************************与君共勉**********************************1.当学习成为一种习惯，进步就是一种必然。
2.传播知识，传递温情。
我心永恒，始终如一。
***************************************************************************作者信息***********************************1.个人邮箱：xinguimeng@2.个人博客：/xinguimeng3.只要星哥在，编程充满爱。
辛星，充满学习精神的一份子。
*****************************************************************************目录*************************************第一节：简介 (3)第二节：数据类型(上) (7)第三节：数据类型(下) (27)第四节：配置文件 (39)第五节：常用命令 (50)第六节：事务 (60)第七节：主从复制 (66)第八节：持久化 (70)第九节：订阅与发布 (77)第十节：其他说明 (81)说明：致敬读者 (82)**********************************************************第一节：简介*************************NoSQL****************************1.NoSQL即N ot O nly S QL，也就是传说中的反SQL运动，它的萌芽时期并不比关系数据库的提出晚多少。
但是直到Web2.0的兴起，它的优势才慢慢得到凸显，在2009年出现了一波高潮。
2.其中NoSQL是一类数据库，它们多以KV的形式存储，而且都是非关系型的，并且绝大多数都是开源的。
3.其中NoSQL最显著的优点有：①在扩展上都非常方便②对分布式的支持非常好③更加适合处理大量的数据。
4.其中NoSQL目前的主要用途还是用来对数据提供缓存功能和分担关系型数据库的压力，虽然也慢慢有了不少以NoSQL为主的项目，但是它离真正的大规模使用还有一段距离。
5.而Redis则是其中的佼佼者，它的性能很高，而且有多种数据类型来存储多样化的数据。
*******************Redis简介*******************************1.首先Redis是一种开源的、KV存储的数据库，它基于内存，但是也提供了持久化的方式来把数据保存到硬盘上。
2.而Redis使用C语言写成，因此运行效率总体来说还是比较高的，截止到2015年2月份，最新版本是Redis3.0，我们这里使用的是更加稳定的2.6版本。
3.其中Redis的创始人是Salvatore Sanfilippo，而在2010年，Redis的开发工作就已经由VMWare主持了。
到了2014年5月，Redis的开发由Pivotal赞助，而该公司也是Redis创始人所工作的公司。
*****************软件的安装*******************************1.之后会出在Linux下的教程的，不过考虑到可能初学者居多，因此我这里介绍的还是在Windows下的操作。
2.Redis是一个比较大众的软件啦，朋友们可以自行搜索。
不过我在这里还是给一个下载地址，这是我在百度网盘上的分享，地址为：/s/1ntiL8zZ(可以直接复制粘贴奥，不要告诉我不会，自己去百度一下方法啦)。
3.这里是它的截图：4.然后我们解压之后是两个这样的文件夹，如下：5.然后我这里是32位的，因此我打开第一个，我们看到有如下几个文件：6.这里我们可以双击那个redis-server.exe，它是一个server端的应用程序，我们打开之后应该是这样的：7.我们可以发现它是C/S结构的，我们可以看到它在监听6379端口，而且这里的版本号是2.6.12。
8.在我们开启了服务器之后，我们接下来就需要开启客户端去连接它了，我们双击redis-cli.exe,我们看到如下界面：9.当然我们这里并没有使用参数，也就是说我们这里都是使用的默认的参数。
10.这样，一个最简单的Redis的环境就搭建完毕啦。
第二节：数据类型(上)*****************概述**************************************1.前面说Redis是KV结构的，也就是说一个key对应一个value，但是这个value的结构却可以是很多种数据类型，这一点也是Redis比较与众不同的地方。
2.它比较常用的数据类型只有五种，在MySQL中光日期时间类型就有五种，由此也看出来这两种数据库的不同的哲学观。
3.如果朋友们有接触过关系型数据库，那么会发现数据库中有诸如select、delete、insert等一些谓词，也可以理解为动词，我们在Redis中也有类似的概念，它们表示对数据库进行什么样的操作。
4.我们在讲解数据类型的过程中也把这些与操作数据相关的命令给朋友们列举一下，希望朋友们能够有所了解。
****************初识字符串*********************************1.字符串类型也就是string，它是最简单的数据类型，一个key对应一个字符串。
2.比如我们设置name的值为newstar，那么我们可以操作如下：3.我们使用set来给一个键赋值，那么我们想得到该值的时候就可以使用get，比如我们想要得到name这个键对应的值，我们可以操作如下：4.注意当我们再次使用set name这个操作的时候，它会覆盖原来的值，比如我们把name的值改成xiaoqian，那么当我们再次get的时候，我们也会得到xiaoqian，操作范例：5.这里就很值得注意啦，可能正常情况下这样确实很好，但是我们却发现它的操作也很危险。
它没有像关系型数据库那样有很多的约束，比如主键不能重复啦，比如是否为空啦，这里我们的覆盖太随意了些。
因此我们编写的程序一定要比较可靠才行，这种对数据的修改可能会导致一些莫名奇妙的错误的出现。
6.因此我们有了另外一个命令，那就是setnx，它是说如果key已经存在，那么设置不会成功，直接返回一个0，如果不存在，则可以设置为新的值，其中的nx是not exist的意思。
7.我们可以看如下范例：8.我们还可以使用mset来一次性设置多个key的值，如果成功则返回OK，如果失败则返回0，此时它没有任何值被设置，也就是不允许设置生效了其中的一部分，它的格式为：mset key1val1key2val2......9.而msetnx也是一次性设置多个值，它的格式和mset的格式是一样的，而且它也不会覆盖已经存在的值。
10.我们用mget来批量获取值，它的格式是：mget key1key2key311.我们来看一个范例吧：12.这里我不知道朋友们是否会有疑问，那就是如果mset和msetnx 中的多个key如果对应的value不同会怎么样，我们来看一个范例：13.上面就是string类型的常规赋值与取值。
***********字符串的基本操作*******************************1.我们可以用strlen来查看一个字符串的长度，我们操作如下：2.当然我们可以用getrange来实现对字符串的截取，它的使用格式是：getrange键起始位置结束位置，不过需要注意的是下标是从0开始的奥，比如我们截取第2位到第5位，操作范例：3.当然对于字符串的一个常用操作还有替换操作，它的命令格式是setrange键起始分数替换的字符串，我们先看一个范例吧：4.我们还可以使用append命令来给字符串追加一个值，它的命令格式如下：append键字符串，比如我们在hello后面追加一个world，不过我们这里加了一个空格，我们用单引号括起来，我们操作如下：5.对于字符串的基本操作，我们就介绍这么多啦。
************字符串的整型运算*******************************1.一般来说字符串是不应该有运算的，但是由于Redis中没有整型这种类型，因此我们都并入了字符型的这一类中。
2.如果我们输入的字符串可以当做整型使用的时候，我们可以使用一些命令来对它们做运算，它们分别是：incr(加1)、decr(减1)incrby(加n)、decrby(减n)3.其中incr和decr的命令格式是：incr/decr键名4.而incrby和decrby的命令格式是：incrby/decrby键名增量5.我们可以看如下操作范例，我们可以对age进行加1，范例如下：6.当然我们还可以对age进行加6，我们操作如下：7.当然incrby还可以加一个负值，此时就相当于减少，我们操作如下：8.不过需要注意这是只能在字符串类型可以转化为整型的时候，否则会报错如下，我们先看一种情况：9.当然如果原来的数不是整数，也会报错，我们看到如下：10.虽然Redis中没有整型，但是由于整型用于计数、运算方面实在是过于普遍，因此Redis还是给予了支持。
******************指定有效期******************************1.这个命令非常符合Redis可以作为一个内存数据库的特色，因为我们存放在内存中的数据很多(不是全部)都会有这样的特点：短时间内多次使用，过一段时间后将不会再用。
2.我们可以使用setex来设置key对应的失效时间，当过了该时间后该键值对自动消失。
3.setex中的ex是expire的简写，该命令的格式如下：setex键缓存时间值4.这里需要注意的是其中的缓存时间是以秒为单位的。