redis——从零开始

第1节:
nosql入门
1.nosql
非关系型数据库的统称,它的几个特点:没有表、数据非结构化的、key-value格式进行存储、有自己的增删改查命令
2.nosql的产品有哪些?nosql产品的4大分类
redis,mongodb,hbase,memcache
3.使用场景
一般用在访问量比较大的场景中,用作缓存、消息系统等。
结构:网站架构以及nosql数据库在整个网站架构中所处的位置。
可以将一些实时的、高频的计算任务分配给nosql数据库,将计算结果在某个时间持久化到mysql中。
4.为什么nosql能够承载巨大的读写?
因为它是内存型数据库,即它的运行数据集都保存在内存中。我们之前的关系型数据库中的数据每次
读写都是一个IO操作,即需要从磁盘上读、然后写回磁盘。
5.从“web结构.png”可以看出,在实际应用中,nosql和关系型数据库是一个相互合作的关系,目前他们
之间谁也不可能取代谁。


第2节:
认识redis
1.redis有上述nosql的一些共性特点
2.redis特点
1)redis支持的数据类型还是比较丰富的,例如strings,lists,hash,set等数据类型。
2)redis还可以作为消息系统使用,提供了mq功能
3)redis每个实例都是单线程的
4)C语言编写,读写速度极高
5)支持主从复制、读写分离、集群
6)性能:这是redis赖以生存的看家本领,增加集群功能后当然不能对性能产生太大影响,所以redis采取了P2P而非Proxy方式、异步复制、客户端重定向等设计,而牺牲了部分的一致性。
7)可用性:在Cluster推出之前,可用性要靠Sentinel保证。有了集群之后也自动具有了Sentinel的监控和自动Failover能力。
8)水平扩展:集群的最重要能力当然是扩展,文档中称可以线性扩展到1000节点。
3.redis的运行模式
1)单机模式
在单机上运行一个redis实例,如果运行多个的话这些实例之间也没有任何关系。
2)主从模式
也称作是读写模式,也成为master-slave.
master负责写,slave负责读,slave不能进行写操作,它的数据全部来自于master。
哨兵模式,哨兵用来检测master是否可用,如果发现master不可用则会将slave设置成master,等原来的master恢复后自动变成slave.
只有一个master.
3)集群模式
无中新节点(去中心化)的很多redis实例,它的结构可以看做是多个master-slave的结合。
集群环境下,多个master,但是多个master各自有各自的槽,数据不同步.见图master-slave结构.png
4.在web应用中,读、写两种操作哪个更频繁?
读更频繁,例如逛淘宝买衣服,逛了3天看了N多件最后下的订单。
5.理解误区
不要以为master不是redis,master、slave都是redis实例,都是安装好的一个redis软件。


第3节:
redis的下载、安装
1.下载
cd /usr/local
wget http://download.redis.io/releases/redis-3.2.11.tar.gz
tar -zxvf redis-3.2.11.tar.gz
rm redis-3.2.11.tar.gz
2.源码安装
cd redis-3.2.11    进入源文件目录
make            下载c语言编译时必须依赖的gcc库等,然后对redis的源文件进行编译,该命令成功后会在redis-3.2.11/src下面生成一些*.o的文件和redis-server/redis-cli等命令
make install    自动将上一步编译好的文件安装到了/usr/local/bin目录下
备注:
1)一旦经过make install之后就可以删除之前的源程序目录redis3.2.11
2)/usr/local/bin目录已经默认在环境变量中了,所以此时可以在任何目录下运行redis-server等命令
3)以上安装是在root用户安装的,为安全起见,建议为redis创建独立的用户
3.安装巡视问题
有不少问题,对目录不清楚、相对路径不清楚、命令使用错误


第4节:
redis启动、关闭
1.非守护进程方式启动
1)在任意目录下运行以下命令:
redis-server
即可启动redis。
2)验证是否启动成功
客户端登录
redis-cli
127.0.0.1:6379>ping
PONG
如果返回PONG则说明服务端正常启动。
3)非守护进程方式运行存在的问题
一旦ctrl+c退出命令行或者关闭xshell,redis服务器也就关闭了,无法再ping
2.守护进程方式启动
1)redis-server &
即可启动守护进程,测试ping,无异常
2)修改并在启动的时候指定redis.conf配置文件
cd /usr/local/bin
cp /usr/local/redis-3.2.11/redis.conf /usr/local/bin/6379.conf
vim 6379.conf
修改daemonize的值为yes,然后保存。

3.注意
1)/usr/local/redis-3.2.11/redis.conf就是出厂设置文件。
2)如果在启动redis的时候,只运行redis-server命令,则会按照redis的出厂默认配置进行。
3)建议以redis-server xxx.conf格式的守护进程方式启动,会按照指定配置文件中的内容进行。
4.说说守护进程启动和非守护进程启动的区别?
守护进程保证了程序在后台一直运行。
5.关闭
1)kill命令
ps -ef | grep redis
kill -9 pid
2)登录客户端执行SHUTDOWN
redis-cli -p 6379
SHUTDOWN
备注:
a.SHUTDOWN命令有2个参数可供选择——SAVE|NOSAVE,默认SAVE会持久化redis中的数据到磁盘上
b.redis-cli -p 6379中的-p参数指定要登录的端口
6.卸载
源码方式安装:rm -f /usr/local/bin/redis-server等
yum方式安装:yum remove redis -y
7.常见错误
[root@iZ2ze9wnprrozvhc2eviueZ ~]# redis-server 6379.conf
10993:C 28 Feb 15:07:01.255 # Fatal error, can't open config file '6379.conf'
因为执行命令的目录没有在/usr/local/bin目录下,而6379.conf在/usr/local/bin目录下。
应该改为:
[root@iZ2ze9wnprrozvhc2eviueZ ~]# redis-server /usr/local/bin/6379.conf
备注:配置文件可放在任何一个目录
8.redis目录结构
redis-server        redis服务端
redis-cli            redis提供的客户端工具
redis-sentinel        搭建redis-sentinel(哨兵机制)集群,是redis实例的监控管理、通知和实例失效备援服务,是redis集群的管理工具。
redis-check-rdb        修复rdb持久化文件
redis-check-aof        修复aof持久化文件
redis-benchmark        redis性能测试工具
*.tcl                redis测试脚本
*.rb                依赖的ruby文件
tests目录            测试脚本存放的目录
utils目录            提供了一些工具
9.作业
1)按照上述方式,再布置一个redis实例,端口6380
2)启动6380端口上的redis,并通过客户端关闭它


