redis查看某一个key的大小

一、Redis基础

1、简介

remote dictionary server 远程字典服务

C语言编写，基于内存，可持久化的日志型key value数据库。

他会周期性将更新的数据写入磁盘或把修改操作追加到记录文件，且在此基础上实现了主从同步。

2、redis能干嘛

内存存储，持久化，内存中是断电及失，所以持久化很重要(rdb/aof)
效率高，用于高速缓存
发布订阅系统
地图信息分析

3、redis特性

持久化
多样数据类型
集群
事务

4、linux安装

1、下载压缩包

wget url

2、复制压缩包到opt目录下

mv reids-6.0.7.tar.gz /opt

3、切换到/opt下并解压redis

cd /opttar -zxvf reids-6.0.7.tar.gz

4、c环境安装

yum install gcc-c++#查看本版，版本过低后续安装会报错gcc -v

5、安装redis

cd /opt/reids-6.0.7#gcc版本过低make会失败make#确认是否安装成功make install

6、拷贝redis.conf文件到redis安装路径下

# /usr/local/bin为redis默认安装路径，make成功后该路径下会有reids的客户端cd /usr/local/bin#创建目录存放conf文件mkdir rconfig#复制conf文件到rconfig目录cp /opt/redis-6.0.7/redis.conf rconfig

7、修改conf文件

vim rconf/redis.conf#deamonize no 改为 yes#bind 127.0.0.1 改为 0.0.0.0

8、启动redis

cd /usr/local/bin#开启redis服务reids-server rconfig/redis.conf

9、连接测试

#连接redis 默认端口6379 也可以省略redis-cli -p 6379127.0.0.1:6379> ping #连接测试PONG #连接成功127.0.0.1:6379> set key value  127.0.0.1:6379> get key  #获取指定key的值127.0.0.1:6379> keys *   #获取所有的key127.0.0.1:6379> shutdown #关闭redis....> exit               #退出连接

查看redis进程是否开启

ps -ef| grep redis

5、Redis基本知识

开启redis--------

#/usr/local/bin下 rconfig为自定义的文件夹存放redis.confredis-server rconfig/redis.conf

连接redis

#本机可省略-h； port为6379也可省略-predis-cli -h ip -p port

redis默认有16个数据库，默认使用第一个数据库

# 切换数据库 index从0-15127.0.0.1:6379> select index#当前数据库使用大小127.0.0.1:6379> dbsize#清空当前数据库127.0.0.1:6379> flushdb#清空所有数据库127.0.0.1:6379> flushall

redis端口为什么是6379

merz(女明星)九宫格对应数字

redis是单线程的，redis是纯内存数据库，一般都是简单的存取操作

为什么redis单线程还这么快

多线程会产生cpu上下文切换，消耗资源；

redis全程使用hash结构，读取速度快；

基本命令

命令	解释
EXISTS key [key ...]	key是否存在
expire key seconds	设置过期时间
ttl key	查看key过期剩余时间
move key db	迁移key
del key	移除key
type key	查看当前key类型

6、redis常见数据类型

基本数据类型：

string、list、set、hash、zset(sorted set)

特殊数据类型

Geospatial地理位置、hyperloglog计数统计算法、bitmaps位存储

6.1 String(字符串)

操作	命令
字符串追加	append key value
获取长度	strlen key
key加一(递增)(计数器)	incr key
key减一(递减)	decr key
设置key增长量	incrby key increment
设置key减少量	decrby key decremen
获取字符串指定范围内容	getrange key start end
获取全部	getrange key 0 -1
字符串内容替换(指定位置开始替换)	setrange key offset value
将值 value 关联到 key ，并设置过期时间	setex key seconds value
key不存在再设置(分布式锁常用)	setnx key value
批量set	mset key value [key value ...]
批量get	mget key [key ...]
同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在(原子性)	msetnx key value [key value ...]
将给定 key 的值设为 value ，并返回 key 的旧值	getset key value

string存对象

#1、设置user:1对象，值为Json保存set user:1 {name:xls,age=23}#2、属性存入key，方便获取，不用解析json(与hash类似)mset user:1:name xls user:1:age 23

