Redis的简单使用 – 破碎的冰

windows启动Redis

在redis目录下，在命令窗口执行：redis-server.exe redis.windows.conf
测试使用：打开另一个命令窗口,执行: redis-cli.exe

Linux安装Redis

1、下载安装包 https://redis.io/download

2、解压Redis安装包，程序一般放在opt目录下tar -zxvf (redis)

3、进入解压后的文件，可以看到redis配置文件

4、基本的环境安装

yum install gcc-c++ //安装c
make 
make install //* 选择性执行，确认环境

5、redis的默认安装路径usr/

6、新建一个配置文件夹mkdir，将redis配置文件，复制到当前目录下redis.conf

7、redis默认不是后台启动的，修改配置文件

将daemonize设置为yes

通过制定的配置文件启动redis服务

8、测试连接

9、查看redis进程号与端口号 ps -ef|grep redis

10、关闭redis服务？ shutdown

测试性能-benchmark

redis-benchmark是一个redis官方自带的压力测试工具

压力测试：

#测试：100个并发 10000个请求
redis-benchmark -h localhost -p 6379 -c 100 -n 10000

解读：

l1:10000个请求0.12秒完成

l2:100个并发客户端

l2:每次写出3个字节

l3::只有一台服务器来处理这些请求，单机性能

基础的知识

redis默认有16个数据库

默认使用的是第0个，可以使用select进行切换

127.0.0.1:6379> select 3 #切换数据库
OK
127.0.0.1:6379[3]> dbsize #查看数据库大小
(integer) 0

清除当前数据库flushdb,清空全部数据库FLUSHALL

Redis是单线程的！

Redis是基于内存操作，CPU不是Redis性能瓶颈，Redis的瓶颈是根据机器的内存和网络带宽。

Redis为什么单线程还这么快？

1、误区1：高性能发服务器一定是多线程

2、误区2：多线程一定比单线程效率高

核心：redis是将所有的数据全部放在内存中的，所以使用单线程去操作效率就是最高的，多线程(CPU上下文切换会消耗多余资源)，对于内存系统来说，没有上下文切换，效率就是最高的

五大数据类型

Redis-Key

String(字符串)

set/get key value #设置/获取值
keys * #获得所有的key
EXISTS key #判断key是否存在
APPEND key "hello" #追加字符串，如果当前key不存在，就相当于set key
STRLEN key #获取字符串长度
incr key #自增1
decr key #自减1
INCRBY key 10 # 可以设置步长，指定增量
DECRBY key 5 #指定自减量
GETRANGE key 0 3 #截取字符串[0,3]
SETRANGE key 1 xx #替换指定位置[1,]开始的字符串
setex key time value #设置过期时间
setnx key value #如果key不存在，创建key
ttl key #查看过期时间倒计时
mset k1 v1 k2 v2 k3 v3...  #同时设置多个值
mget k1 k2 k3... #同时获取多个值
msetnx k1 v2 k4 v4 #msetnx是一个原子性的操作，要么都成功，要么都失败
set user:1{key1:value1,key2:value2} #设置user:1对象 值为json字符来保存一个对象
    mset user:1:name jhonny user:1:age 3 #设置
    mget user:1:name user:1:age #获取
getset #先get然后再set
    getset db redis #如果不存在值，则返回nil
    get db ---> "redis"
    getset db mongodDB ----> "redis" #如果存在值，获取原来的值，并设置新的值
    get db ---> "mongoDB"

List(列表)

所有list命令都是l开头

127.0.0.1:6379> LPUSH list one #将一个值或多个值，插入到列表头部 左边
(integer) 1
127.0.0.1:6379> LPUSH list two
(integer) 2
127.0.0.1:6379> LPUSH list three
(integer) 3
127.0.0.1:6379> LRANGE list 0 1  #通过区间获取list中值
1) "three"
2) "two"
127.0.0.1:6379> LRANGE list 0 -1 #获取list中值
1) "three"
2) "two"
3) "one"