第5节:
在window上安装redis并作为一个服务启动
1.下载
https://github.com/MicrosoftArchive/redis/releases
下载msi双机安装到e:\redis目录
备注:如果下载zip包解压后需要手动添加目录到path环境变量
2.注意事项
1)安装时将redis安装目录添加到PATH环境变量中,勾选
2)默认端口6379,可以更改
3)安装完毕后,redis默认作为windows的一个服务,在服务列表中可以看到它,自动启动
3.登录客户端测试
C:\Windows\System32>redis-cli.exe -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> set username admin
OK
127.0.0.1:6379> get username
"admin"
4.发现的几个问题
1)部分win7,win8机器需要重启才能读取path变量
5.win7/win8或者不能自动启动redis的同学将redis启动程序配置成windows的一个服务
http://blog.csdn.net/baidu_33465676/article/details/75530477


第6节:
redis常用的一些关于数据库(系统)操作的基础命令
redis-server /etc/6379.conf            根据指定的配置文件加载server    
redis-cli -p 6379                    登录6379端口的server    
redis-cli -p 6379 -a password        使用密码password登录6379端口的server
redis-cli -h 192.168.1.1 -p 6379    登录指定IP指定端口的server
redis-cli -c -p 6379                以集群的方式登录端口为6379的集群中的一个节点
redis-cli --raw -c -p 6379            以可以获取中文字符的方式登录                            
keys h*llo                            查询符合指定通配符格式的key有哪些
select 10                            redis中默认创建16个库,该命令可以将操作切换到索引为10的,即第11个库上                    
exists key                            判断指定的key是否存在,如果存在返回1,否则返回0
expire key 60                        设置某一个key的生命周期,即存活时间。例如expire name 5,则5秒name就不存在了
del key                                从库中删除指定key的元素,可以删除任何数据类型的值
move key 1                            将某个一key移到指定索引的库里面
config get keyname                    获取指定配置文件中的key的配置信息
config set key value                设置指定配置文件中的key的配置信息
dbsize                                获得当前库中key的个数,跟占用的内存空间没关系    
flushdb                                删除当前库中所有的内容
flushall                            删除所有库中所有的内容
info                                查看当前redis配置信息
save                                同步内存中的数据到磁盘上,相当于word中的ctrl+s
shutdown                            关闭server,注意:不是退出客户端
exit                                退出当前客户端
quit                                退出当前客户端
rename age nianling                    将key为age的重命名为nianling
type key                            获取key的存储类型
randomkey                            获得一个随机的key
lastsave                            获得最后一次同步磁盘的时间


第7节:
redis配置文件简介以及基础配置
1.通读redis.conf
该文件分为几大块,分别为:
INCLUDES、NETWORK、GENERAL、snapshottingTING、REPLICATION、SECURITY、LIMITS、CLUSTER、
APPEND ONLY MODE、SLOW LOG、LUA SCRIPTING、EVENT NOTIFICATION、ADVANCED CONFIG
每一块都是有自己配置内容。
注意:
在redis里面表示占用空间大小的方式有2种,一种单位为k,m,g,一种单位为kb,mb,gb。对应关系为:
1k => 1000 bytes
1kb => 1024 bytes
1m => 1000000 bytes
1mb => 1024*1024 bytes
1g => 1000000000 bytes
1gb => 1024*1024*1024 bytes
2.最基础(最小)的必配配置建议
port 6380                            配置server端运行的端口号
daemonize yes                        以守护进程方式运行redis,要求启动redis-server的时候必须指定配置文件            
pidfile /var/run/redis_6380.pid        指定pid文件的位置
logfile "/usr/local/redis/6380.log"    日志文件的位置
bind 127.0.0.1                        允许指定客户端IP访问server,如果注销那么任何IP都可以访问
dir /usr/local/redis                指定持久化文件存放的位置,默认./,如果选择默认值那么在哪个目录启动redis-server持久化文件就生成到那个目录
dbfilename 6380.rdb                    指定持久化文件的名称,默认名称dump.rdb。
appendfilename "6379.aof"    
备注:
1)这些项目强烈建议个性化设置,否则如果多个实例共存时可能会产生文件覆盖或找不到之前的rdb文件,给管理造成麻烦。
2)默认情况下持久化文件需要运行save或者重启server才会生成,否则看不到该文件。
3)如果没有目录需要手动创建目录,文件不需要手工创建。
4)部分机器需要去掉logfile中的双引号,否则启动redis时报找不到路径
3.作业
1)再配置一个redis实例,在不修改配置文件的情况下,查看是否有覆盖现象。
2)指定相应的conf文件启动,重启,查看之前的数据有没有覆盖、丢失。
3)在windows下再配置一个6380的实例并运行


第8节:
1.string类型
set name zhangsan    设置一个值
get name            获取指定的key值                
mset                批量设置key-value,例如:mset no 201611 address shandong remark goodstudent
mget                批量获取            
append                在后面追加
decr                减去1,例如decr age
incr                加1,例如incr age
decrby                decrby age 30
incrby                incrby age 3
getrange            getrange tel 0 3 包前也包后
setrange            替换指定位置的值
strlen                获取指定key的值的长度,注意:字节的长度
2.list类型
lpush        左进,如果没有队列会创建指定名称的队列,队列长度加1
rpush        右进,如果没有队列会创建指定名称的队列,队列长度加1
lpop        左弹出该元素的值,队列长度减1
rpop        右弹出该元素的值,队列长度减1
lrange        获取指定范围内的元素,例如:lrange studentname 0 -1,索引可以为负数(负数会取所有)
linsert        指定某个元素值前或者后插入某个元素值,例如:LINSERT mylist BEFORE "World" "There",如果列表存在多个重复的元素则从第一个元素前或后插入
lrem        移除,例如:lrem studentname 3 zhangsanfeng 从队列中移除3个zhangsanfeng,会从较小的索引开始移除
ltrim        剪切出指定范围内的内容,例如:ltrim studentname 1 3,得到的新studentname列表只含有索引为1和3之间的元素
lindex        获取某个索引上的值,例如:lindex studentname 2,得到第3个元素,会报索引越界异常
lset        设置队列里面一个元素的值
llen        获取列表长度
--------注意:
第一,lpush在第一次push数据的时候也是从左push,所以得到的结果跟命令行中的顺序相反
127.0.0.1:6379> LPUSH shandong jinan qingdao
(integer) 2
127.0.0.1:6379> LRANGE shandong 0 -1
1) "qingdao"
2) "jinan"
127.0.0.1:6379> lpush shandong dezhou
(integer) 3
127.0.0.1:6379> LRANGE shandong 0 -1
1) "dezhou"
2) "qingdao"
3) "jinan"
第二,两头均可操作
第三,建议对比着java中的ArrayList等学习,结构相似