6.2 list(列表)

Redis中list可以当成栈、队列、阻塞队列

所有的list命令都是以L开头

常用命令：

lpush key element [element ...]	向list中存值(列表头部插入)
lrange key start stop	获取list数据(0 -1全部)
Rpush key element [element ...]	向列表尾部插值
Lpop key	左移除(移除列表第一个元素)
Rpop key	右移除(移除列表最后一个元素)
Lindex key index	通过下标获取值
Llen key	返回列表长度
Lrem key count value	移除指定个数的value
Ltrim key start stop	截取列表
Rpoplpush source destination	移除列表最后一个元素，并放入新的列表
Lset key index element	向列表中指定下标替换(列表必须存在，下标必须存在)
Linsert key before/after pirot value	向列表指定值前/后插入新的值

list实际是个链表，left、right都可插入

消息队列：走进右拿 lpush Rpop

栈：左进左拿 lpush lpop

6.3 set(无序集合)

Sadd key value	插入
Smembers key	查看指定set的所有值
Sismember key value	set中是否包含元素
Scard key	set的元素个数
Srem key value [value ...]	移除set中元素
Srandmember key [count]	随机选出指定个数元素
Spop key	随机移除set中一个元素
Smove soure destination member	将目标set中元素移除到指定set
Sdiff key [key ...]	差集
Sinter key [key ...]	交集
Sunion key [key ...]	并集

6.4 hash(哈希)

key-map,hash的值是一个map集合key-value

应用：用户信息保存；经常变更的数据；对象的存储。

Hset key field value [field value ...]	插入
Hget key field [field ...]	获取元素
Hgetall key	获取hash所有元素
Hdel key field [field ...]	删除元素
Hlen key	hash长度
Hexists key field	元素是否存在
Hkeys key/Hvals key	获取所有字段/获取所有值
Hincrby key field	元素递增
Hdecrby key field	元素递减
Hsetnx key field value	不存在再设置

6.5 Zset(有序集合)

在set基础上加上了一个数的标识用来排序

Zadd key [nx/xx] [ch] [incr] score member [source member]

例：Zadd test 1 one 2 two 3 three

应用:

set排序，储存班级成绩，工资表排序

消息权重

排行榜应用实现

Zrange key 0 -1	查看所有
Zrangebysore key min max [witnscore] [limite offset count]	按score排序(小到大)
Zrem key member [member ...]	删除元素
Zcard key	集合元素个数
Zrevrange key 0 -1	大到小排序
Zcount key min max	获取指定区间的数量

6.6 Geospatial(地理位置)

朋友定位，附近的人，打车距离计算

geo基于Zset，Zset的所有命令都可用于geo

两级无法添加，一般通过程序导入，经度-180到180度，纬度-85.05..到85.05..

geoadd key longitude latitude member [longitude latitude member ...]	添加元素及位置
geopos key member	获取指定元素的经纬度
geodist key member1 member2	两元素间距离
georadius key longitude latitude radius m/km/ft/mi [count number]	以指定位置为中心获取半径内的元素
georadiusbymember key member radius m/km/ft/mi	以指定元素为中心获取半径内的元素

6.7 hyperloglog (基数统计算法)

基数：不重复的数

应用：

统计网站访问人数(一个人多次访问只计一次)；

传统的方法：set保存用户id，统计set中元素个数，这个方法需要保存大量用户id，比较麻烦，消耗内存

hyperloglog 占用内存是固定的，2^64不同元素的计数只需12kb内存，0.81%错误率。

pfadd key member [member ...]	添加元素
pfcount key	统计元素中基数数量
pfmerge deskey sourcekey [sourcekey ...]	合并表

6.8 bitmaps(位存储)

两个状态的都可以使用bitmaps；

通过操作二进制来记录，就只会有0/1两种状态，如打卡记录，统计用户信息，活跃不活跃

setbit key offset value	添加(如：setbit sign 1(号数等) 0(0未打卡，1已打卡) )
getbit key offset	查看
bitcount key [start end]	统计

