SpringBoot集成Redis缓存并实现初始化用户数据到Redis缓存
 
1、springboot集成Redis缓存
1.引入依赖
2.添加配置
3.测试是否成功
  
2、实现初始化用户数据到Redis缓存
1.listener监听类
2.实体表中需要序列化
3.findById示例
4.测试
 

 
1、springboot集成Redis缓存
 
1.引入依赖
 
在 pom.xml 中引入依赖（这里没有添加版本号是因为加了spring-boot-starter-parent，可以省略一些常用依赖的版本号）
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
 
2.添加配置
 
在 application.properties 中添加如下配置
 
### Redis缓存配置
### 默认Redis数据库为db0
spring.redis.database=0
### 服务器地址，localhost
spring.redis.host=localhost
### 链接端口，默认为6379
spring.redis.port=6379
### Redis密码默认为空
spring.redis.password=
 
3.测试是否成功
 
在测试类中加入如下代码，运行
 
    @Test
    public void testRedis(){
        //增
        redisTemplate.opsForValue().set("name","Test");
        String name = (String)redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }
 
运行截图：
 
 成功！
 
2、实现初始化用户数据到Redis缓存
 
之所以要把数据放到缓存中，是因为用户的数据属于变动不大的数据，适合放到缓存中，在应用需要获取用户数据时，可以直接到Redis获取，提高数据访问速度
 
1.listener监听类
 
package com.example.demojpa.listener;

import com.example.demojpa.model.PhoneType;
import com.example.demojpa.service.PhoneTypeService;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import java.util.List;

/*
* 监听器
* ye
* 2020.10.26
* */

@WebListener
public class RedisListener implements ServletContextListener {
    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private PhoneTypeService phoneTypeService;
    private static final String ALL_USER = "ALL_USER_LIST";

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent){
        //查询数据库所有用户
        List<PhoneType> phoneListenerList = phoneTypeService.findAll();
        System.out.println(phoneListenerList);
        //清除缓存中的用户数据
        redisTemplate.delete(ALL_USER);
        //将数据存放到Redis缓存中
        redisTemplate.opsForList().leftPushAll(ALL_USER,phoneListenerList);

        //真实项目中需要注解掉，查询所有的用户数据
        List<PhoneType> queryPhoneTypeList = redisTemplate.opsForList().range(ALL_USER,0,-1);
        System.out.println("缓存中目前的用户数：" + queryPhoneTypeList.size() + "人");

        System.out.println("ServletContext 上下文初始化");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent){
        System.out.println("ServletContext 上下文销毁");
    }
}

 
2.实体表中需要序列化
 
因为RedisTemplate默认使用jdkSerializationRedisSerializer，而StringRedisTemplate默认使用StringRedisSerializer。所以实体类需要实现序列化接口Serializable。代码如下：
 
@Entity
@Table(name="phone_type")
public class PhoneType implements Serializable {
   //省略代码
}
 
3.findById示例
 
我们首先是查找Redis缓存中的数据，有就返回，没有就查找数据库中的数据，有就更新缓存并返回数据，没有就返回没有。
 
具体方法如下：
 
    @Override
    public PhoneType findById(String id) {
        //step.1 查询Redis缓存中的所有数据
        List<PhoneType> phoneTypeList = redisTemplate.opsForList().range(ALL_USER,0,-1);
        if (phoneTypeList != null&&phoneTypeList.size() >0){
            for (PhoneType phoneType:phoneTypeList
            ) {
                if (phoneType.getType_id().equals(id)){
                    return phoneType;
                }
            }
        }

        //step.2 查询数据库中的数据
        PhoneType phoneType = phoneTypeRepository.findById(id).get();
        if (phoneType != null){
            //step.3 将数据插入到Redis缓存中
            redisTemplate.opsForList().leftPush(ALL_USER,phoneType);
        }

        return phoneType;
    }
 
4.测试
 
    @Test
    public void testFindById_redis(){
        Long redisUserSize = 0L;
        //查询id = 2 的数据，该数据存在于Redis缓存中
        PhoneType phoneType = phoneTypeService.findById("2");
        redisUserSize = redisTemplate.opsForList().size("ALL_USER_LIST");
        System.out.println("目前缓存中的用户数量为：" + redisUserSize);
        System.out.println("----> id: " + phoneType.getType_id() + "   name: " + phoneType.getType_name());

    }

 

 成功！

 
 
 
 
 
 
  
1、Mysql作为主存储服务器，Redis作为缓存，需要实时将需要缓存的mysql数据同步到Redis
 实现机制：
 如果对Mysql性能要求较高，可以解析Mysql binlog日志，然后将数据写入消息队列，再同步到Redis。此种方案需要熟悉binlog日志格式，相对复杂。
 如果性能要求不高，简单起见，可以使用Mysql UDF+触发器方式，将变化的数据写入消息队列，再同步到Redis。
 
  