第9节:
1.hash数据类型
健值对的存储类型
hset        设置指定字段的值,例如hset shujuyun 1611 15
hget        获取指定字段的值,例如hget shujuyun 1611
hdel        删除指定的key值,例如HDEL shujuyun 1611
hmset        批量设置指定字段的值,例如hmset shujuyun 1612 22 1609 23
hmget        批量获取指定字段的值,例如hmget shujuyun 1611 1609
hkeys        获取hash所有字段名称
hlen        获取元素总数量,例如hlen shujuyun
hgetall     获取所有key-value对,例如hgetall shujuyun
hincrby        将指定的字段值加某个数字,例如数据云学院1611班的学生数加2,HINCRBY shujuyun 1611 2
hdecrby        将指定的字段值减某个数字

2.set数据类型
元素各不重复,没有索引(无序)
sadd        添加一个或多个新元素,返回影响的行数。SADD studentno 1 2 3 4 5 5 6 返回6.如果集合中已经有了某个元素则返回0.
srem        删除集合中某个元素,例如srem food juzi
spop        从集合弹出一个或多个元素并返回被删除的值,spop food。注意:由于集合无序,没有左右之分,所以弹出的元素随机。
smove        移动food集合中的元素xiaomai到shiwu集合中,smove food shiwu xiaomai
sismember    确定某个值是否在集合中,如果有则返回1,如果没有返回0.例如:sismember food xiaomai
smembers    返回集合中所有的值
scard        获得集合里面元素数量
sinter        获取多个集合的交集
sunion        获取多个集合的并集,合并后消重
sdiff        获取多个集合的差集,例如sdiff A, SDIFF A B, SDIFF B A.
SRANDMEMBER    随机获取一个元素
备注:
1)该结构可以看做一个没有索引、没有重复值的"list",命令的使用上跟list相仿
2)key值可以看做变量名称,是key-value中key的部分,每种数据类型的value格式又各不相同,list是动态数组,有索引;hash的value部分是一组一组的键值对。

3.sorted set数据类型
每个元素都有一个float类型的score值,称为分数
zadd        增加元素,例如:zadd chengji 90 zhangsan 88 lisi 95 wangwu
zrem        删除指定元素,返回值是影响的个数,例如:zrem chengji zhangsan
zscore        获取成员的分数,例如zscore chengji lisi
zincrby        将指定的字段值加某个数字
zdecrby        将指定的字段值减某个数字
zcard        获取成员数量(长度)
zscan        迭代显示集合中的元素
zcount        分数满足区间min-max条件的总个数,包前包后
zrange        根据指定的index(索引)返回成员列表,根据分数从小到大排序。例如:zrange chengji 1 2 [withscores], zrang chengji 0 -1返回所有
zrevrang    跟zrange相反,根据分数从大到小排序
zrangbyscore获取指定分数区间min-max内的字段,包前包后,例如:ZRANGEBYSCORE chengji 60 90 limit 0 2 从0开始取,取2个
备注:
1)成员跟set一样必须是唯一的,分数可以重复。
2)成员有相应的索引,索引值大小按照分数从小到大排序,见zrange 
3)命令中[]中的参数代表可选
4)还可以使用limit关键字限制结果集个数,这里的limit跟mysql中的limit含义一样


第10节:
阶段总结和作业
1.安装
wget
tar -zxvf
make
make install
2.运行模式
1)单机模式
2)主从模式
3)集群模式
集群中的master之间要不要进行信息同步(共享)?
不。
3.使用场景
见web架构结构图
4.画出各个数据类型存储结构
见“数据类型存储结构.png”
5.写命令包括:
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。
6.作业
1)将关系型数据库中的一行数据内容描述成redis中的string结构进程保存
2)将关系型数据库中的一行数据内容描述成redis中的hash结构进程保存
3)选择合适的数据类型,描述一周内文章的搜索排名,并按从多到少排序输出
4)1609和1611两个班中相同姓名的有哪些?    
5)抽奖场景下,每抽出一个就在奖品池中删除该奖品,备注:要求奖品不能重复        
6)选择合适的数据类型,模拟关系型数据库中的between...and操作
7)将上述练习中set中的值移动到另外一个set中,写出命令
8)根据TestAPI.java写出jedis操作其他数据类型的程序,并登陆redis客户端查看是否写入


第11节:
redis的安全策略
1.安装的时候使用非root账号安装
在linux上为redis单独建一个用户,root,zhangsan,mysql....然后使用建好的这个用户登录linux,然后进行安装和启动。
好处就是一些需要root用户操作的权限进行了必要的限制。
2.为redis增加一个访问密码
第480行redis.conf中requirepass设置项中填写密码。
注意:这个密码没有任何加密方式,是以明文存储的,无法防止拥有足够的访问网络权限的攻击者进行窃听,因为redis并不支持数据加密。
redis官方特意有一句话:redis运算速度非常快,防止其他人暴力破解密码。
3.以防有人更改我们的conf文件中的设置
通过设置config命令防止其他人执行config set xxx yyy的命令。
1)禁用config
495行rename-command CONFIG ""将config设置为""即可禁用。
2)将 config这个命令命名成一个很复杂的字符串
rename-command CONFIG "b840fc02d524045429941cc15f59e41cb7be6c52"
4.防火墙
推荐redis实例在局域网内访问,即程序和redis实例运行在同一个局域网。一般情况下一台直接暴露在Internet的计算机,防火墙应该防止外部用户访问它的redis端口,用户仍可以通过本地接口来访问redis。
不禁止外部访问redis的话,将会产生非常严重的后果。比如,一个FLUSHALL操作就可以当做外部攻击来删除redis上的所有数据。
5.加IP黑名单或者白名单
1)操作系统层面,设置白名单,只允许符合条件的IP访问,例如:ECS上有设置白名单的选项。
2)在redis层面,设置redis.conf中的bind选项,例如:bind 127.0.0.1
a.bind后面绑定的是允许访问的ip地址,如果有多个则IP之间用空格隔开
b.如果允许任何IP访问则将bind选项注销
6.做一些SSL安全访问代理
7.为redis实例增加日志记录
1)指定日志记录级别
# redis总共支持四个级别:debug、verbose、notice、warning,默认为verbose
# debug    记录很多信息,用于开发和测试
# varbose    有用的信息,不像debug会记录那么多
# notice    普通的verbose,常用于生产环境
# warning    只有非常重要或者严重的信息会记录到日志
loglevel debug
2)配置log文件地址
# 默认值为stdout,标准输出,若后台模式会输出到/dev/null
#logfile stdout
logfile /var/log/redis/redis.log
作业:
启动windows上的redis实例,各个同学之间测试5-2中的bind策略.
注意:如果在cmd中运行redis-server等命令时默认读取的是环境变量中指定的path路径中的redis。如果要运行某个
redis实例则可进入相应的目录双击redis-server.


