Redis学习笔记

阅读数: 次 2023-01-15

文章导航

Redis学习笔记

redis数据类型

五种基本类型

string

keys * 查看所有的key
select + 数字选择数据库(redis有16个数据库)
flushall 删除所有数据
exists + key 判断某个key 是否存在
expire + key + time 设置某个key的过期时间单位是秒
setex + key + time + value 设置一个key的过期时间和值setex(expire )
ttl + key 查看key的过期时间还剩多少
del + key 删除 key
type + key 查看 key的数据类型
move + key + 数字把当前库的key转移的下表为数字的库中
append + key + value 在key后追加 value，如果 key不存在，就添加
strlen + key 获取key下value的长度
incr/decr + key key的value +/-1
incrby/decrby + key + 数字 key的value+/- 数字长度
getrange + key + startIndex + endIndex 查看下标为startIndex到end的key的值(查看所有的话为 0 -1)
setrange + key + index +value 将kye下标为index的值替换成value,如果value有两个，则替换两位
setnx + key + value 如果key不存在，key值为value，如果存在，则创建失败setnx(set if Not eXists)
mset + [key,value] 一次性赋多个值如 mset k1 v1 k2 v2
mget + key1 +.. 一次性获取多个值如 mget k1 k2 ..
msetnx 原子性操作，设置多个值时，如果有一个值存在，则其他的也不会被设置成功
getset + key + value 获取值然后设置值，如果不存在，则返回空并设置值,如果存在，则返回值并设置新的值

list

lpush + list+ element 将元素放入list中先进后出
lrange +list+sindex+eindex 取出list中下表为 sindex到eindex中的值
rpush 从右边(尾部)插入
lpop + list 将list左边第一个元素移除 rpop移除右边第一个
lindex +list+ index 通过下标获取
llen + list返回数组的长度
lrem + count + list 移除list中指定个数的list值如 lrem 2 one 移除2个one（如果count>0，从表头开始删除，如果count=0，删除所有，如果count<0，从尾部开始删）
ltrim + list+ sIndex + eIndex 获取list中下表为 sindex到eindex中的元素(删除不在区间的其他值)
rpoplpush + 原来数组 + 新数组将原来数组的最后一个元素移到新数组去，返回的值是原来数组的最后一个元素
lset + list +index+ value 将list中指定下标的值替换成value(如果list不存在会报错)
linsert + list +before/after + 指定值 + value 在list指定值的前/后插入value，如果指定值有多个，则会添加在第一个指定值的前或者后

应用场景

最新消息排行等功能(比如朋友圈的时间线)
消息队列

set

sadd + set + v1 v2 v3 向set中添加值（可一次性添加多个）
smembers + set 获取set中的所有值（无序不可重复）
sismember +set + value 判断set中是否包含指定的value值
scard + set 获取set中的元素个数
srem + set + key 删除set中的指定key，可一次性删除多个
srandmember +set (+ count) 在set中随机挑选一个(count 个)元素
spop +set (+count) 从set中随机弹出(删除)一个(count个)元素
smove +原来set + 新set + key 将指定的元素剪贴到新的set里
sdiff + set1 + set2 两个集合的差集(相比set1来说，如set1 有 abc，set2有bcd，返回结果为ab)
sinter +set1+set2 两个集合的交集
sunion + set1 +set2 两个集合的并集

应用场景

共同好友
利用唯一性,统计访问网站的所有独立ip
好友推荐时,根据tag求交集,大于某个阈值就可以推荐

hash

与string类似，hash更适合对象的存储

hset + hash + field + value 在一个hash中存入一个key-value
hget + hast + field 获取hash中某个field的值
hset + hash+ field + value 在hash中一次性插入多个field 和值如 hset hash1 f1 v1 f2 v2(如果field存在，则会覆盖之前的值)
mgetall + hash 获取hash中的所有键值对
mdel + hash + field1 + field2.. 从hash中删除一个或多个key-value
hlen + hash 查看hash中有个几个键值对(长度)
hexists + hash + field 判断hash中的filed是否存在
hkeys + hash 获取hash中所有的key
hvals + hash 获取hash中所有的value

zset

zadd + set + number + key + number + key 往set中添加值(需要加序号，可以一次添加多个)
zrangebyscore + set + 范围(如 -inf +inf,负无穷到正无穷) 给一个set按照序号从小到大排序(只有key没有值)
zrangebyscore set -inf +inf withscores 从小到大排序(显示key和value)
zrevrangebyscore + set + +inf + -inf 从大到小给set排序(ps：范围需要从大到小,与正序相反如：正无穷~负无穷)
zrevrang + set + 0 + -1 给set反向排序
zrem + set + key 移除set中key值
zcard + set 显示set的长度(有几个值)
zcount + set + num1 + num2 获取指定区间值的个数