7、Redis基本事务操作

redis单条命令是保证原子性的，但是事务不保证原子性。

redis事务本质：一组命令的集合，一个事务中所有的命令都会被序列化，在事务执行过程中会按照顺序执行。

redis事务中没有隔离级别的概念，只有发起执行命令时才执行(exec)。

7.1 redis事务三个阶段：

开启事务(multi)
命令入队
执行命令(exec)

...> multi  #开启事务ok...> set t1 test1  #入队QUEUED...> set t2 test2  #入队QUEUED...> get t1  #入队  QUEUED...> get t2  #入队QUEUED...> exec    #执行ok           #返回结果ok..

7.2 事务失败

放弃事务(discard)：执行该命令后，队列中的事务将不会被执行。
编译型异常(代码有问题，命令有错)：事务中所有的命令都不会被执行。
运行时异常(如1/0)：执行时其他命令可以正常执行，错误的命令抛出异常。

7.3 Redis实现乐观锁

watch监视：

事务操作前对元素进行监控，元素被其他线程修改则事务不会执行，每个事务完成watch失效。

...> set money 100...> set out 0...> watch money        #监视money的值...> multi              #开启事务...> decryby money 10...> incryby out 10     ...> exec               #exec之前其他线程修改了money，事务会执行失败，返回nil

unwatch解锁：

如果事务执行失败，则解锁，再watch key 获取新的值，再次监视。

二、Redis使用

1、通过Jedis操作Redis

Jedis是官方推荐的java连接开发工具，使用Java操作redis中间件(jar包)。

Jedis中所有的api对应的命令用法一致

使用：

<dependency>    <groupId>redis.clientsgroupId>    <artifactId>jedisartifactId>    <version>3.2.0version>dependency>     Jedis jedis=new Jedis("host",ip);System.err.println(jedis.ping());JSONObject json=new JSONObject();json.put("name","xls");json.put("age",23);String result=json.toJSONString();//实现事务Transaction multi = jedis.multi();try {    multi.set("user1",result);    multi.set("user2",result);    multi.exec();} catch (Exception e) {    multi.discard();    e.printStackTrace();} finally {    //关闭连接    jedis.close();}

2 、springboot整合Redis

spring boot的数据相关操作都封装再在spring-Data中，spring-Data也是和Spring Boot齐名的项目。

在Spring Boot 2.x之后，原来使用的Jedis被替换成Lettuce

Jedis:采用直接、多线程操作的话不安全，如果要避免不安全，就要使用Jedis pool连接池。(更像BIO)

Lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全，可以减少线程数量。(更像NIO)

2.1 自动配置类RedisAutoConfiguration：

RedisAutoConfiguration是Spring Data提供的redis自动配置类。

RedisConnectionFactory实现类有JedisConnectionFactory和LettuceConnectionFactory，

JedisConnectionFactory中引用的类没有导入，所以使用不了jedis连接池，而LettuceConnectionFactory能够使用。