第12节:
配置redis成为一个缓存,如果redis当做一个缓存来用,所有的key都有过期时间
1.配置缓存
1)设定最大内存使用量
maxmemory 2mb
2)设定过期策略
#maxmemory-policy allkeys-lru 该设置并不需要我们的应用使用EXPIRE(或相似的命令)命令去设置每个key的过期时间,因为只要内存使用量到达2M,redis就会使用类LRU算法自动删除某些key。
#maxmemory-policy allkeys-random:随机移除任何key。
#maxmemory-policy volatile-lru:利用LRU算法移除设置过过期时间的key。
#maxmemory-policy volatile-random:随机移除设置过过期时间的key。
#maxmemory-policy volatile-ttl:移除即将过期的key,根据最近过期时间来删除(辅以TTL)
#maxmemory-policy noeviction:不移除任何key,只是返回一个写错误,让用户对缓存内容进行处理,用户根据需要删除自己想删除的内容。
备注:
a.最大内存达到后redis将不再接收写请求,只接收get请求。
b.lru,即最近最少使用
c.ttl,即Time to Live,意思就是生存时间
d.至于选择哪个策略,一切根据需求来
2.缓存的应用举例
1.见图“tomcat集群下session共享.png”
2.按图所示,两次产生的session值不一样,将会产生什么问题?
会让用户一直登陆,无法使用系统。需要“单点登录”配置。
session!=null(错误)
session.getAtitute("username")!=null(正确)
3.问题2的解决方案?
使用redis缓存web集群环境下的session值,如下几步:
1)首先,启动一个redis实例作为缓存
启动6379端口的redis,强烈建议用一台单独的redis作为缓存。
2)配置tomcat/conf/context.xml
a.如果是单点redis则配置代码如下:
<Valve className="com.orangefunction.tomcat.redissessions.redisSessionHandlerValve" />    
<Manager className="com.orangefunction.tomcat.redissessions.redisSessionManager" 
host="127.0.0.1" 
port="6379" 
database="0" 
password="aaaa"
maxInactiveInterval="60" />
b.如果是sentinel-redis集群则配置代码如下:
<Valve className="com.orangefunction.tomcat.redissessions.redisSessionHandlerValve" />    
<Manager className="com.orangefunction.tomcat.redissessions.redisSessionManager" 
maxInactiveInterval="60"
sentinelMaster="mymaster"
sentinels="127.0.0.1:26379,127.0.0.1:26380,127.0.0.1:26381,127.0.0.1:26382" />
备注:maxInactiveInterval含义为最大不活动时间,应该是每接受一次请求就重新起算,单位秒
3)在tomcat/lib中导入一下jar包
tomcat-juli-adapters.jar
tomcat-redis-session-manager1.2.jar
jedis-2.6.2.jar
tomcat-juli.jar
commons-pool2-2.4.1.jar
4)共享原理
tomcat在启动的时候,每一个tomcat实例连接redis,当有用户访问的时候再写入session信息,其他tomcat实例根据指定的配置文件从redis实例中读取该session。
4.演示
配置好context.xml后,重启tomcat,访问页面验证每次打印的sessionid是否一致。
5.注意
1)即使是context.xml总配置maxInactiveInterval默认60秒,只要web.xml中的sessionConfig默认配置30分钟,则session的失效时间还是30分钟。
2)tomcat仍然为每一个访问的用户创建他的session.
3)只是连上了服务器但是没有输入用户名密码登录的情况下session创建了吗?YES
4)关闭浏览器后原来的session消失了吗?NO
5)所有的tomcat实例的context.xml配置必须都相同的,只有相同才能保证所有的tomcat实例访问的是同一个sessions。
6)如果redis访问需要密码,需要在context.xml中配置password属性指定密码。
7)session是基于cookie的,在以后的访问请求中会包含该sessionid,其他的tomcat就是根据包含的这个id到redis中查看它是否存在,如果存在则不创建新session否则就创建并写入新session.


第13节:
redis的持久化和rdb持久化
1.什么是持久化?
将内存中的数据写入到磁盘。在mq课程接触了持久化。
2.redis在什么情况下执行持久化操作?
1)符合配置规则
2)执行了save,shutdown,shutdown save,restart,flushdb,flushall,kill命令后
3.rdb持久化方式
1)rdb持久化方式是redis的默认持久化方式,即redis生成一个后缀名为.rdb的文件,配置规则见SNAPSHOTTING模块。
2)配置rdb持久化频率
配置规则:save <seconds> <changes>
即每隔一段时间redis服务器程序会自动对数据库做一次遍历,把内存快照写在一个叫做“dump.rdb”的文件里,这个持久化机制叫做snapshotting。
有了snapshotting后,如果服务器宕机,重新启动redis服务器程序时redis会自动加载dump.rdb,将数据库状态恢复到上一次做snapshotting时的状态。
可以在redis的conf文件里指定持久化频率,以下满足其中一个就行:
save 900 1
save 300 10
save 60 10000
# 900秒(15分钟)内至少1个key值改变(则进行数据库保存--持久化) 
# 300秒(5分钟)内至少10个key值改变(则进行数据库保存--持久化) 
# 60秒(1分钟)内至少10000个key值改变(则进行数据库保存--持久化)
3)配置rdb持久化文件存放路径
dbfilename 6379.rdb                生成的rdb文件的名称,建议必须配置
dir /usr/local/bin                生成的rdb文件的路径,建议必须配置
如果没有配置上述项目,持久化文件dump.rdb会位于redis的启动目录,即在哪个目录下运行的redis-server就在哪个目录下生成持久化文件。
另外,如果没有配置上述项目,多个redis实例共存的情况下会覆盖前一个的数据。
4)其他配置
stop-writes-on-bgsave-error yes    持久化过程中发生错误时是否停止操作,默认值
rdbcompression yes                是否启用压缩,默认
rdbchecksum yes                    检测rdb文件,默认,在恢复数据的时候要不要进行合法性检测
5)rdb持久化的特点
每一次持久化的时候把所有数据写到硬盘上,数据量如果大的话,花费的时间会很长。
在实际应用中根据业务类型选择时间和操作,相应的去提高或者降低持久化的门槛。
例如:会员充值(增加持久化频率)、点赞浏览量统计(适当减少持久化频率)。
6)禁用
放开save ""并且注销所有save行。如果放开了save ""但是没有注销save 900 1仍然会进行持久化。
7)从什么时候开始计时?
从上一次持久化成功的时间开始计算。