127.0.0.1:6379> RPUSH list right1 #将一个值或多个值，插入到列表尾部 右边
(integer) 4
127.0.0.1:6379> LRANGE list 0 -1 
1) "three"
2) "two"
3) "one"
4) "right1"

127.0.0.1:6379> LPOP list  #移除list的第一个元素
"three"
127.0.0.1:6379> RPOP list  #移除list的最后一个元素
"right1"
127.0.0.1:6379> lrange list
(error) ERR wrong number of arguments for 'lrange' command
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"

127.0.0.1:6379> LINDEX list 1  #通过下标获得list中的某一个值
"one"
127.0.0.1:6379> LINDEX list 0
"two"

Llen key #返回列表的长度

127.0.0.1:6379> LPUSH list one
(integer) 2
127.0.0.1:6379> LPUSH list one
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "one"
2) "one"
3) "two"
127.0.0.1:6379> LREM list 2 one #移除list中的2个one
(integer) 2
127.0.0.1:6379> LRANGE list 0 -1
1) "two"

trim #修建 
    ltrim list 1 2 #通过下标截取指定的长度，原list会被修改
rpoplpush #移除列表的最后一个元素，将它移动到新的列表中
    rpoplpush oldlist newlist 

127.0.0.1:6379> RPUSH list "hello" 
(integer) 1
127.0.0.1:6379> RPUSH list "world"
(integer) 2
127.0.0.1:6379> linsert list after "world" "happy" #插入数据
(integer) 3
127.0.0.1:6379> keys *
1) "list"
127.0.0.1:6379> LRANGE list 0 0
1) "hello"
127.0.0.1:6379> LRANGE list 0 -1
1) "hello"
2) "world"
3) "happy"

消息队列(lpush rpop)

Set(集合)

无序不重复集合

127.0.0.1:6379> sadd myset "hello" #set 新建一个myset集合并在集合中添加元素
(integer) 1

127.0.0.1:6379> sadd myset "hello" #set 集合中添加元素
(integer) 1
127.0.0.1:6379> sadd myset "jhonny"
(integer) 1
127.0.0.1:6379> SMEMBERS * #查看指定set的所有值
(empty array)
127.0.0.1:6379> SMEMBERS myset
1) "hello"
2) "jhonny"
127.0.0.1:6379> SISMEMBER myset hello #判断一个值是不是在set集合中
(integer) 1

127.0.0.1:6379> scard myset # 获取set集合中的内容元素个数
(integer) 2 

127.0.0.1:6379> srem myset hello #移除指定set集合中指定元素
(integer) 1
127.0.0.1:6379> scard myset
(integer) 1
127.0.0.1:6379> smembers myset
1) "jhonny"

127.0.0.1:6379> srandmember myset #随机取一个myset集合中的元素
"jhonny1"
127.0.0.1:6379> srandmember myset 2 #随机取两个myset集合中元素
"jhonny1"
"jhonny"

127.0.0.1:6379> spop myset #随机删除一个元素
"jhonny1"

127.0.0.1:6379> smove myset myset2 bay #将指定一个值，移动到另外一个set集合
(integer) 1
127.0.0.1:6379> smembers myset2
1) "bay"
2) "set2"

两个集合取：
- 差集：SIDFF key1 key2 ---> 以key1为参照物，取两集合的差集
- 交集：SINTER key1 key2 
- 并集：SUNION key1 key2

Hash(哈希)

Map集合，key-Map（key-value）时候这个值是一个map集合本质和String类型没有太大区别，还是一个简单的key-value

127.0.0.1:6379> hset myhash field1 jhonny # set一个具体key-value
(integer) 1
127.0.0.1:6379> hget myhash field1
"jhonny"
127.0.0.1:6379> hmset myhash field1 hello field2 world  #set多个key-value
OK 
127.0.0.1:6379> hmget myhash field1 field2 #获得多个字段值
1) "hello"
2) "world"
127.0.0.1:6379> hgetall myhash #获取全部的数据
1) "field1"
2) "hello"
3) "field2"
4) "world"