2、Redis为主存储服务器，Mysql为从服务器，Mysql用作统计分析等场合，需要将Redis数据同步到Mysql（一般定时/准实时即可）
 实现机制：
 可以在Redis中创建多个zset，每个zset与mysql表对应，score用unix时间戳（整数）,zset用于存放近期insert/update/delete的记录。
 然后定期服务定时扫描zset，用时间戳排序，同时查询定时服务的同步日志（可以在Redis中用hash或其他结构存储），获取上一次同步操作以来insert/update/delete的记录，然后同步到mysql。
 至于分布式和读写分离，我理解是指Redis分布式、Mysql读写分离吧，参考一下Redis和Mysql的文档即可。
 
 

redis缓存雪崩
 
如果我们的缓存挂掉了，这意味着我们的全部请求都跑去数据库了。
 数据未加载到缓存中，或者缓存同一时间大面积的失效，从而导致所有请求都去查数据库，导致数据库CPU和内存负载过高，甚至宕机。
 
 我们都知道Redis不可能把所有的数据都缓存起来(内存昂贵且有限)，所以Redis需要对数据设置过期时间，并采用的是惰性删除+定期删除两种策略对过期键删除。
 
如果缓存数据设置的过期时间是相同的，并且Redis恰好将这部分数据全部删光了。这就会导致在这段时间内，这些缓存同时失效，全部请求到数据库中。
 
这就是缓存雪崩：Redis挂掉了，请求全部走数据库。
 
缓存雪崩如果发生了，很可能就把我们的数据库搞垮，导致整个服务瘫痪！
 
比如一个雪崩的简单过程：
 1、redis集群大面积故障
 
2、缓存失效，但依然大量请求访问缓存服务redis
 
3、redis大量失效后，大量请求转向到mysql数据库
 
4、mysql的调用量暴增，很快就扛不住了，甚至直接宕机
 
5、由于大量的应用服务依赖mysql和redis的服务，这个时候很快会演变成各服务器集群的雪崩，最后网站彻底崩溃。
 
如何预防缓存雪崩？
 在缓存的时候给过期时间加上一个随机值，这样就会大幅度的减少缓存在同一时间过期。
 
对于“Redis挂掉了，请求全部走数据库”这种情况，我们可以有以下的思路：
 
事发前：实现Redis的高可用(主从架构+Sentinel 或者Redis Cluster)，尽量避免Redis挂掉这种情况发生。
 
事发中：万一Redis真的挂了，我们可以设置本地缓存(ehcache)+限流(hystrix)，尽量避免我们的数据库被干掉(起码能保证我们的服务还是能正常工作的)
 
事发后：redis持久化，重启后自动从磁盘上加载数据，快速恢复缓存数据。
 
1.缓存的高可用性
 缓存层设计成高可用，防止缓存大面积故障。即使个别节点、个别机器、甚至是机房宕掉，依然可以提供服务，例如 Redis Sentinel 和 Redis Cluster 都实现了高可用。
 
2.缓存降级
 可以利用ehcache等本地缓存(暂时支持)，但主要还是对源服务访问进行限流、资源隔离（熔断）、降级等。
 当访问量剧增、服务出现问题仍然需要保证服务还是可用的。系统可以根据一些关键数据进行自动降级，也可以配置开关实现人工降级，这里会涉及到运维的配合。
 
降级的最终目的是保证核心服务可用，即使是有损的。
 比如推荐服务中，很多都是个性化的需求，假如个性化需求不能提供服务了，可以降级补充热点数据，不至于造成前端页面是个大空白。
 
在进行降级之前要对系统进行梳理，比如：哪些业务是核心(必须保证)，哪些业务可以容许暂时不提供服务(利用静态页面替换)等，以及配合服务器核心指标，来后设置整体预案，比如：
 
（1）一般：比如有些服务偶尔因为网络抖动或者服务正在上线而超时，可以自动降级；
 
（2）警告：有些服务在一段时间内成功率有波动（如在95~100%之间），可以自动降级或人工降级，并发送告警；
 
（3）错误：比如可用率低于90%，或者数据库连接池被打爆了，或者访问量突然猛增到系统能承受的最大阀值，此时可以根据情况自动降级或者人工降级；
 
（4）严重错误：比如因为特殊原因数据错误了，此时需要紧急人工降级。
 
3.Redis备份和快速预热
 
1)Redis数据备份和恢复
 
2)快速缓存预热
 
4.提前演练
 
最后，建议还是在项目上线前，演练缓存层宕掉后，应用以及后端的负载情况以及可能出现的问题，对高可用提前预演，提前发现问题。
 
缓存穿透
 