第14节:
AOF持久化方式
1.什么是aof
见APPEND ONLY MODE模块,aof即是Append Only File的缩写,意思是对操作进行追加,换句话说就是记录用户的所有写操作。
例如set,sadd,flushdb...都记录。time,get....这些操作不记录。只要发生写操作,它就按照规则在aof文件中进行追加,注意:是追加不是修改。
注意:并不是立马记录,得看配置规则。
2.配置aof持久化
appendonly no                    默认redis关闭了aof操作,如果打开则将值设置为yes
appendfilename "appendonly.aof"    持久化aof文件的名称,aof文件的路径见rdb配置中的dir值。
3.配置aof持久化策略
# appendfsync always            只要发生写操作就进行持久化,特点是速度慢,但是最安全
appendfsync everysec            每秒钟进行一次持久化操作,默认策略,特点是比较兼顾安全和速度,redis推荐使用。如果数据丢失的话,最多丢失1秒钟的数据。
# appendfsync no                将持久化的操作交给操作系统处理。
4.其他配置
no-appendfsync-on-rewrite no    在持久化过程中产生的新操作要不要写入,yes不写,no写。默认是no一般推荐yes.
auto-aof-rewrite-percentage 100    当文件增加的体积是原来体积的百分之多少的时候进行rewrite
auto-aof-rewrite-min-size 64mb    当文件满足最小体积是多少的时候,才进行rewrite操作
aof-load-truncated yes            在恢复数据的时候要不要进行合法性检测,如果出错就不加载。
3.如何在rdb和aof之间切换?
首先,他们是可以同时使用的,也可以单独使用。
rdb-->aof
4.rdb和aof文件修复工具
redis-check-rdb /usr/local/bin/6379.rdb
redis-check-aof /usr/local/bin/6379.aof
修复一些语法错误,例如删除一些错误的内容。
5.禁用持久化
rdb默认开启,save ""或者注销掉save 900 1, save 300 100等配置信息,注意save "" save 900 1, save 300 100都存在的话仍会进行持久化。
aof默认关闭,appendonly no即可禁用。
6.问答
1)如何验证持久化是否成功?
2)如何解决不同redis实例之间持久化文件命名的冲突?
3)按照默认配置,假定只有一个客户端操作,在执行了set name zhangsan之后停止操作,多长时间后会生成rdb文件?15分钟后。
4)如果禁用持久化后,执行save命令还会生成持久化文件吗?会
5)为什么always慢?因为底层本质是IO,这会增加IO开启、关闭的时间。
6)某一个实例开启了rdb和aof持久化,给它set一个key-value,然后立即kill -9掉该实例(间隔时间不超过1秒),问会不会持久化成功?会


第15节:
redis的事务
1.事务最基本的特点?
事务是一个不可分割的操作,意思就是在执行这一连串动作的时候,中间不会被其他线程(客户端)执行的程序打断。
这个特点在关系型数据库是通用的。注意:redis是单线程运行的,所有的指令均是单线程逐个被执行。
2.redis事务所涉及到的几个命令
1)加锁的命令
watch:用在multi命令之前,对任何key都可以加锁,语法watch key1 key2 key3这样就可以对key1,key2,key3进行加锁保护,在watch执行之后, exec执行之前, 其他终端客户(或自己)修改了key的值, 那么当前客户端的事务就会失败,返回nil。
unwatch:释放锁,它后面不带key参数,会释放之前所有watch的key,任何时候都返回OK,它能保证下一个事务的执行不会受到影响。.
2)开启事务、中断事务、执行事务
multi:开启一个事务,当客户端发出了multi命令时,客户端和服务端的连接就进入了一个事务上下文的状态。multi执行之后, 客户端可以继续向服务器发送任意多条命令, 这些命令不会立即被执行, 而是被放到一个队列中, 当exec命令被调用时, 所有队列中的命令才会被执行。在multi之后输入相应的其他操作,例如decrby,incr,set,sadd....这些操作。
discard:放弃事务的执行,用在exec之前,例如发现前面的某个命令输入错误了,可运行该命令放弃事务。这是再执行exec就会报错。
exec:执行事务,当exec运行的时候,在multi之后的QUEUED中的命令会被执行,可以理解成connection.commit()
3)演示
账号里面有100元,买东西,单价20元
4)如何表达一个事务执行的过程?
[watch keys] multi....exec,其中watch是可选的,根据实际需求决定是否要watch.
3.事务的三个场景
1)加锁的变量在未执行exec之前被第三方程序(客户端)更改了值,导致整个事务返回nil
127.0.0.1:6379> WATCH money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> set test test
QUEUED
127.0.0.1:6379> EXEC
(nil)

2)事务中的命令无法通过解释,导致整个事务报错
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> sets remark zheshihaoshangpin
(error) ERR unknown command 'sets'
127.0.0.1:6379> set time 20180307
QUEUED
127.0.0.1:6379> set no 1234234234
QUEUED
127.0.0.1:6379> EXEC
(error) EXECABORT Transaction discarded because of previous errors.

3)事务中的命令运行时报错误,导致事务部分执行成功
27.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> DECRBY name 20
QUEUED
127.0.0.1:6379> set sex nv
QUEUED
127.0.0.1:6379> EXEC
1) (integer) 40
2) (error) ERR value is not an integer or out of range
3) OK
4.事务总结
1)redis里面的事务是弱事务,即它可以部分执行成功。
2)当执行exec或者discard或者unwatch的时候该命令后watch自动失效,即exec/discard/unwatch命令会取消对所有key的监控。
3)事务中的每个命令的执行结果都是最后一起返回的,所以无法将前一条命令的结果作为下一条命令的参数


第16节:
1.使用jedis操作redis事务
//如果不写host则默认为localhost
//如果不写端口则默认为6379
Jedis jedis = new Jedis();
jedis.set("money", "100");
//假如需求中需要对money加锁的话则加锁
jedis.watch("money");
//开启事务
Transaction transaction = jedis.multi();
//停止5秒
try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
//开始往事务队列中添加命令(操作)
transaction.decrBy("money", 20);
transaction.set("name", "zhangsanfeng");
transaction.set("age", "20");
//执行事务
List<Object> exec = transaction.exec();
//打印执行结果
System.out.println(exec);
2.作业
手动输入金额,用来购买单价为20的商品。如果输入金额大于20则对金额加锁并在事务中完成购买操作。如果输入的金额
小于20则取消锁并返回提醒信息。
3.注意
在事务multi....exec中间的代码块中,不能调用jedis的任何方法,例如jedis.get(key)等。
否则报Cannot use Jedis when in Multi的异常,即在事务中不能调用jedis对象,只能使用transaction操作。