127.0.0.1:6379> hdel myhash field1 #删除hash指定key子墩，对应的value值也就没有了
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"

127.0.0.1:6379> hlen myhash #获取hash表的字段数量
(integer) 2
127.0.0.1:6379> hexists myhash field1 #判断hash中指定字段是否存在
(integer) 1
127.0.0.1:6379> hexists myhash field3
(integer) 0

127.0.0.1:6379> hkeys myhash # 只获得所有的key
1) "field2"
2) "field1"
127.0.0.1:6379> hvals myhash # 只获得所有的value
1) "world"
2) "hello"

127.0.0.1:6379> hincrby myhash field 1 #指定增量
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 hello #如果不存在则可以设置
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 hello #如果存在则不能设置
(integer) 0

hash变更的数据user name age 尤其是用户信息之类的，经常变动的信息，hash更适合于对象的存储，String更加适合字符串存储

Zset(有序集合)

在set基础上，增加了一个值，set k1 v1 / zset k1 score1 v1

127.0.0.1:6379> zadd myset 1 one  #添加一个值
(integer) 1
127.0.0.1:6379> zadd myset 2 two 3 three #添加多个值
(integer) 2
127.0.0.1:6379> ZRANGE myset 0 -1 
1) "one"
2) "two"
3) "three"

#排序如何实现
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf  #显示全部用户，从小到大
1) "jhonny"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> ZREVRANGE salary 0 -1 #从大到小
1) "zhangsan"
2) "xiaohong"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf  2500 withscores #显示工资小于2500员工的升 序排列
1) "jhonny"
2) "500"
3) "xiaohong"
4) "2500"

127.0.0.1:6379> zrem salary jhonny #移除有序集合中的指定元素
(integer) 1
127.0.0.1:6379> zcard salary #显示有序集合中的个数
(integer) 2

127.0.0.1:6379> zadd myset 1 hello
(integer) 1
127.0.0.1:6379> zadd myset 2 world 3 jhonny
(integer) 2
127.0.0.1:6379> zcount myset 1 2 #获取指定区间的成员数量
(integer) 2

三种特殊数据类型

geospatial地理位置

geoadd

#添加地理位置
#规则：两级无法直接添加，我们一般会下载城市数据，直接通过java程序一次性导入
#有效的经度从-180到+180
#有效的纬度从-85.05112878到85.05112878
#当坐标位置超出上述指定范围时，该命令会返回一个错误
#参数 key 值(纬度，精度，名称)
127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
(integer) 1
127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing 114.05 22.52 shenzhen
(integer) 2
127.0.0.1:6379> geoadd china:city 120.16 30.28 hangzhou 108.96 34.26 xi'an
Invalid argument(s)
127.0.0.1:6379> geoadd china:city 120.16 30.28 hangzhou 108.96 34.26 xian
(integer) 2

geopos

获得指定城市的经度和纬度，获取的值一定是一个坐标值

127.0.0.1:6379> GEOPOS china:city beijing
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
127.0.0.1:6379> GEOPOS china:city xian
1) 1) "108.96000176668167114"
   2) "34.25999964418929977"

GEODIST

两点之间的直线距离

127.0.0.1:6379> GEODIST china:city beijing shanghai km #查看上海到北京的直线距离
"1067.3788"
127.0.0.1:6379> GEODIST china:city beijing chongqing km #查看重庆到北京的直线距离
"1464.0708"

GEORADIUS

属性：

withdist：显示半径内的元素到原点的直线距离
withcoord：显示半径内元素的经纬度
count：显示指定数量

以给定的经纬度为中心，找出某一半径内的元素

