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());

    }




成功！

把redis作为缓存使用已经是司空见惯，当redis中的数据量起来了以后你就得考虑以下几个问题：

(一)缓存和数据库间数据一致性问题

分布式环境下（单机就不用说了）非常容易出现缓存和数据库间的数据一致性问题，针对这一点的话，只能说，如果你的项目对缓存的要求是强一致性的，那么请不要使用缓存。我们只能采取合适的策略来降低缓存和数据库间数据不一致的概率，而无法保证两者间的强一致性。合适的策略包括 合适的缓存更新策略，更新数据库后要及时更新缓存、缓存失败时增加重试机制，例如MQ模式的消息队列。

(二)缓存穿透问题

现象：用户大量并发请求的数据(key)对应的数据在redis和数据库中都不存在，导致尽管数据不存在但还是每次都会进行查DB。

为什么key对应数据在缓存和db中不存在还会每次都进行DB查询呢？因为很多开发同学写的代码写的逻辑都是先从redis缓存中查一把，如果缓存中为空则从DB中查，如果DB中查到的数据不为空则设置到缓存并返回给接口。那么问题来了，如果从DB中查询的数据为空呢？？

解决方案：

从DB中查询出来数据为空，也进行空数据的缓存，避免DB数据为空也每次都进行数据库查询；
	
使用布隆过滤器，但是会增加一定的复杂度及存在一定的误判率；
bloomfilter就类似于一个hash set，用于快速判某个元素是否存在于集合中，其典型的应用场景就是快速判断一个key是否存在于某容器，不存在就直接返回。布隆过滤器的关键就在于hash算法和容器大小，下面先来简单的实现下看看效果，我这里用guava实现的布隆过滤器：

<dependencies>  
     <dependency>  
         <groupId>com.google.guava</groupId>  
         <artifactId>guava</artifactId>  
         <version>23.0</version>  
     </dependency>  
</dependencies>  

public class BloomFilterTest {

    private static final int capacity = 1000000;
    private static final int key = 999998;

    private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), capacity);

    static {
        for (int i = 0; i < capacity; i++) {
            bloomFilter.put(i);
        }
    }

    public static void main(String[] args) {
        /*返回计算机最精确的时间，单位微妙*/
        long start = System.nanoTime();

        if (bloomFilter.mightContain(key)) {
            System.out.println("成功过滤到" + key);
        }
        long end = System.nanoTime();
        System.out.println("布隆过滤器消耗时间:" + (end - start));
        int sum = 0;
        for (int i = capacity + 20000; i < capacity + 30000; i++) {
            if (bloomFilter.mightContain(i)) {
                sum = sum + 1;
            }
        }
        System.out.println("错判率为:" + sum);
    }
}

成功过滤到999998
布隆过滤器消耗时间:215518
错判率为:318

可以看到，100w个数据中只消耗了约0.2毫秒就匹配到了key，速度足够快。然后模拟了1w个不存在于布隆过滤器中的key，匹配错误率为318/10000，也就是说，出错率大概为3%，跟踪下BloomFilter的源码发现默认的容错率就是0.03：

public static <T> BloomFilter<T> create(Funnel<T> funnel, int expectedInsertions /* n */) {
  return create(funnel, expectedInsertions, 0.03); // FYI, for 3%, we always get 5 hash functions
}

我们可调用BloomFilter的这个方法显式的指定误判率：



private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), capacity,0.01);

我们断点跟踪下，误判率为0.02和默认的0.03时候的区别:





对比两个出错率可以发现，误判率为0.02时数组大小为8142363，0.03时为7298440，误判率降低了0.01，BloomFilter维护的数组大小也减少了843923，可见BloomFilter默认的误判率0.03是设计者权衡系统性能后得出的值。要注意的是，布隆过滤器不支持删除操作。用在这边解决缓存穿透问题就是：

public String getByKey(String key) {
    // 通过key获取value
    String value = redisService.get(key);
    if (StringUtil.isEmpty(value)) {
        if (bloomFilter.mightContain(key)) {
            value = userService.getById(key);
            redisService.set(key, value);
            return value;
        } else {
            return null;
        }
    }
    return value;
}

(三)缓存雪崩问题

现象：大量key同一时间点失效，同时又有大量请求打进来，导致流量直接打在DB上，造成DB不可用。

解决方案：

设置key永不失效（热点数据）；
	
设置key缓存失效时候尽可能错开；
	
使用多级缓存机制，比如同时使用redsi和memcache缓存，请求->redis->memcache->db；
	
购买第三方可靠性高的Redis云服务器；
 引申阅读: 使用quartz实现高级定制化定时任务（包含管理界面）

 推荐阅读:elastic search搜索引擎实战demo:https://github.com/simonsfan/springboot-quartz-demo，分支:feature_es

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、数据量不大，可以在项目启动的时候自动进行加载；
目的就是在系统上线前，将数据加载到缓存中。