应用场景

排行榜
带权重的消息队列

三大特殊类型

geospatial

地理位置, 底层是zset，所以可以用zset操作geo

geoadd + key +经度 + 维度 + 城市名 (可一次性添加多个) egg: geoadd china:city 116.40 39.90 beijing
geopos + key + city 获取城市经纬度 egg: geopos china:city beijing
geodist + key + city1 + city2 + 单位两地之间的直线距离
georadius + key + 经度 + 维度 + 数值 + 单位以经纬度为中心数值半径内的城市 egg:georadius china:city 110 30 100 km
georadius + key + 经度 + 维度 + 数值 + 单位 withcoord withdist withhash count 2 withcoord:带距离 withcoord:带经纬度 count:限制返回值的个数 egg:georadius china:city 110 30 10000 km withcoord withdist withhash count 2
georadiusbymember +key + 城市 + 数值 + 单位查询以城市(对象)为中心,数值半径内的对象 egg：georadiusbymember china:city beijing 10000 km
geohash + key + 城市返回 11位字符的GeoHash字符串，将二维的经纬度转换为字符串 egg:geohash china:city beijing
zrange china:city 0 -1 查询所有城市(zset的用法)
zrem china:city beijing 删除北京(zset的用法)

Hyperloglog

统计基数

pfadd + set + 元素1 + 元素2 + .. 往数据组添加元素，可一次性添加多个(不重复)
pfcount + set 返回数据组里的元素
pfmerge + newSet + set1 + set2 将set1和set2数据组合并成newSet

BitMaps

setbit + key + 位 +0/1
getbit + key + 位返回key中该位的值 0/1
bitcount + key +(start + end)key中的值为1的个数

事务

Redis事务的本质:一组命令的集合。一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行
==Redies事务没有隔离级别的概念==
==Redies单挑命令保证原子性，但是Redis事务不保证原子性==

Redies事务

开启事务(multi)
命令入队(…)
终止事务(discard,事务终止后，入队的命令也不会被执行)
执行事务(exec)

事务执行

127.0.0.1:6379> multi			#开启事务
OK
#命令入队
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec			#执行事务
1) OK
2) OK
3) "v2"
4) OK

问题类型

编译型错误(代码/命令有问题)，事务中所有命令都不会执行

127.0.0.1:6379> multi				#开启事务
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> getset k2			#错误的命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec				#执行命令报错
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k2  			#所有的命令都不会被执行
(nil)

运行时异常(如 1/0)，其他正常命令可以执行，错误的命令抛出异常

127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incr k1	
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> exec			#错误命令抛出异常，其他正常执行
1) (error) ERR value is not an integer or out of range
2) OK
3) "v2"

Redies监视器测试(可充当乐观锁)

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		#监视(开启事务后，另一个线程先修改了值，事务会执行失败，watch可以充当Redis的的乐观锁)
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby money 20
QUEUED
127.0.0.1:6379> incrby out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20

Jedis

1.导入对应的依赖

<dependencies>     
    <!--导入jedis的包-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.5.1</version>
    </dependency>
</dependencies>

2.编码测试

连接数据库

前提

连接外网首先有在redis.conf改几个设置
1.daemonize yes
2.注释 bind 127.0.0.1
3.protected-mode no
其次看一下自己防火墙对端口号开没开放
firewall-cmd --query-port=6379/tcp
如果是yes就是开放的,如果没有开放,则需要手动添加
firewall-cmd --zone=public --add-port=6379/tcp --permanent
然后重启防火墙
firewall-cmd --reload
然后 redis-server fconfig/redis.conf
redis-cli -h 自己外网端口号 -p 6379
最后ping一下如果pong就成功了

连接

public static void main(String[] args) {

       Jedis jedis = new Jedis("114.55.107.193",6379);

       System.out.println(jedis.ping());  #返回的结果是 pong 就代表连接成功了
 }

操作命令

java操作事务

public static void main(String[] args) {

        Jedis jedis = new Jedis("114.55.107.193", 6379);

        jedis.flushDB();
        //开启事务
        Transaction multi = jedis.multi();
        try{
            multi.lpush("list1","ele1","ele2");
            multi.lpush("list1","ele3");
            multi.lpop("list1");
           //执行事务
            multi.exec();
        }catch (Exception e){
            //如果报错，终止事务
            multi.discard();
            e.printStackTrace();
        }finally {
            System.out.println(jedis.lrange("list1", 0, -1));
            //关闭连接
            jedis.close();
        }
    }

断开连接

1	jedis.close();