127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km withdist withcoord count 2
1) 1) "chongqing"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) "483.8340"
   3) 1) "108.96000176668167114"
      2) "34.25999964418929977"

GEORADIUSBYMEMBER

找出指定元素指定半径内的其他元素

127.0.0.1:6379> GEORADIUSBYMEMBER china:city shanghai 400 km
1) "hangzhou"
2) "shanghai"

GEOHASH

该命令返回11个字符的GeoHash字符串

127.0.0.1:6379> GEOHASH china:city beijing chongqing #如果两个字符串越接近，则距离越近
1) "wx4fbxxfke0"
2) "wm5xzrybty0"

Hyperloglog

什么是基数？

两个集合中不重复的元素的个数，可以接受误差

Hyperloglog就是基数统计的算法

优点：占用的内存是固定的，2^64不同的元素的基数，只需要费12KB内存，如果从内存角度来比较的话Hyperloglog首选

网页UV（一个人访问一个网站多次，但还是算作一个人）

传统的方式，set保存用户的id，如何可以统计set中的元素数量作为标准判断

这个方式入股保存大量的用户id，就会比较麻烦，我们的目的是为了计数，而不是保存用户id

127.0.0.1:6379> PFADD mykey a b c d e f g h i j #创建第一组元素mykey 
(integer) 1
127.0.0.1:6379> pfcount mykey  #统计mykey 元素的基数数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 i j z x d v f g m n  # 创建第二组元素 mykey2
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 10
127.0.0.1:6379> PFMERGE mykey3 mykey mykey2 #合并两组 mykey mykey2 ===> mykey3 并集
OK
127.0.0.1:6379> pfcount mykey3 #统计数量
(integer) 15

如果允许容错。可以使用Hyperloglog

Bitmap

位存储

统计用户信息，活跃和不活跃，登录和未登录，打卡和未打卡，只有两个状态的，可以使用Bitmap

365天=365bit 1字节=8bit 46个字节左右即可记录365条记录

使用Bitmap记录周一到周日的打卡情况：

查看某一天是否打卡：

127.0.0.1:6379> getbit sign 3
(integer) 1
127.0.0.1:6379> getbit sign 1
(integer) 0

统计做，统计已打卡的天数

127.0.0.1:6379> bitcount sign
(integer) 3

事务

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

一次性、顺序性、排他性。执行一系列的命令

Redis事务没有隔离级别的概念

所有的命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行！Exec

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

redis的事务：

开启事务（MULTI）
命令入队（）
执行事务（EXEC）

127.0.0.1:6379> MULTI #开启事务
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec #执行事务
1) OK
2) OK
3) "v2"
4) OK

127.0.0.1:6379(TX)> DISCARD #取消事务
OK

编译型异常（代码有问题，命令有错误），事务中所有命令都不会被执行！

运行时异常（1/0）如果事务队列中存在语法性，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常，所以redis事务没有原子性

监控：watch

悲观锁：

很悲观，认为什么时候都会出问题，无论做什么都加锁！

乐观锁：

很乐观，认为什么时候都不会出现问题，无论做什么都不会加锁！更新数据的时候去判断在此期间是否有人修改过数据。
获取version
更新的时候比较version

Redis监控测试：

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> watch money #监视money对象
OK
127.0.0.1:6379> MULTI #事务正常结束，数据期间没有发生变动，这个时候就正常执行成功
OK
127.0.0.1:6379(TX)> DECRBY money 20
QUEUED
127.0.0.1:6379(TX)> INCRBY out 20
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20

使用watch可以当做redis的乐观锁操作

Jreis

使用java操作Redis

什么是Jedis？Jedis是Redis官方推荐java连接开发工具，使用Java操作Redis中间件，如果要使用Java操作Redis，那么一定要对Jedis十分熟悉！

导入依赖