第17节:
redis的主从复制/读写分离
1.什么是主从复制/读写分离?
将读和写操作进行划分,让读(查询/统计)、写(增/删/改)在不同的服务器上。
2.读写分离的使用场景
1)第一,减轻主数据库的压力,在高并发情况下,为了提高网站的“可用性”,进行读写分离。
2)第二,避免redis单点故障,用作数据备份。
备注:一般情况读操作要远远大于写操作,所以一般配置服务器的时候读服务器的数量大于写操作。
3.环境准备
6380(master)
6381(slave)
6382(slave)
并且修改各自的最小配置文件。
4.使用redis命令配置读写分离
6381>slaveof 127.0.0.1 6380
6381>info replication
运行上述命令查看主从复制信息如下:
# Replication
role:slave
master_host:127.0.0.1
master_port:6380
1)然后到6380里面set一个值,验证6381中是否存在该值。
2)在6381中set一个值,看是否成功
127.0.0.1:6381> set age 18
(error) READONLY You can't write against a read only slave.
所以,在默认情况下,从服务器不能进行写操作,例如set,sadd,flushdb,flushall....凡是改变数据库状态的命令都是写操作。
5.修改从slave的conf文件配置读写分离
1)必须配置
slaveof 127.0.0.1 6380
  
            
2)其他配置
slave-serve-stale-data yes    当从库同主机失去连接或者复制正在进行,从机库有两种运行方式:1) 如果slave-serve-stale-data设置为yes(默认设置),从库会继续响应客户端的请求。2) 如果slave-serve-stale-data设置为no,除去INFO和SLAVOF命令之外的任何请求都会返回一个错误
slave-read-only yes            作为从服务器,默认情况下是只读的(yes),可以修改成NO,用于写(不建议)。
repl-timeout 60                复制连接超时时间。master和slave都有超时时间的设置。master检测到slave上次发送的时间超过repl-timeout,即认为slave离线,清除该slave信息。slave检测到上次和master交互的时间超过repl-timeout,则认为master离线
slave-priority 100            当master不可用,Sentinel会根据slave的优先级选举一个master。最低的优先级的slave,当选master。而配置成0,永远不会被选举。
min-slaves-to-write 3        只有当3个或3个以上的从数据库连接到主库时,主数据库才是可写的,否则返回错误。
min-slave2-max-lag 10        允许从数据库失去连接的最长时间,该选项默认是关闭的,在分布式系统中,打开并合理配置该选项可以降低主从架构因为网络分区导致的数据不一致问题。
5.更换master
slaveof newhost newport命令或修改slave的配置文件
6.解除主从关系
slaveof no one命令或修改slave的配置文件
7.验证试验
刚才的实验
8.主从复制的架构
1)一主多从
6380(master)-6381(slave)
            -6382(slave)
2)级联结构
6380(master)-6381(slave)-6382(slave)
9.异步复制
在master中set一个值,其执行结果会立即返回给客户,并不会等待主从复制完成以后再返回给客户。
所以说,这个过程是异步的。异步复制带来的问题?带来的最大问题就是不能保证数据100%复制成功,如果是同步的话则可以保证,在同步操作时如果复制失败可以返回一个
错误,用户再从新set。
10.总结
1)主从配置不需要修改master的conf文件。
2)使用slaveof 127.0.0.1 6380,slave no one等命令配置的主从关系,如果服务器重启后主从配置将会失效,继续按照conf文件中的配置规则工作。
3)主从复制能够保证主机和从机的数据是基本同步的(不是绝对的实时同步,因为主从复制是异步复制),这个跟主从架构的结构没有关系。
4)会使用slaveof/slaveof no one/info replication命令。
5)无论哪种主从架构,其中的数据在各个redis实例中最终都是一致的。
6)默认情况从机不能进行写操作,例如set,flushdb,flushall等,也可以通过修改slave-read-only no设置成可写。
7)为什么从库不建议写?因为从库中数据的改变不会被同步到master中,并且一旦master修改了数据,从库的数据就会因为自动同步被覆盖,所以一般情况下不建议将从库设置为可写。


第18节:
redis主从复制中的哨兵机制
1.上述配置存在的问题
如果master宕机则不能及时处理,影响整体的“可用性”。
2.解决方案
1)手动解决
2)引入一个机制,这个机制至少做2件事,即自动检测障碍、自动切换slave成master。
3.哨兵机制
redis-sentinel,哨兵机制是主从复制架构的容错机制。
1)如何配置哨兵
# cp /usr/local/redis-3.2.11/sentinel.conf /etc/redis/sentinel26379.conf
# cp /usr/local/redis-3.2.11/sentinel.conf /etc/redis/sentinel26380.conf
# vi sentinel26379.conf
port 26379
sentinel monitor mymaster 127.0.0.1 6380 2
sentinel auth-pass mymaster myredis1611
备注:
第一,哨兵只检测master;
第二,后面的2代表如果至少有2个哨兵同时发现master宕机才执行切换恢复(failover)策略
第三,myredis1611为master密码
第四,mymaster是自己给主机取的名字,可以包含字母数字等
2)如何启动哨兵
[root@sdfsdf~]#redis-sentinel /usr/local/bin/sentinel26379.conf &
[root@sdfsdf~]#redis-sentinel /usr/local/bin/sentinel26380.conf &
备注:&保证了服务能在后台运行,关闭xshell不会退出程序。
4.验证哨兵的有效性
1)首先配置6380为master,配置6381/6382为slave.
2)使用info replication记录下主从关系
3)然后kill掉6380
4)再次使用info replication记录下主从关系
5)再次恢复之前的master
6)再次使用info replication记录下主从关系
7)发现之前的master成为了slave.
备注:在整个过程中,sentinel修改了6380.conf, 6381.conf,6382.conf,sentinel26379.conf,sentilnel26380.conf
5.如何从众多的slave选择一个slave?
见配置文件redis.conf中的slave-priority 100配置项
1)如果值设置为0则永远不会被选择
2)值小的优先被选择
6.小结
1)检测、恢复、检测和恢复的策略
2)主从复制不会影响m/s的持久化
3)不能互为主从,一台主库可以拥有多个从库,但是一个从库只能隶属于一个主库。
4)如果slave的权重相同则哨兵会随机选择一个作为master
5)如果所有的slave和master都有密码切密码不同,sentinel.conf如何配置?