@Configuration(proxyBeanMethods = false)@ConditionalOnClass(RedisOperations.class)@EnableConfigurationProperties(RedisProperties.class)@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })public class RedisAutoConfiguration {    @Bean    @ConditionalOnMissingBean(name = "redisTemplate")//如果没有设置redisTemplate才生效，我们可以自定义一个redisTemplate    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)            throws UnknownHostException {        //默认的RedisTemplate没有过多的设置，redis对象都是需要序列化的        //两个泛型都是Object类型，我们后续使用需要强制转换        RedisTemplate<Object, Object> template = new RedisTemplate<>();        template.setConnectionFactory(redisConnectionFactory);        return template;}    @Bean    @ConditionalOnMissingBean //由于string类型是redis中最长使用的类型，所以单独提出来一个bean    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)            throws UnknownHostException {        StringRedisTemplate template = new StringRedisTemplate();        template.setConnectionFactory(redisConnectionFactory);        return template;}}

2.1 Spring中使用Redis

2.1、导入依赖

<dependency>    <groupId>org.springframework.bootgroupId>    <artifactId>spring-boot-starter-data-redisartifactId>dependency>

2.2、配置连接(application.properties)

#springboot所有的配置类，都有一个自动配置类，redis的是RedisAutoConfiguration#自动配置类都会绑定一个properties配置文件，RedisProperties#配置reidsspring.redis.host=192.168.20.128spring.redis.port=6379#连接池使用lettuce，而不是jedis连接池，springboot中jedis连接池很多类不存在所以不生效

2.3、测试使用

//注入SpringData提供的redisTemplate@Autowiredprivate RedisTemplate redisTemplate;@Testvoid contextLoads() {    //操作类型，api和基本命令基本一样    //操作字符串    redisTemplate.opsForValue().set("mykey1","xls");    Object mykey = redisTemplate.opsForValue().get("mykey1");    System.err.println(mykey);    //操作list    redisTemplate.opsForList();    //操作set    redisTemplate.opsForSet();    //操作zset    redisTemplate.opsForZSet();    //操作hash    redisTemplate.opsForHash();    //操作HyperLogLog(基数算法)    redisTemplate.opsForHyperLogLog();    //操作geo(地理位置)    redisTemplate.opsForGeo();    //除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的crud    redisTemplate.multi();    redisTemplate.exec();    redisTemplate.discard();    redisTemplate.delete("");    //获取reids的连接对象    RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();    connection.flushDb();    connection.flushAll();    }

2.3 替换redisTemplate方法

由于调用提供的redisTemplate存入数据时会进行转义(默认使用的是JDKSerializable序列化)。

自定义redisTemplate可以指定序列化方法

使用时依赖注入自定义类返回的RedisTemplate，如果没成功可用@Qualifier("redisTemplate")注解标注
@Autowired@Qualifier("redisTemplate")private RedisTemplate redisTemplate;

@Configurationpublic class RedisConfig {    //固定模板，在企业中可直接使用    //自定义一个redistemplate    @Bean    @SuppressWarnings("all")    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)            throws UnknownHostException {        //修改方便使用的泛型        RedisTemplate<String, Object> template = new RedisTemplate<>();        template.setConnectionFactory(redisConnectionFactory);        //jackson序列化配置        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);        ObjectMapper om=new ObjectMapper();        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);        jackson2JsonRedisSerializer.setObjectMapper(om);        //String序列化配置        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();        //key采用string的序列化        template.setKeySerializer(stringRedisSerializer);        //hash采用string序列化        template.setHashKeySerializer(stringRedisSerializer);        //value序列化采用jackson        template.setValueSerializer(jackson2JsonRedisSerializer);        //hash的value采用jackson序列化        template.setHashValueSerializer(jackson2JsonRedisSerializer);        template.afterPropertiesSet();        return template;    }}

2.4 RedisUtil

自定义的redis工具类：

进一步封装template提供的方法，可省略重复的Try-catch，空值判断等

三、redis.config文件

1、配置文件单位、大小写不敏感

2、引入其他配置文件

3、网络

#绑定ip，设置127.0.0.1可本机访问，设置成0.0.0.0可供外部连接bind 127.0.0.1protected-mode yes #保护模式port 6379 #端口设置

4、通用 GENERAL

daemonize yes  #以守护进程方式运行，默认是no，需要自己开启为yespidfile /var/run/redis_6379.pid #如果以后台方式运行，需要指定pid文件#日志# 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#日志的文件位置名，如果为空为标注的输出logfile ""#数据库的数量databases 16#是否总是显示logoalways-show-logo yes

5、快照

持久化，在规定的时间内，执行了多少次操作就会持久化到文件 .rdb.aof

redis是内存数据库，没有持久化，数据断电即失；

#在900秒内，至少有1个key进行了修改，就进行持久化操作save 900 1#在300秒内，至少有10个key进行了修改，就进行持久化操作save 300 10#在60秒内，至少有10000个key进行了修改，就进行持久化操作save 60 10000#可以设置自己的持久化策略#持久化如果出错了，redis是否还继续工作stop-writes-on-bgsave-error yes#是否压缩rdb文件，需要消耗一些cpu的资源rdbcompression yes#保存rdb文件时，进行错误校验rdbchecksum yes#rdb文件保存目录dir ./

6、replication 复制 (主从复制时讲解)

7、SECURITY 安全密码

设置密码，默认没有密码

#  设置密码方式一，命令修改[root@localhost bin]# redis-cli    127.0.0.1:6379> ping    PONG    127.0.0.1:6379> config set requirepass "123456" #设置密码    OK    127.0.0.1:6379> config get requirepass #获取密码    1) "requirepass"    2) "123456"    127.0.0.1:6379> auth 123456  #使用密码重新登录    OK    127.0.0.1:6379> ping    PONG

# 设置密码方式二，redis.conf文件的requirepass值requirepass 密码

8、限制CLIENTS

Redis提供6种数据淘汰策略

#设置客户端最大连接数量maxclients 10000#最大内存容量maxmemory #内存达到上限之后的处理策略maxmemory-policy noevictionRedis提供6种数据淘汰策略：    1、volatile-lru:从已设置过期时间的内存数据集中挑选最近最少使用的数据 淘汰；    2、volatile-ttl: 从已设置过期时间的内存数据集中挑选即将过期的数据 淘汰；    3、volatile-random:从已设置过期时间的内存数据集中任意挑选数据 淘汰；    4、allkeys-lru:从内存数据集中挑选最近最少使用的数据 淘汰；    5、allkeys-random:从数据集中任意挑选数据 淘汰；    6、no-enviction(驱逐)：禁止驱逐数据。(默认淘汰策略。当redis内存数据达到maxmemory，在该策略下，直接返回OOM错误)；

9、APPEND ONLY模式 aof模式

#默认不开启aof模式。默认使用rdb方式持久化，大部分情况下够用appendonly no#持久化文件的名字appendfilename "appendonly.aof"# appendfsync always #每次修改都会同步sybc，消耗性能appendfsync everysec #每秒执行一次sync，可能会丢失这1s数据# appendfsync no  #不执行同步sync，这个时候操作系统自己同步数据，速度最快

具体配置在redis持久化配置中详解

四、Redis持久化

redis是内存数据库，如果不将内存中的数据存入磁盘，那么一旦服务进程退出，服务器中的数据库状态也会消失，所以需要持久化功能。

RDB(Redis DataBase)

在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是Snapshot快照，它恢复时是将快照文件直接读到内存中。

redis会单独创建一个子进程(fork)来进行持久化，会先将数据写入一个临时文件中，等持久化过程都结束了，再用这个临时文件替换上次的持久化文件。整个过程中，主进程不进行任何的IO操作，这确保了极高的性能。如果需要进行大规模的数据恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加高效，RDB缺点是最后一次持久化后的数据可能丢失。默认的是RDB，一般情况下不需要修改配置。

RDB保存的文件是/usr/local/bin/dump.rdb,都是在配置文件中的快照中进行配置的。

生成环境将dump.rdb备份。

# The filename where to dump the DBdbfilename dump.rdb

优点：

1、适合大规模的数据恢复

2、对数据的完整性要求不高

缺点：

1、需要一定的时间间隔进程操作，如果redis意外宕机了，这个最后一次修改数据就没有了；

2、fork进程的时候，会占用一定的内容空间。

AOF(append only file)

将所有命令都记录下来，history，恢复时就把这个文件全部执行一遍。

以日志的形式来记录每个操作，将Redis执行过的所有指令记录下来(读操作不记录)，只许追加文件，不可以改写文件，redis启动之初会读取该文件重新构建数据库。

AOF保存的时appendonly.aof文件

appendonly no   #默认不开启，修改appendonly为yes就开启了aof模式，重启redis即可生效appendfilename "appendonly.aof" #持久化的文件名# aof执行策略# appendfsync always  #每一次操作都追加，消耗性能appendfsync everysec  #每秒执行一次，可能会丢失这一秒的数据# appendfsync no      #不执行 sync，这个时候操作系统自己同步数据，速度最快

redis-check-aof修复aof文件

appendonly.aof文件损坏，redis将无法启动(dump.rdb文件也没有的情况下)。

/usr/local/bin/redis-check-aof 用于修复损坏的aof文件

redis-check-aof --fix appdendonly.aof

文件重写机制说明

aof默认就文件无限追加，文件会越来越大。

重写机制：如果aof文件大于64m，fork一个新的进程来将文件进行重写，保证文件不会太大。

no-appendfsync-on-rewrite no    #默认关闭重写机制，开启yesauto-aof-rewrite-percentage 100 #上次aof文件大小auto-aof-rewrite-min-size 64mb

优点：

1、每一次修改都同步，文件完整性会更好

2、每一秒同步一次，可能会丢失一秒的数据

3、从不同步，效率最高

缺点：

1、相对于数据文件来说，aof远远大于rdb，修复速度也比rdb慢；

2、aof运行效率也比rdb慢，所有redis默认rdb

扩展：

1、rdb持久化方式能够在指定时间间隔内对你的数据进行快照存储；

2、aof持久化方式记录每次对服务器的写操作，当服务器重启时会重新执行这些命令来恢复原始数据，AOF命令以redis协议追加保存每次写的操作到文件末尾，redis还能对AOF文件进行后台重写，使得aof文件体积不至于太大；

3、只做缓存，如果只希望你的数据在服务器运行的时候存在，也可以不使用任何持久化；

4、同时开启两种持久化方式

在这种情况下，当redis重启时会优先载入aof文件来恢复原始数据，因为在通常情况下aof文件保存的数据集要比rdb文件保存的数据集完整
rdb的数据不实时，同时使用两者时服务器重启也只会找aof文件，但是不建议只使用aof方式，因为rdb更适合用于备份数据库(aof在不断变化不好备份)，快速重启，而且不会有aof可能潜在的bug，留着作为万一手段

5、性能建议

因为rdb文件只用作后备用途，建议只在slave(从机)上持久化rdb文件，而且只要15分钟备份一次就够了，只保留save 900 1这条规则
如果enable AOF，好处是在最恶劣的情况下也只会丢失不超过2s的数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的IO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘允许，应尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64m太小，可以设置到5G以上，默认超过原大小100%重写，也可以改到适合的值
如果不Enable AOF，仅靠Master-Slave Repllcation实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时挂掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave中的rdb文件，载入较新的那个，微博就是这种架构。

五、Redis发布订阅

redis发布订阅(pub/sub)是一种消息通信模式，订阅者(sub)接收消息。微博、微信、关注系统。

指令：

 # 订阅一个或多个频道 psubdcribe pattern [pattern] #查看订阅于发布系统状态 pubsub subcommand [argument [argument ...]] #将信息发送到指定频道 publish channel message #退订给定模式的频道 punsubscribe [pattern [pattern ...]] #订阅频道 subscribe channel [channel ...] #退订给定频道 unsubscribe [channel [channel ...]]

原理：

通过subscribe命令订阅某频道后，redis-server里维护了一个字典，字典的键就是一个个channel，而字典的值则是一个链表，链表中保存了所有订阅这个channel的客户端。subscribe命令的关键就是将客户端添加到给定的channel的订阅链表中。

通过publish命令向订阅者发送消息，redis-server会使用给定的频道作为key，在他所维护的channel字典中查找订阅了这个评到的所有客户端链表，遍历这个链表，将消息发布给所有订阅者。

使用场景

1、实时消息系统；

2、实时聊天系统；

3、订阅，关注等

稍微复杂一点的系统，选择用中间件来做。

六、Redis主从复制

1、概念

主从复制：是指一台redis服务器的数据，复制到其他redis服务器。前者称为主节点(master/leader)，后者称为从节点(slave/follower)；数据的复制是单向的，只能由主节点到从节点。master以写为主，slave以读为主。

默认情况下，每台redis服务器都是主节点，且一个主节点可以有多个从节点(或没有)，但一个从节点只能有一个主节点。

2、主从复制的作用

数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式；
故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复，实际上是一种服务冗余；
负载均衡：在主从复制基础上，配合读写分离，可以由主节点提供写服务，从节点提供读服务，分担服务器负载；尤其是在写少读多情况下，通过从节点分担读负载，可以大大提高redis服务的并发量；
高可用(集群)基石：主从复制还是哨兵和集群能够实施的基础，因此它是redis高可用的基石

一般来说工程项目中，一台redis是不够的(框架中一般使用一主二从)

单个redis服务器会发生单独故障，并且单台服务器请求压力较大；
单个redis内存容量有限，一台redis服务器内存容量为256G，但是不能将所有内存用作redis存储内存，一般redis最大使用内存不超过20G

3、环境配置(搭建伪集群)

查看redis库的信息，默认情况下每台redis都是主节点，我们只用配置从机；

127.0.0.1:6379> INFO replication# Replicationrole:master  #角色connected_slaves:0 #从机个数master_replid:9777390da8ab158625cf8ec409c3741aba9fe6a8master_replid2:0000000000000000000000000000000000000000master_repl_offset:0second_repl_offset:-1repl_backlog_active:0repl_backlog_size:1048576repl_backlog_first_byte_offset:0repl_backlog_histlen:0

1、复制配置文件，修改port，pid名字，log文件名，dump文件名

这里只是由于在同一台服务器上实验主从复制，所以修改端口等来避免多个redis进程冲突。

[root@VM-0-16-centos rconfig]# lsredis79.conf  redis80.conf  redis81.conf  redis.conf

2、启动不同端口的redis

[root@VM-0-16-centos bin]# redis-server rconfig/redis79.conf [root@VM-0-16-centos bin]# redis-server rconfig/redis80.conf [root@VM-0-16-centos bin]# redis-server rconfig/redis81.conf [root@VM-0-16-centos bin]# ps -ef|grep redisroot     24750     1  0 15:39 ?        00:00:00 redis-server 0.0.0.0:6379root     24920     1  0 15:40 ?        00:00:00 redis-server 0.0.0.0:6380root     24941     1  0 15:40 ?        00:00:00 redis-server 0.0.0.0:6381root     24958 19799  0 15:40 pts/0    00:00:00 grep --color=auto redis

3、修改配置实现主从复制(一主二从)

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379 #配置主机OK127.0.0.1:6380> INFO replication# Replicationrole:slavemaster_host:127.0.0.1master_port:6379master_link_status:down...

127.0.0.1:6381> SLAVEOF 127.0.0.1 6379 #配置主机OK

命令配置重启失效，通过配置文件配置如下

#REPLICATION中，一下命令注释取消，配置对应的主机ip、端口和密码，保存即可# replicaof # masterauth

查看主机信息更改

127.0.0.1:6379> INFO replication# Replicationrole:masterconnected_slaves:2slave0:ip=127.0.0.1,port=6380,state=online,offset=1008,lag=1slave1:ip=127.0.0.1,port=6381,state=online,offset=1008,lag=0

细节

从机无法写入数据

# 主机6379，从机6380，6381127.0.0.1:6380> set key5 test5(error) READONLY You can't write against a read only replica.

2. 从机可以获取主机写入的信息

3.主服务器挂掉，从服务器还是从服务器，需要手动将从服务器切换为主服务器。如果是配置文件配置的需要修改配置文件，如果是命令行修改的需要执行slaveof no one 命令切换成主服务器

4、复制原理

slave启动成功连接到master后发送一个sync命令

master收到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集的命令，在后台进程执行完毕后，master将传送整个数据文件到slave，并完成一次完全同步。

全量复制：slave服务器在接收到数据文件后将其存盘并加载到内存中；

增量复制：master继续将新搜集到的修改命令依次传给slave，完成同步；

只要重新连接master，完全同步(全量复制)将自动进行。

六、哨兵模式(自动选举主机模式)

1、概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，还会造成一段时间能服务不可用。所以优先考虑哨兵模式。

哨兵模式能够监控后台主机是否有故障，如果故障根据投票数自动将从数据库换为主数据库。

原理

哨兵为一个独立的进程，哨兵通过发送命令,等待redis服务器响应，从而监控运行的多个redis实例