<dependencies>
   <!--导入jedis包-->
   <dependency>
       <groupId>redis.clients</groupId>
       <artifactId>jedis</artifactId>
       <version>3.7.0</version>
   </dependency>
   <!--fastjson-->
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>fastjson</artifactId>
       <version>1.2.78</version>
   </dependency>
</dependencies>

编码测试：

连接数据库
操作命令

断开连接

//1.new Jedis 对象即可
Jedis jedis = new Jedis("127.0.0.1",6379);
//2.jedis所有的命令就是我们之前学习的所有指令
System.out.println(jedis.ping());

输出：

常用API

SpringBooot整合Jedis

在Springboot2.x之后，jedis被替换为了lettuce

jedis：采用的直连，多个线程操作的话，是不安全的，如果想要避免，使用jedis pool连接池，更像BIO模式

lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数据，更像NIO模式

源码分析：

@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    //默认的RedisTemplate没有过多的配置。redis对象都是需要序列化
    //两个泛型都是Object，Object的类型，我们后使用需要钱强转转换<String, Obejct>
    RedisTemplate<Object, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

@Bean
@ConditionalOnMissingBean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)//由于String是redis中最常用的类型，所有单独提出来了一个bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

整合测试

配置文件：

# 配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

编写自己的redistemplate+序列化

//编写自定义redisTemplate
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);

    //Json序列化配置
    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的key也采用String的序列化方式
    template.setHashKeySerializer(stringRedisSerializer);
    //value的序列化方式采用jackson
    template.setValueSerializer(jackson2JsonRedisSerializer);
    //hash的value序列化方式采用jackson
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    template.afterPropertiesSet();

    return template;
}

Redis.conf

网络

bind 127.0.0.1 #绑定的ip
protected-mode yes #保护模式
port 6379 #端口设置

通用GENERRAL

daemonize yes # 以守护进程的方式运行，默认是no，需要手动开启
pidfile /var/run/redis.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 notic
logfile "" #日志的文件位置名
databases 16 #数据库的数量，默认是16个数据库
always-show-logo no #是否总是显示LOGO

SNAPSHOTTING 快照

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

redis是内存数据库，如果没有持久化，那么数据断电及失！

save 3600 1  #如果3600秒内，至少有一个1 key进行了修改，则进行持久化操作
save 300 100 #如果300秒内，至少100 key进行了修改，则进行持久化操作
save 60 10000  #如果60秒内，至少10000 key进行了修改，则进行持久化操作

stop-writes-on-bgsave-error yes #持久化如果出错，是否还需要继续工作
rdbcompression yes # 是否压缩rdb文件，需要消耗一些cpu资源
rdbchecksum yes # 保存rdb文件的时候，进行错误的检查校验
dir ./ #rdb文件保存的目录

REPLICATION 复制

SECURITY 安全

可以在这里设置redis密码，默认是没有密码

config set requirepass "password" #设置redis密码
config get requirepass #获取密码
auth password #授权

CLIENTS 限制

maxclients 10000 #设置最大能连接redis的客户端数量
maxmemory <bytes> #redis 配置最大的内存容量
maxmemory-policy noeviction #内存到达上限之后的处理策略
    # 移除一些过期的key

maxmemory-policy 六种方式
volatile-lru：只对设置了过期时间的key进行LRU（默认值） 
allkeys-lru ： 删除lru算法的key   
volatile-random：随机删除即将过期key   
allkeys-random：随机删除   
volatile-ttl ： 删除即将过期的   
noeviction ： 永不过期，返回错误

APPEND ONLY 模式 aof配置

appendonly no # 默认是不开启aof模式的，默认使用rdb方式持久化，在大部分所有的情况下，rdb完全够用 
appendfilename "appendonly.aof" #持久化的文件的名字 

# appendfsync always  # 每次修改都会sync(同步)，消耗性能
appendfsync everysec  # 每秒执行一次 可能会丢失者1s的数据
# appendfsync no     # 不执行sync，这个时候操作系统自己同步数据，速度最快