第19节:
1.通过jedis操作主从复制
//主机
Jedis m=new Jedis("127.0.0.1",6379);
//从机
Jedis s=new Jedis("127.0.0.1",6380);
//设置
s.slaveof("127.0.0.1",6379);
//验证
m.set("name", "admin");
//slave取值
String string = s.get("name");
System.out.println(string);
备注:
1)在windows下操作需要重新复制一份rediscopy
2)运行redis-server redis.windows.conf启动rediscopy中的redis
3)运行上述程序,可能存在异步复制的时间差,再执行一次程序即可
2.作业
1)使用springmvc的方式操作redis
http://localhost:8080/springmvc/fuxiyi/redistest.jsp
2)开启5个线程模拟商品秒杀,假定商品库存始终足够,秒杀时间设定为一分钟,商品
由key和value的形式存储在redis中。
要求:
一,超时后无法再购买
二,统计每个线程购买商品的个数
3)在linux上准备6个redis实例,并把配置文件最小配置修改好,备用


第20节:
安装ruby环境
1.ruby简介
1)ruby,gem,rails.
2)为什么用ruby?因为redis提供了一个命令redis-trib.rb
3)安装方式:源码,yum,rpm(zip),rvm
2.ruby的yum安装
[root@iZ2ze9wnprrozvhc2eviueZ~]# yum install centos-release-scl-rh    会在/etc/yum.repos.d/目录下多出一个CentOS-SCLo-scl-rh.repo源
[root@iZ2ze9wnprrozvhc2eviueZ~]# yum install rh-ruby23  -y            直接yum安装即可  
[root@iZ2ze9wnprrozvhc2eviueZ~]# scl enable rh-ruby23 bash            必要一步
[root@iZ2ze9wnprrozvhc2eviueZ~]# ruby -v                            查看ruby是否安装成功,如果结果为版本号则成功
[root@iZ2ze9wnprrozvhc2eviueZ~]# gem install redis                    安装gem
3.设置环境变量
[root@iZ2ze9wnprrozvhc2eviueZ~]# export                                查看环境变量
export的命令作用是打印出当前系统的环境变量内容。将打印出的环境变量内容添加到系统的环境
变量配置文件/etc/profile文件中,下次重启后在任何目录均可执行ruby命令,否则下次重启
客户端后找不到ruby命令。例如:
declare -x HISTCONTROL="ignoredups"
declare -x HOME="/root"
.....
.....
export PATH=/bin:/usr/bin:$PATH #最后加上这一行


第21节:
使用redis-trib.rb命令创建redis集群
1.redis-trib.rb命令的使用
为了使用方便,我们将该命令放到/usr/local/bin中。
cp /usr/local/redis-3.2.11/src/redis-trib.rb /usr/local/bin
拷贝过去备用。
2.环境准备
6383.....6388共6个redis实例,并修改配置文件为最小配置。
3.创建集群
1)修改redis.conf配置文件使得redis支持集群
cluster-enabled yes
cluster-config-file nodes-6383.conf
cluster-node-timeout 5000
2)集群的创建
a.首先启动6个redis实例
备注:
在启动redis实例的时候,nodes-port.conf文件就在启动目录被创建了。
运行ps -ef |grep redis的时候会发现配置了集群支持的实例后面都跟着一个[cluster]
b.执行运行redis-trib.rb命令创建集群
redis-trib.rb create --replicas 1 127.0.0.1:6383 127.0.0.1:6384 127.0.0.1:6385 127.0.0.1:6386 127.0.0.1:6387 127.0.0.1:6388
备注:
redis分配了一些master和一些slave,并且做了一对一的配对
每一个redis实例,包括master/slave都有一个唯一的id号
标明了每一个slave的master是谁,并且slave将会从属于它的master哪里复制信息,换句话说说,集群中包含着很多主从复制架构。
每一个master都分了若干个slots(槽/分片),每一个slave没有分slots.即只有master分配了槽。
众多的master在分槽的时候,按照一个相对均衡的策略进行分配,即这就是redis集群的负载均衡策略。
一个集群总共有16384个槽,即一个集群最多有16384个master。
4.常见错误
1)最小配置没有准备好
2)在主从复制的配置6380,6381....的基础改的集群配置
报错:slaveof...不能运行在cluster...环境下,即必须注销slaveof。
也就是说同一个redis实例要么单机运行、要么在主从复制中运行、要么在集群中运行。
不能即在主从中运行又在集群中运行。
3)执行redis-trib.rb的时候提示Permiission denies即没有执行权限,先修改该文件的权限。
4)redis实例中有密码导致redis-trib.rb执行时报Can't connect 127.0.0.1:6385,解决方案有:
a.先将集群创建成功后再用config set requirepass XXX添加密码,添加的时候所有实例的密码必须相同。
b.修改redis-trib.rb的源代码,将密码付给该程序
5)redis-server /usr/local/bin/6384.conf不报错
ps -ef | grep redis却看不到6384.
6)粗心
7)版本3.2.11版本,要求ruby版本大于2.2
8)不能开启maxmemory配置
5.作业
登录redis-cli -p 6383 -c登录,然后在集群中set/get值。