缓存穿透是指查询一个一定不存在的数据。由于缓存不命中，并且出于容错考虑，如果从数据库查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，失去了缓存的意义。
 
 缓存穿透是指查询一个一不存在的数据。例如：从缓存redis没有命中，需要从mysql数据库查询，查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，造成缓存穿透。
 
解决思路：
 由于请求的参数是不合法的(每次都请求不存在的参数)，于是我们可以使用布隆过滤器(BloomFilter)或者压缩filter提前拦截，不合法就不让这个请求到数据库层！
 
当我们从数据库找不到的时候，我们也将这个空对象设置到缓存里边去。下次再请求的时候，就可以从缓存里边获取了。
 
这种情况我们一般会将空对象设置一个较短的过期时间。
 
如果查询数据库也为空，直接设置一个默认值存放到缓存，这样第二次到缓冲中获取就有值了，而不会继续访问数据库。设置一个过期时间或者当有值的时候将缓存中的值替换掉即可。
 可以给key设置一些格式规则，然后查询之前先过滤掉不符合规则的Key。
 
缓存并发
 
这里的并发指的是多个redis的client同时set
 key引起的并发问题。其实redis自身就是单线程操作，多个client并发操作，按照先到先执行的原则，先到的先执行，其余的阻塞。当然，另外的解决方案是把redis.set操作放在队列中使其串行化，必须的一个一个执行。
 
缓存预热
 
缓存预热就是系统上线后，将相关的缓存数据直接加载到缓存系统。
 
这样就可以避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据！
 
解决思路：
 
1、直接写个缓存刷新页面，上线时手工操作下；
 
2、数据量不大，可以在项目启动的时候自动进行加载；
 
目的就是在系统上线前，将数据加载到缓存中。

场景：​​​​​​
 
redis缓存中的缓存过期了，但是还需要用到他，然而如果设置缓存为永不过期的话，数据会越堆越多，严重占用空间。所以需要对过期缓存进行监听。在缓存过期的时候进行处理。如果还需要用到就重新加载缓存，用不到了可以不用处理。解决了有用缓存过期的尴尬，又不会造成数据堆积。
 
过期事件通过Redis的订阅与发布功能（pub/sub）来进行分发。
 
 
 
配置文件
 
 
而对超时的监听呢，并不需要自己发布，只有修改配置文件redis.conf中的：notify-keyspace-events Ex，默认为notify-keyspace-events "" 
 
# K    键空间通知，以__keyspace@<db>__为前缀
 # E    键事件通知，以__keysevent@<db>__为前缀
 # g    del , expipre , rename 等类型无关的通用命令的通知, ...
 # $    String命令
 # l    List命令
 # s    Set命令
 # h    Hash命令
 # z    有序集合命令
 # x    过期事件（每次key过期时生成）
 # e    驱逐事件（当key在内存满了被清除时生成）
 # A    g$lshzxe的别名，因此”AKE”意味着所有的事件
  
 
 
 
 
监听器：
 
 
package connect.listen;

import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.Topic;

/**
 * @author wm
 */
public class KeyExpirationEvent5MessageListener extends KeyExpirationEventMessageListener {


    private static final Topic KEYEVENT5_EXPIRED_TOPIC = new PatternTopic("__keyevent@*__:expired");

    /**
     * Creates new {@link MessageListener} for {@code __keyevent@*__:expired} messages.
     *
     * @param listenerContainer must not be {@literal null}.
     */
    public KeyExpirationEvent5MessageListener(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }

    @Override
    public void doRegister(RedisMessageListenerContainer listenerContainer) {
        listenerContainer.addMessageListener(this, KEYEVENT5_EXPIRED_TOPIC);
    }
}
 
过期监听的管道默认是__keyevent@0__:expired，@后面的0表示第几个数据库，redis默认的数据库是0~15一共16个数据库，根据需求修改@后的数字。expired监听过期redis，可以换成*，监听所有。
 
 
 
配置bean：
 
 
   @Bean
    public RedisMessageListenerContainer container(JedisConnectionFactory jedisConnectionFactory, ApplicationContext context) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(jedisConnectionFactory);
        KeyExpirationEvent5MessageListener listener = new KeyExpirationEvent5MessageListener(container);
        listener.doRegister(container);
        listener.setApplicationEventPublisher(context);
        return container;
    }
 
 
 
监听：
 
 
@EventListener(classes = RedisKeyExpiredEvent.class)
    @Override
    public void event(RedisKeyExpiredEvent event) {
        String expiredKey = new String(event.getSource());
        System.out.println(expiredKey);
        //expiredKey监听到的过期redis，根据业务要求进行操作
}
 
启动项目就可以监听redis了。
 
 
 
本人菜鸟一只，如有大佬发现错误或有更好的方法，跪请不吝赐教！！！