Redis持久化

Redis是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失，所以Redis提供了持久化的功能

RDB(Redis DataBase)

持久化快照保存过程

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

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

触发机制：

save的规则满足的情况下，会自动触发rdb规则
执行fluashall命令，也会触发我们的rdb规则
退出redis，也会产生rdb文件

备份就会自动生成一个dump.rdb

如何恢复rdb文件？

只需要将rdb文件放在我们redis启动目录就可以，redis启动的时候会自动检查dump.rdb文件，恢复其中的数据

查看需要存放的位置

127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin" #如果在这个目录下存在dump.rdb文件，启动就会自动恢复其中的数据

优点：

适合大规模的数据恢复
对数据的完整性要求不高

缺点：

需要一定的时间间隔进程操作，如果redis意外宕机，这个最后一次修改的数据就没有了
fork进程的时候，会占用一定的内存空间

AOF(Append OnlyFile)

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

默认的不开启的，我们需要手动进行配置，。只需要将appendonly改为yes

如果appendonly.aof被修改的话，可以使用
“`redis-check-aof“`修复，

redis-check-aof --fix appendonly.aof

优点和缺点

# appendfsync always  # 每次修改都会sync，消耗性能
appendfsync everysec  # 每秒执行一次sync，可能会丢失1s的数据
# appendfsync no   # 不执行sync，这个时候操作系统自己同步数据，速度最快

优点：

每一次修改都同步，文件的完整会更加好
每秒同步一次，可能会丢失一秒的数据
从不同步，效率最高的

缺点：

相对于数据来说，aof远远大于rdb，修复的速度也比rdb慢
aof运行效率也要比rdb慢，所以我们redis默认的配置就是rdb持久化

Redis发布订阅

测试：

订阅端：

127.0.0.1:6379> SUBSCRIBE bybing # 订阅一个频道 bybing
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "bybing"
3) (integer) 1
1) "message" # 消息
2) "bybing"  # 频道名称
3) "hello,jhonny" # 消息内容
1) "message"
2) "bybing"
3) "hello,redis"

发送端：

127.0.0.1:6379> PUBLISH bybing "hello,jhonny" # 发布者发布消息到频道
(integer) 1
127.0.0.1:6379> PUBLISH bybing "hello,redis"  # 发布者发布消息到频道
(integer) 1

使用场景：

实时消息系统
实时聊天(频道当做聊天室，将消息回显给所有人即可)
订阅，关注系统都是可以的

稍微复杂的场景就会使用消息中间件MQ

Redis主从复制

概念

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

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

主从复制的作用主要包括：

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

环境配置

只配置从库，不用配置主库

# Replication
role:master #角色：master
connected_slaves:0  #没有从机
master_failover_state:no-failover
master_replid:4439754540685587b7de501012035fd17f54a1cb
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

复制3个配置文件，然后修改对应的四个信息

端口号 #进程占用的端口号
pid名字 #记录了进程的id
log文件名字 #日志名字
dump.rdb名字 #持久化文件

修改完毕之后，启动3个redis服务器，可以通过进程信息查看

一主二从

默认情况下，每台redis服务器都是主节点

一般情况下，只用配置从机就好了。

从机信息：

SLAVEOF ip  port #绑定主机

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379
OK
127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:up
master_last_io_seconds_ago:5
master_sync_in_progress:0
slave_repl_offset:0
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:e3eb259350025730aaa80da77b3d1e5f79c81e71
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:0

主机信息：

在配置文件中配置主从复制：

REPLICATION

replicaof <主机ip地址> <端口号>

masterauth <主机的授权密码>

主机可以写，从机不能写只能读，主机中的所有信息和数据，都会自动被从机保存！

主机断开，从机依旧连接主机，但是没有写操作，这个时候，主机重新连接，从机依旧可以直接获取主机新写入的信息。