SpringBoot整合

下载jar包

配置application文件

spring:
  redis:
    port: 6379     	#端口
    host: 114.55.107.193	#ip

连接测试

实际应用中，一般用 ObjectMapper 将对象序列化然后存入

如果 pojo（entity）实体类没有序列化（implements Serializable），直接将对象存入，则会报错

自定义redisTemplate

@Configuration
public class RedisConfig {

    //自定义redisTemplate
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {

        RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        /*
        * 配置具体的 序列化方法(只需要new一个序列化的方法对象，然后放入setDefaultSerializer中)
        * 序列化配置
        * */
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new 			Jackson2JsonRedisSerializer(Object.class);
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, 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;
    }
}

在使用自定义的redisTemplate时，需指定

1
2
3

@Autowired
@Qualifier("redisTemplate")
private RedisTemplate redisTemplate;

自定义 redis util工具类

类似 jdbc的 Helper，方便操作，不用在使用 redisTemplate.ops 方法操作

public class RedisUtils {  
  
  
    private RedisTemplate<String, Object> redisTemplate;  
      
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
        this.redisTemplate = redisTemplate;  
    }  
    //=============================common============================  
    /** 
     * 指定缓存失效时间 
     * @param key 键 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean expire(String key,long time){  
        try {  
            if(time>0){  
                redisTemplate.expire(key, time, TimeUnit.SECONDS);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 根据key 获取过期时间 
     * @param key 键 不能为null 
     * @return 时间(秒) 返回0代表为永久有效 
     */  
    public long getExpire(String key){  
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);  
    }  
      
    /** 
     * 判断key是否存在 
     * @param key 键 
     * @return true 存在 false不存在 
     */  
    public boolean hasKey(String key){  
        try {  
            return redisTemplate.hasKey(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 删除缓存 
     * @param key 可以传一个值 或多个 
     */  
    @SuppressWarnings("unchecked")  
    public void del(String ... key){  
        if(key!=null&&key.length>0){  
            if(key.length==1){  
                redisTemplate.delete(key[0]);  
            }else{  
                redisTemplate.delete(CollectionUtils.arrayToList(key));  
            }  
        }  
    }  
      
    //============================String=============================  
    /** 
     * 普通缓存获取 
     * @param key 键 
     * @return 值 
     */  
    public Object get(String key){  
        return key==null?null:redisTemplate.opsForValue().get(key);  
    }  
      
    /** 
     * 普通缓存放入 
     * @param key 键 
     * @param value 值 
     * @return true成功 false失败 
     */  
    public boolean set(String key,Object value) {  
         try {  
            redisTemplate.opsForValue().set(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
          
    }  
      
    /** 
     * 普通缓存放入并设置时间 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 
     * @return true成功 false 失败 
     */  
    public boolean set(String key,Object value,long time){  
        try {  
            if(time>0){  
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);  
            }else{  
                set(key, value);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 递增 
     * @param key 键 
     * @param by 要增加几(大于0) 
     * @return 
     */  
    public long incr(String key, long delta){    
        if(delta<0){  
            throw new RuntimeException("递增因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, delta);  
    }  
      
    /** 
     * 递减 
     * @param key 键 
     * @param by 要减少几(小于0) 
     * @return 
     */  
    public long decr(String key, long delta){    
        if(delta<0){  
            throw new RuntimeException("递减因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, -delta);    
    }    
      
    //================================Map=================================  
    /** 
     * HashGet 
     * @param key 键 不能为null 
     * @param item 项 不能为null 
     * @return 值 
     */  
    public Object hget(String key,String item){  
        return redisTemplate.opsForHash().get(key, item);  
    }  
      
    /** 
     * 获取hashKey对应的所有键值 
     * @param key 键 
     * @return 对应的多个键值 
     */  
    public Map<Object,Object> hmget(String key){  
        return redisTemplate.opsForHash().entries(key);  
    }  
      
    /** 
     * HashSet 
     * @param key 键 
     * @param map 对应多个键值 
     * @return true 成功 false 失败 
     */  
    public boolean hmset(String key, Map<String,Object> map){    
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * HashSet 并设置时间 
     * @param key 键 
     * @param map 对应多个键值 
     * @param time 时间(秒) 
     * @return true成功 false失败 
     */  
    public boolean hmset(String key, Map<String,Object> map, long time){    
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            if(time>0){  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     * @param key 键 
     * @param item 项 
     * @param value 值 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key,String item,Object value) {  
         try {  
            redisTemplate.opsForHash().put(key, item, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     * @param key 键 
     * @param item 项 
     * @param value 值 
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key,String item,Object value,long time) {  
         try {  
            redisTemplate.opsForHash().put(key, item, value);  
            if(time>0){  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 删除hash表中的值 
     * @param key 键 不能为null 
     * @param item 项 可以使多个 不能为null 
     */  
    public void hdel(String key, Object... item){    
        redisTemplate.opsForHash().delete(key,item);  
    }   
      
    /** 
     * 判断hash表中是否有该项的值 
     * @param key 键 不能为null 
     * @param item 项 不能为null 
     * @return true 存在 false不存在 
     */  
    public boolean hHasKey(String key, String item){  
        return redisTemplate.opsForHash().hasKey(key, item);  
    }   
      
    /** 
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回 
     * @param key 键 
     * @param item 项 
     * @param by 要增加几(大于0) 
     * @return 
     */  
    public double hincr(String key, String item,double by){    
        return redisTemplate.opsForHash().increment(key, item, by);  
    }  
      
    /** 
     * hash递减 
     * @param key 键 
     * @param item 项 
     * @param by 要减少记(小于0) 
     * @return 
     */  
    public double hdecr(String key, String item,double by){    
        return redisTemplate.opsForHash().increment(key, item,-by);    
    }    
      
    //============================set=============================  
    /** 
     * 根据key获取Set中的所有值 
     * @param key 键 
     * @return 
     */  
    public Set<Object> sGet(String key){  
        try {  
            return redisTemplate.opsForSet().members(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
      
    /** 
     * 根据value从一个set中查询,是否存在 
     * @param key 键 
     * @param value 值 
     * @return true 存在 false不存在 
     */  
    public boolean sHasKey(String key,Object value){  
        try {  
            return redisTemplate.opsForSet().isMember(key, value);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 将数据放入set缓存 
     * @param key 键 
     * @param values 值 可以是多个 
     * @return 成功个数 
     */  
    public long sSet(String key, Object...values) {  
        try {  
            return redisTemplate.opsForSet().add(key, values);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
      
    /** 
     * 将set数据放入缓存 
     * @param key 键 
     * @param time 时间(秒) 
     * @param values 值 可以是多个 
     * @return 成功个数 
     */  
    public long sSetAndTime(String key,long time,Object...values) {  
        try {  
            Long count = redisTemplate.opsForSet().add(key, values);  
            if(time>0) expire(key, time);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
      
    /** 
     * 获取set缓存的长度 
     * @param key 键 
     * @return 
     */  
    public long sGetSetSize(String key){  
        try {  
            return redisTemplate.opsForSet().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
      
    /** 
     * 移除值为value的 
     * @param key 键 
     * @param values 值 可以是多个 
     * @return 移除的个数 
     */  
    public long setRemove(String key, Object ...values) {  
        try {  
            Long count = redisTemplate.opsForSet().remove(key, values);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
    //===============================list=================================  
      
    /** 
     * 获取list缓存的内容 
     * @param key 键 
     * @param start 开始 
     * @param end 结束  0 到 -1代表所有值 
     * @return 
     */  
    public List<Object> lGet(String key,long start, long end){  
        try {  
            return redisTemplate.opsForList().range(key, start, end);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
      
    /** 
     * 获取list缓存的长度 
     * @param key 键 
     * @return 
     */  
    public long lGetListSize(String key){  
        try {  
            return redisTemplate.opsForList().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
      
    /** 
     * 通过索引 获取list中的值 
     * @param key 键 
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 
     * @return 
     */  
    public Object lGetIndex(String key,long index){  
        try {  
            return redisTemplate.opsForList().index(key, index);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
      
    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value, long time) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            if (time > 0) expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value, long time) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            if (time > 0) expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  
      
    /** 
     * 根据索引修改list中的某条数据 
     * @param key 键 
     * @param index 索引 
     * @param value 值 
     * @return 
     */  
    public boolean lUpdateIndex(String key, long index,Object value) {  
        try {  
            redisTemplate.opsForList().set(key, index, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }   
      
    /** 
     * 移除N个值为value  
     * @param key 键 
     * @param count 移除多少个 
     * @param value 值 
     * @return 移除的个数 
     */  
    public long lRemove(String key,long count,Object value) {  
        try {  
            Long remove = redisTemplate.opsForList().remove(key, count, value);  
            return remove;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }

redis.conf详解

单位

配置文件units单位对大小写不敏感

包含

类似于 import,include

网络

1
2
3

bind 127.0.0.1    #绑定的ip
protected-mode no #保护模式
port 6379 		  #端口号

GENERAL 通用

daemonize yes   #以守护线程的方式执行，默认是 no，需要手动更改为yes
pidfile /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	#数据库的数量
always-show-logo yes	#是否总是显示logo

SNAPSHOTTING 快照

持久化，在规定的时间内，达到规定的操作次数，则会持久化到文件 .rdb, .aof

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

# 900s内，至少有 1 个key进行了修改，就进行持久化操作
save 900 1
# 300s内，至少有 10 个key进行了修改，就进行持久化操作
save 300 10
# 60s内，至少有 10000 个key进行了修改，就进行持久化操作
save 60 10000

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

SECURITY 安全

1
2
3

config get requirepass  #获取数据库的密码
config set requirepass  123  #设置数据库密码 为 123(设置完之后，所有的操作会提示没有权限，需要登录才可)
auth 123 	#使用密码 123 进行登录

CLIENTS 客户端

maxclients 10000  #最大客户端连接数

maxmemory <bytes> #redis配置最大内存容量

maxmemory-policy noeviction		#内存到达上限后的处理策略
- noeviction：当内存使用达到阈值的时候，所有引起申请内存的命令会报错。
- allkeys-lru：在所有键中采用lru算法删除键，直到腾出足够内存为止。
- volatile-lru：在设置了过期时间的键中采用lru算法删除键，直到腾出足够内存为止。
- allkeys-random：在所有键中采用随机删除键，直到腾出足够内存为止。
- volatile-random：在设置了过期时间的键中随机删除键，直到腾出足够内存为止。
- volatile-ttl：在设置了过期时间的键空间中，具有更早过期时间的key优先移除。
#LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰

APPEND ONLY MODE aof配置

appendonly no		#默认不开启(rdb持久化方式可以适应的大部分场景，一般用不到 aof)
appendfilename "appendonly.aof"  #持久化的文件名字

# appendfsync always	#每次修改都会执行 sync，消耗资源
appendfsync everysec	#每秒执行一次 sync，可能会丢失 1s 的数据
# appendfsync no		#不执行 sync 操作，操作系统自己同步数据

redis持久化

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

RDB(Redis DataBase)

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

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

==rdb保存的文件是 dump.rdb== 在配置文件中 SNAPSHOTTING 快照中设置

dump.rdb 触发机制

save 条件满足的情况下，会自动触发 rdb规则
执行flushall 命令也会触发 rdb规则
退出也会产生rdb文件（kill 结束进程的话，redis会来不及保存）

恢复rdb文件

只需要将rdb文件放在redis启动目录即可，redis启动时会自动检测dump.rdb，恢复其中的数据
查看需要存在的位置

1
2
3

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

优点

适合大规模的数据恢复

缺点

需要一定的时间间隔进行操作(可以自定义为每次修改都同步，但是会消耗资源)，如果redis意外宕机，可能会丢失数据
fork进程时，会占用一定的内存空间

AOF(Append Only File)

以日志的形式记录每一个操作，将Redis执行过的所有指令记录下来（读操作不记录），只许追加文件但不可以改写文件，reids再启动时，会读取该文件重新构建数据

==Aof 保存的是 appendonly.aop 文件==

优点

每次修改都同步，保证了数据的完整性

缺点

相对于数据文件来说，aof远远大于rdb，修复速度慢与rdb

运行效率比rdb慢

Rewrite

是什么

Aof采用的是文件追加方式，文件会越来越大，为避免这种情况，新增了重写机制，当AOF文件大小超过规定的阈值时，Redis会启动AOF文件的内容压缩

重写原理

AOF文件持续增长过大时，会fork出新进程将文件重写（也就是先写零时文件最后再rename），遍历新进程的内存中数据，每条记录有一条set语句。重写aof文件的操作，没有读取旧的aof文件

触发机制

Redis会记录上一次重写时的AOF大小，默认配置是aof大小是上次rewrite后得大小且文件大于64M

redis发布订阅

Redis发布/订阅(pub/sub)是一种==消息通信模式==：发送者(pub)发送信息，订阅者(sub)接收消息。(微信，微博，哔哩哔哩有关注系统的)

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

发布订阅命令

订阅频道

subscribe + 频道名，订阅一个或多个频道，如果频道不存在也可订阅

127.0.0.1:6379> subscribe kuanshen
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "kuanshen"
3) (integer) 1

(频道操作者)向频道发送内容

publish + 频道名 + 内容

1 2	127.0.0.1:6379> publish kuanshen aaaaa (integer) 1

发送内容后，已订阅该频道的人都会接收到消息

127.0.0.1:6379> subscribe kuanshen
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "kuanshen"
3) (integer) 1
#接收到的消息
1) "message"		#消息
2) "kuanshen"		#发送消息的频道
3) "aaaaa"			#接收到的消息内容

原理

Redis是使用C实现的，通过分析Redis源码里的pubsub.c文件，了解发布和订阅机制的底层实现，籍此加深对Redis的理解。Redis通过PUBLISH、SUBSCRIBE 和PSUBSCRIBE等命令实现发布和订阅功能。

通过SUBSCRIBE命令订阅某频道后，redis-server 里维护了一个字典，字典的键就是一个个 channel , 而字典的值则是一个链表，链表中保存了所有订阅这个channel的客户端。SUBSCRIBE 命令的关键，就是将客户端添加到给定channel的订阅链表中。通过PUBLISH命令向订阅者发送消息，redis-server 会使用给定的频道作为键,在它所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表,遍历这个链表，将消息发布给所有订阅者。

Pub/Sub从字面上理解就是发布( Publish )与订阅( Subscribe )，在Redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。

redis主从复制

概念

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点master/leader)，后者称为从节点(slavefollower) ;==数据的复制是单向的，只能由主节点到从节点==。Master以写为主，Slave 以读为主。(一主多仆，只有允许有一个主机)

默认情况下，每台Redis服务器都是主节点;且一个主节点可以有多个从节点(或没有从节点) ,但一个从节点只能有一个主节点主从复制的作用主要包括:

1、数据冗余:主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。

2、故障恢复:当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复;实际上是一种服务的冗余。

3、负载均衡:在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务(即写Redis数据时应用连接主节点,读Redis数据时应用连接从节点) , 分担服务器负载;尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。

4、高可用基石:除了上述作用外，主从复制还是哨兵和集群能够实施的基础，因此主从复制是Redis高可用的基础

==主从复制，读写分离，主机用来写，从机只能读==

环境配置

只配置从库，主库不做配置(每连接一个reids，会默认为是一个主机Master)

127.0.0.1:6379> info replication		#查看当前库的状况
# Replication	
role:master								#Master主机
connected_slaves:0						#从机个数 0
master_replid:63c194a47b34e70c626c20779f7a958dd4c98b97
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:616
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:616

复制三个配置文件，修改对应的信息(将信息改为自己的),避免会造成文件覆盖

端口
pid名字
log文件名字
dump.rdb名字

修改完毕之后，启动三个redis服务器

配置为子节点

命令配置

暂时的，断开连接，再重连就会自动变回主机(默认)，==与主机共享的数据也会获取不到==

127.0.0.1:6380> slaveof 127.0.0.1 6370		#将当前redis配置为 子节点 salveof + ip + 端口号
OK
127.0.0.1:6380> info replication
# Replication
role:slave									#slave  从机
master_host:127.0.0.1						#主机ip
master_port:6379							#主机端口
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_repl_offset:0
master_link_down_since_seconds:1614416493
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:9316f9c9ee435be60ef27462979e60f1d44e778b
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

配置文件配置

删除注释，replicaof + 主机ip + 主机端口，重连之后，==与主机共享的数据不会丢失，依旧可以获取==

重新登录后，依然是从机

[root@xiaoxi bin]# redis-server fconfig/redis-1.conf 
[root@xiaoxi bin]# redis-cli -p 6380
127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_repl_offset:1
master_link_down_since_seconds:1614417299
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:8c539f4d1b5cbd315c9ce54c57802ac0277c7d98
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

主机写，从机读

主机可以写

127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> get k1
"v1"

从机只能读，不能写

127.0.0.1:6380> get k1
"v1"
127.0.0.1:6380> set k2 v2
(error) READONLY You can't write against a read only replica.

主要redis被配置为从机，则会实时共享主机的所有数据（成为该主机的从机前，主机存的数据也可以获取到）

复制原理

Slave启动成功连接到master后会发送一个synct同步命令

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

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

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

但是只要是重新连接master，一次完全同步(全量复制)将被自动执行

谋朝篡位(没有配置哨兵模式)

如果主机失去连接，从机可以使用slaveof no one把自己作为主机，其他节点可以连接到该最新的主节点(手动)，如果之前主节点修复了，也只能重新配置

哨兵模式

自动选老大（主节点）的模式

概述

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

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

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

配置

建一个 sentinel.conf 的哨兵配置文件
在配置文件写入核心配置语句

命令格式 sentinel monitor + 名字(可自定义) + 需要监视的redis的 ip + 端口号 + n(数字指的是主机挂了之后，从机需要得到哨兵 ‘n’ 张票之后，才可以自动设为主机)
sentinel monitor myredis 127.0.0.1 6379 1
启动哨兵

redis-sentinel fconfig/sentinel.conf

启动成功:

#监视的主机
21689:X 28 Feb 2021 00:25:59.227 # +monitor master myredis 127.0.0.1 6379 quorum 1
#监视的主机的从机
21689:X 28 Feb 2021 00:25:59.228 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:25:59.273 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379

主机宕机后

哨兵的日志

21689:X 28 Feb 2021 00:34:09.347 # +sdown master myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.347 # +odown master myredis 127.0.0.1 6379 #quorum 1/1
21689:X 28 Feb 2021 00:34:09.347 # +new-epoch 1
21689:X 28 Feb 2021 00:34:09.347 # +try-failover master myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.383 # +vote-for-leader a4c980cd2c769e10dc758af3df9f84c349573e50 1
21689:X 28 Feb 2021 00:34:09.383 # +elected-leader master myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.383 # +failover-state-select-slave master myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.440 # +selected-slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.441 * +failover-state-send-slaveof-noone slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.498 * +failover-state-wait-promotion slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.604 # +promoted-slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.604 # +failover-state-reconf-slaves master myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:09.650 * +slave-reconf-sent slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:10.641 * +slave-reconf-inprog slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:10.641 * +slave-reconf-done slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:10.731 # +failover-end master myredis 127.0.0.1 6379
21689:X 28 Feb 2021 00:34:10.732 # +switch-master myredis 127.0.0.1 6379 127.0.0.1 6381	 #投票6381 为主机
21689:X 28 Feb 2021 00:34:10.732 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6381
21689:X 28 Feb 2021 00:34:10.732 * +slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381
21689:X 28 Feb 2021 00:34:40.775 # +sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381

6381的replication信息

127.0.0.1:6381> info replication
# Replication
role:master						#由从机变为主机
connected_slaves:1
slave0:ip=127.0.0.1,port=6380,state=online,offset=32964,lag=1
master_replid:84176ff5d3adcfbf8ff0ded5a51f850fa43be575
master_replid2:ebaaf65cfdf89c6da8548a36e41a0dd393231559
master_repl_offset:32964
second_repl_offset:30788
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:57
repl_backlog_histlen:32908

当之前的主机(6379)重连后，会自动变为当前主机（6381）的从机

127.0.0.1:6379> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6381
master_link_status:up
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_repl_offset:52123
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:84176ff5d3adcfbf8ff0ded5a51f850fa43be575
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:52123
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:49947
repl_backlog_histlen:2177

优缺点

优点

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

缺点

集群容量一旦达到上限，Redis扩容会很困难
实现哨兵模式的配置麻烦，里面有很多选择

哨兵模式全部配置

# 哨兵sentinel实例运行的端口   默认是26379，如果有哨兵集群，我们还需要配置每个哨兵端口
port 26379

#哨兵sentinel的工作目录
dir /tmp

#哨兵 sentine1 监控的redis主节点的 ip port   
# master-name  ，可以自己命名的主节点名字 只能由字母A-Z、数字0-9、这三个字符"  .   -  _ "组成。
# quorum配置多少个sentine1哨兵统- -认为master主节点失联那么这时客观上认为主节点失联了
# sentine1 monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster   127.0.0.1   6379   2

#当在Redis实例中开启了requirepass foobared 授权密码这样所有连接kedis实例的客户端都要提供密码
#设置哨兵sentinel连接主从的密码注意必须为主从设置- - 样的验证密码
# sentine1 auth-pass <master-name> <password>
sentine1 auth-pass mymaster MySUPER--secret-0123passwOrd

#指定多少毫秒之后主节点没有应答哨兵sentine1 此时哨兵主观上认为主节点下线默认30秒
# sentinel down-after-mi 11i seconds <master-name> <mi 11iseconds>
sentine1 down-after-mi 11iseconds mymaster 30000

#这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行同步，这个数字越小，完成fai lover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为replication而 不可用。可以通过将这个值设为1来保证每次只有一个slave处于不能处理命令请求的状态。
# sentine1 paralle1-syncs <master-name> <numslaves>
sentine1 paralle1-syncs mymaster 1

#故障转移的超时时间failover-timeout 可以用在以下这些方面:
#1.同一个sentine1对同一 个master两次fai lover之间的间隔时间。
#2.当一个slave从一 个错误的master那里同步数据开始计算时间。直到s1ave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。
#4.当进行failover时，配置所有s1aves指向新的master所需的最大时间。不过，即使过了这个超时，slaves 依然会被正确配置为指向master,但是就不按parallel-syncs所配置的规则来了
#默认三分钟
# sentine1 failover-timeout <master-name> <milliseconds>
sentine1 fai lover-ti meout mymaster 180000

# SCRIPTS EXECUTION
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则:
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被-一个SIGKILL信号终止，之后重新执行。

#通知型脚本:当sentine1有任何警告级别的事件发生时(比如说redis实例的主观失效和客观失效等等)，将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等 方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一 个是事件的类型，一个是事件的描述。如果sentine1. conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentine1无法正常启动成功。
#通知脚本
# she11编程
# sentine1 notification-script <master-name> <script-path>
sentine1 notificati on-script mymaster /var/redis/notify. sh

#客户端重新配置主节点参数脚本
#当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
#以下参数将会在调用脚本时传给脚本: 
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
#目前<state>总是“failover",
# <role>是“Teader"或者"observer"中的-一个。
#参数from-ip， from-port， to-ip，to-port是用来和旧的master和新的master(即旧的s lave)通信的
#这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentine1 client-reconfig-script <master-name> <script-path>
sentine1 client-reconfig-script mymaster /var/redis/reconfig.sh #一般都是由运维来配置!

缓存穿透和雪崩

缓存穿透

概述

用户想要查询某个数据，但是redis内存数据库没有（也就是缓存没有命中），于是向持久层数据库进行查询，发现也没有，查询失败。当用户很多，缓存都没有命中（如：秒杀），都去请求了持久层数据库，给持久层数据库带来很带压力，这时候相当于出现了缓存穿透。

解决方案

布隆过滤器

布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式储存，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力（人话：在用户和缓存之间加入布隆过滤器，布隆过滤器会对用户查询的参数进行判断，判断缓存是否有这个参数）

缓存空对象

当存储层未命中后，及时返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据会从缓存中获取，保护了后端数据源（人话：用户查询数据（如：user1），缓存中没有这个数据，然后会查询数据库（如：mysql），数据库也没有这个数据，这时候就在缓存中加入该数据（user1），但是该数据的值是空）

缓存空对象存在的问题

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

缓存击穿

概述

缓存击穿，指的是一个key非常热点，大并发集中对这一个点访问，当该key过期失效的瞬间，持续的大并发就穿破缓存，直接请求数据库

解决方案

设置热点数据永不过期

从缓存层面上讲，没有设置过期时间，就不会出现key失效后产生的问题

加互斥锁

分布式锁：使用分布式锁，保证每个key同一时间只有一个线程去查询后端服务，其他线程没有获取分布式锁的的权限（人话：在缓存和持久层数据库之间加一把锁，只有一个线程可以获取锁，保证同一时间只有一个线程可以访问数据库）

缓存雪崩

概述

缓存雪崩是指在某一个时间段内，缓存集中过期（如：redis宕机/设置过期时间过于集中，如：双11)，或缓存服务器某个节点宕机或断网

缓存集中过期是自然形成的雪崩，数据库一般可以顶住压力。缓存服务器某个节点宕机或断网形成的雪崩可能会瞬间把数据库冲垮

解决方案

redis高可用性（搭建集群）

redis可能挂掉，那可以多增加几台服务器，搭建集群

限流降级

缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。

数据预热

在正式部署前，把可能的数据先访问一次，部分可能大量访问的数据就加载到缓存中，手动触发加载缓存不同的key，让缓存失效的时间尽量均匀

缓存和持久层数据库数据一致性

本文作者： 腾飞
本文链接： https://www.tengfei.eu.org/article/8eda3648.html
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！

redis数据类型

五种基本类型

string

list

set

hash

zset

三大特殊类型

geospatial

Hyperloglog

BitMaps

事务

Redies事务

问题类型

Jedis

1.导入对应的依赖

2.编码测试

连接数据库

SpringBoot整合

下载jar包

配置application文件

连接测试

自定义redisTemplate

自定义 redis util工具类

redis.conf详解

单位

包含

网络

SNAPSHOTTING 快照

SECURITY 安全

CLIENTS 客户端

APPEND ONLY MODE aof配置

redis持久化

RDB(Redis DataBase)

优点

缺点

AOF(Append Only File)

Rewrite

redis发布订阅

发布订阅命令

订阅频道

(频道操作者)向频道发送内容

原理

redis主从复制

概念

环境配置

配置为子节点

命令配置

配置文件配置

主机写，从机读

复制原理

哨兵模式

配置

命令格式 sentinel monitor + 名字(可自定义) + 需要监视的redis的 ip + 端口号 + n(数字指的是主机挂了之后，从机需要得到哨兵 ‘n’ 张票之后，才可以自动设为主机)

主机宕机后

优缺点

哨兵模式全部配置

缓存穿透和雪崩

缓存穿透

概述

解决方案

布隆过滤器

缓存空对象

缓存空对象存在的问题

缓存击穿

概述

解决方案

设置热点数据永不过期

加互斥锁

缓存雪崩

概述

解决方案

redis高可用性（搭建集群）

限流降级

数据预热

缓存和持久层数据库数据一致性