第22节:
redis集群的特性分析
1.上节作业
127.0.0.1:6388> set name liubei
-> Redirected to slot [5798] located at 127.0.0.1:6384
OK
127.0.0.1:6384> keys *
1) "name"
127.0.0.1:6384> get name
"liubei"
127.0.0.1:6384> set age 18
-> Redirected to slot [741] located at 127.0.0.1:6383
OK
127.0.0.1:6383> set no 124234243
-> Redirected to slot [13676] located at 127.0.0.1:6385
OK
127.0.0.1:6385> get name
-> Redirected to slot [5798] located at 127.0.0.1:6384
"liubei"
2.节点通信
1)从任何一个节点,不管是master还是slave均可登录集群;
2)任何一个节点的配置文件nodes-port.conf文件中除了自身信息以外还有其他节点的信息;
3)集群的节点包含master和slave等节点(也包含宕机的节点);
4)在任意一个节点均可运行get/set等命令,但是在Redirected的时候不可能定位到slave上面;
5)集群中的任意节点都是彼此互联的,每一个节点的状态其他节点都能感知;
6)在集群的slave节点可以执行set/sadd/del等命令;
7)master节点的中数据彼此之间不会进行同步;
8)master和自己的slave数据会做同步,同步规则遵循“主从复制”架构;
9)整个集群架构是“分布式集群”。
3.最低要求
1)如果master有从节点,则master宕机的数据不能大于一半;
2)如果master没有从节点,则宕掉任何一个节点就会因为缺少槽导致集群不可用;
备注:宕机后立即运行cluster info可能状态还没更改过来。
4.负载均衡
16384个槽基本均衡的分布到了所有的master上,这样访问的时候就保证了负载均衡。
5.主从复制
1)主从复制只发生在master和隶属它的slave之间,master和master之间、master和非隶属它的slave之间不存在主从复制。
2)在从节点可以执行set等命令
6.容错机制
1)容错机制分宕机检测和主从切换两个操作。
2)宕机检测,集群内超过一半master节点检测到某一个master节点宕机,该节点才算宕机
3)主从切换,集群内部从宕机的master隶属的slave节点中选择一个切换成master
4)集群的容错机制不依赖于哨兵,这是跟主从架构的一个重要区别
7.事务支持
在集群中,是不支持事务的,因为各个命令可能跨不同的节点,命令在各个节点已经执行,不会再放到Queued。
8.集群效率
由于集群在set/get的时候需要redirect寻找相应的槽,因此它的运行效率没有单机高。
我们搭建集群的目的是为了提高整个系统的“可用性”。另外,通过负载均衡也相应的
提高了访问的效果。
9.集群命令
cluster info
cluster myid
cluster nodes
cluster meet
cluster foget
10.总结性的作业
把redis单机、主从、集群3个运行模式,从效率、容错、事务等3个方面进行对比,列出表格。


第23节:
1.昨天作业
2.使用jedis操作redis集群
见TestCluster.java,部分代码如下:
JedisPoolConfig config=new JedisPoolConfig();
//设置最大链接的数量,并不是一开始就创建50个
config.setMaxTotal(50);
//设置最大的不活动的连接的数量,一旦达到该值就不再创建新连接
config.setMaxIdle(10);
//设置最小的不活动的连接的数量,一旦达到该值就立即创建新连接,直到达到50个为止,维持连接池的动态平衡
config.setMinIdle(5);
//在从连接池中取连接的时候是否检查取到的连接是否可用,建议设置true
config.setTestOnBorrow(true);


第24节:
使用spring集成redis的访问
1.操作单机/主从
见spring.xml和TestSpring.java
2.操作集群
见springcluster.xml和TestSpringCluster.java
3.主要学习如何注入,不要死记硬背属性名称
4.注意
1)以上java程序是使用getBean()方法手动从ApplicationContext对象中获取对象的。
如果要使用注解注入的方式获取对象,需要在配置文件中增加如下代码:
<!-- 采用注释的方式配置bean -->
<context:annotation-config />
<!-- 配置要扫描的包 -->
<context:component-scan base-package="cn.buba.redis.spring" />
<!-- proxy-target-class默认"false",更改为"ture"使用CGLib动态代理 -->
<aop:aspectj-autoproxy proxy-target-class="true" />
2)在操作集群的时候无需声明ShardedJedisPool,JedisCluster自己会根据JedisPoolConfig创建连接池。
5.作业
将上述程序改成注解注入获取对象的方式


第25节:
高级理论部分—acid和cap
ACID是整个关系型数据的理论基础,如果这4个方面其中有一个做不到,那么该产品
也无法使用。
1.ACID理论
A原子性:该操作(或者是批量的操作)不可分割,要么全部执行,要么全部回滚
C一致性:无论由多少个线程(客户端)操作数据库得到的结果跟1个线程(客户端)操作的结果必须是相同的
I隔离性:事务跟事务之间互不影响
D持久性:指的是事务必须支持提交(持久化)一旦commit()则不会再修改,即commit()执行完毕代表着一个事务的结束

2.CAP理论
nosql产品的理论基石,nosql产品的需要从下面3个方面考虑,但是下面这3个方面又不能同时满足,最多只能满足其中2个
C一致性:牺牲部分的一致性,若事务,强一致性即要求某一个节点修改了数据另外一个节点立马看到
A可用性:必须保留,因为可用性直接影响了系统的健壮和用户体验
P分区容错:一旦一个分区发送故障或者需要增加新的分区的时候,能够很好的进行水平扩展
备注:这里的分区不是指的槽,而是指的是“单例”
区块链:去中心化的分布式数据库,去中心化就是没有中心,只有没有中心节点的架构才能很方便进行水平扩展。


第26节:
常见错误/术语中英文对照/结课作业
1.常见错误
1)同名key的覆盖问题,同一个redis实例的同一个库中的key值是唯一的。例如:key为user的string类型的数据覆盖掉key为user的hash,set等数据
2)命令使用错误,例如忘记带-p等
3)命令不区分大小写,例如:shutdown和SHUTDOWN相同
4)健值区分大小写,例如:get NAME 和get name不同
5)修改conf配置文件后需要重启redis才能生效,如果使用config命令修改则不需要重启
6)set name zhang san feng报错,值中间不能有空格,如果要加空格则将值用""包裹,例如set name "zhang san feng"
7)登录集群和登录单机的是有区别的,如果要操作集群必须加-c参数,否则get/set失败(error) MOVED 5798 127.0.0.1:7001
2.中英对照
复制(replication)
持久化(persistence)
最近最少使用(lru算法)
集群(cluster)
主机(master) 
从机(slave)
节点(nodes)
槽(slots)
哨兵机制(sentinel)
转向(redirect)
故障转移(failover)
3.结课作业:
1)画出redis的思维导图
数据类型、运行模式去划分
2)搭建springmvc+redis环境,完成基于redis的增加和查询,查询结果分页显示。


附件:
认识阿里云
1.ECS:服务器(linux,windows)
1)分地区
2)各个地区之间的内网不互联
3)如果选择国外的服务器则不用备案
4)可以初始化硬盘,可以更换操作系统,一旦换了之后之前的数据丢失
5)安全规则
2.RDS:关系型数据库
1)购买地区要和ECS在同一个地区
2)创建数据库
3)备份设置,例如每天备份一次、3天备份一次,不是实时备份
4)一旦购买了就不需要在本地ECS安装mysql了
3.其他:
Redis,OSS
4.域名和网站
1)购买,.com一年50,.xin一年8块,域名不区分大小写
2)域名的解析
第一,指定解析名称,例如abc,www,blog,test
第二,指定解析的值,即IP地址,例如47.95.255.233
备案
1)备案服务号申请,例如c9e1e12d-7e64-44fd-99c3-6486d213b26a
2)拿着申请到的备案申请号,到备案系统进行申请,傻瓜式操作
3)打印一个备案申请单,纸质,阿里背景的照片,20天左右

展开阅读全文

没有更多推荐了,返回首页