从机如果使用命令行绑定的主机，重启后就会自动变成主机！只要重新变为从机，会立马从主机获得值。

复制原理

Slave启动成功连接到一个master后会发送一个sync同步命令，Master街道命令，启动后台的存盘进程，同时手机所有接收到的用于修改数据命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次同步。

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

增量复制：Master继续将新的所有收集到的修改命令依次传给slave，完成同步

但是只要是重新连接master，一次完全同步(全量复制)将被自动执行，数据一定可以在从机中看到

层层链路

上一个Master连接下一个Slave，这个时候也可以完成主从复制

如果主机断开连接，我们可以使用
“`SLAVEOF NO ONE“`让从机自己变成临时主机，其他节点就可以==手动连接==到最新的这个主节点，等原始主机修复好了，需手动重新连接，配置主从关系。

哨兵模式

自动选举主机模式

概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费时费力，还会造成一段时间内服务不可用，这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。

能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行，其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例

哨兵模式的两个作用：

通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
当哨兵检测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

假设主服务器宕机，监视此服务器的哨兵会先检测到这个结果，系统并不会模式进行failover过程，仅仅是此哨兵主观的认为主服务器不可用，这个现象称为主观下线，后面的哨兵也检测到主服务器不可用，并数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover[故障转移]操作，切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线

测试

状态：一主二从

配置哨兵配置文件
“`sentinel.conf“
```
sentinel monitor myredis(被监控的名称) 127.0.0.1 6379 1
```
后面这个数字1，代表主机挂了，slave投票让谁接替称为主机，票数最多的，就会成为主机

启动哨兵

[root@iz2zefq6ofuvebjh7ztbasz bin]# redis-sentinel bconfig/sentinel.conf

如果主机回来了。只能归并到新的主机下，当做从机，这就是哨兵模式的规则。

优点：

哨兵集群，基于主从复制模式，所有的主从配置优点，他全有
主从可以切换，故障可以转移，系统的可用性就会更好
哨兵模式就是主从模式的升级，手动到自动，更加健壮

缺点；

Redis不好在线扩容，集群容量一旦到达上限，在线扩容就十分麻烦
实现哨兵模式的配置其实是很麻烦的，里面有很多选择

Redis缓存穿透和雪崩

缓存穿透

概念

用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败，当用户很多的时候，缓存都没有命中，于是都去请求持久层数据库，这会给持久层数据库操作很大的压力，这时候就相当于出现了缓存穿透。

解决方案

布隆过滤器

布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力

缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源

该解决方案存在两个问题：

如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中会有很多空值的键
即使对控制设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

缓存击穿

量大，缓存过期

概述

注意和缓存穿透区别，缓存击穿是指一个key非常热点，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库。就像一堵墙凿开一个洞。

解决方案

设置热点数据永不过期

从缓存层面来看，没有设置过期时间，所以不会出现热点key过期后产生的问题

加互斥锁

分布式锁：使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可，这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。

缓存雪崩

概念

缓存雪崩，是指在某一时间段，缓存集中过期失效，Redis宕机

解决方案

Redis高可用

redis可能会挂，多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其是就是搭建集群。

限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量，比如对某个key只允许一个线程查询数据，其他线程等待。

数据预热

数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中，在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

windows启动Redis

Linux安装Redis

测试性能-benchmark

基础的知识

Redis是单线程的！

五大数据类型

Redis-Key

String(字符串)

List(列表)

Set(集合)

Hash(哈希)

Zset(有序集合)

三种特殊数据类型

geospatial地理位置

Hyperloglog

Bitmap

事务

Jreis

常用API

SpringBooot整合Jedis

Redis.conf

Redis持久化

RDB(Redis DataBase)

AOF(Append OnlyFile)

Redis发布订阅

Redis主从复制

环境配置

哨兵模式

Redis缓存穿透和雪崩

缓存穿透

缓存击穿

缓存雪崩

留下评论取消回复