SpringDataRedis

创建项目

SpringDataRedis--乐字节Java_第1张图片
SpringDataRedis--乐字节Java_第2张图片
SpringDataRedis--乐字节Java_第3张图片
SpringDataRedis--乐字节Java_第4张图片

添加依赖

  
   
   
 org.springframework.boot  
 spring-boot-starter-data-redis  
   
   
   
 org.apache.commons  
 commons-pool2  
   
   
   
 org.springframework.boot  
 spring-boot-starter-web  
   
   
   
 org.springframework.boot  
 spring-boot-starter-test  
 test

添加application.yml配置文件

spring:  
 redis:  
 \# Redis服务器地址  
 host: 192.168.10.100  
 \# Redis服务器端口  
 port: 6379  
 \# Redis服务器端口  
 password: root  
 \# Redis服务器端口  
 database: 0  
 \# 连接超时时间  
 timeout: 10000ms  
 lettuce:  
 pool:  
 \# 最大连接数，默认8  
 max-active: 1024  
 \# 最大连接阻塞等待时间，单位毫秒，默认-1ms  
 max-wait: 10000ms  
 \# 最大空闲连接，默认8  
 max-idle: 200  
 \# 最小空闲连接，默认0  
 min-idle: 5

Lettuce和Jedis的区别

Jedis是一个优秀的基于 Java 语言的 Redis 客户端，但是，其不足也很明显：Jedis在实现上是直接连接 Redis-Server，在多个线程间共享一个 Jedis实例时是线程不安全的，如果想要在多线程场景下使用 Jedis，需要使用连接池，每个线程都使用自己的 Jedis实例，当连接数量增多时，会消耗较多的物理资源。

Lettuce则完全克服了其线程不安全的缺点：Lettuce是基于 Netty的连接（StatefulRedisConnection），

Lettuce是一个可伸缩的线程安全的 Redis 客户端，支持同步、异步和响应式模式。多个线程可以共享一个连接实例，而不必担心多线程并发问题。它基于优秀 Netty NIO 框架构建，支持 Redis 的高级功能，如 Sentinel，集群，流水线，自动重新连接和 Redis 数据模型。

测试环境测试环境是否搭建成功

@RunWith(SpringRunner.class)  
@SpringBootTest(classes \= SpringDataRedisApplication.class)  
public class SpringDataRedisApplicationTests {  
​  
 @Autowired  
 private RedisTemplate redisTemplate;  
 @Autowired  
 private StringRedisTemplate stringRedisTemplate;  
​  
 @Test  
 public void initconn() {  
 ValueOperations ops \= stringRedisTemplate.opsForValue();  
 ops.set("username","lisi");  
 ValueOperations value \= redisTemplate.opsForValue();  
 value.set("name","wangwu");  
 System.out.println(ops.get("name"));  
 }  
}

自定义模板解决序列化问题

　默认情况下的模板 RedisTemplate，默认序列化使用的是JdkSerializationRedisSerializer，存储二进制字节码。这时需要自定义模板，当自定义模板后又想存储 String 字符串时，可以使StringRedisTemplate的方式，他们俩并不冲突。

序列化问题：

要把 domain object 做为 key-value 对保存在 redis 中，就必须要解决对象的序列化问题。Spring Data Redis给我们提供了一些现成的方案：

JdkSerializationRedisSerializer使用JDK提供的序列化功能。 优点是反序列化时不需要提供类型信息(class)，但缺点是序列化后的结果非常庞大，是JSON格式的5倍左右，这样就会消耗 Redis 服务器的大量内存。

Jackson2JsonRedisSerializer使用 Jackson 库将对象序列化为JSON字符串。优点是速度快，序列化后的字符串短小精悍。但缺点也非常致命，那就是此类的构造函数中有一个类型参数，必须提供要序列化对象的类型信息(.class对象)。通过查看源代码，发现其只在反序列化过程中用到了类型信息。

GenericJackson2JsonRedisSerializer通用型序列化，这种序列化方式不用自己手动指定对象的 Class。

@Configuration  
public class RedisConfig {  
 @Bean  
 public RedisTemplate redisTemplate(LettuceConnectionFactory redisConnectionFactory){  
 RedisTemplate redisTemplate \= new RedisTemplate<>();  
 //为string类型key设置序列器  
 redisTemplate.setKeySerializer(new StringRedisSerializer());  
 //为string类型value设置序列器  
 redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());  
 //为hash类型key设置序列器  
 redisTemplate.setHashKeySerializer(new StringRedisSerializer());  
 //为hash类型value设置序列器  
 redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());  
 redisTemplate.setConnectionFactory(redisConnectionFactory);  
 return redisTemplate;  
 }  
}

//序列化  
@Test  
public void testSerial(){  
 User user \= new User();  
 user.setId(1);  
 user.setUsername("张三");  
 user.setPassword("111");  
 ValueOperations value \= redisTemplate.opsForValue();  
 value.set("userInfo",user);  
 System.out.println(value.get("userInfo"));  
}

操作string

// 1.操作String  
@Test  
public void testString() {  
 ValueOperations valueOperations \= redisTemplate.opsForValue();  
​  
 // 添加一条数据  
 valueOperations.set("username", "zhangsan");  
 valueOperations.set("age", "18");  
​  
// redis中以层级关系、目录形式存储数据  
valueOperations.set("user:01", "lisi");  
valueOperations.set("user:02", "wangwu");  
​  
 // 添加多条数据  
 Map userMap \= new HashMap<>();  
 userMap.put("address", "bj");  
 userMap.put("sex", "1");  
 valueOperations.multiSet(userMap);  
​  
 // 获取一条数据  
 Object username \= valueOperations.get("username");  
 System.out.println(username);  
​  
​  
 // 获取多条数据  
 List keys \= new ArrayList<>();  
 keys.add("username");  
 keys.add("age");  
 keys.add("address");  
 keys.add("sex");  
 List resultList \= valueOperations.multiGet(keys);  
 for (Object str : resultList) {  
 System.out.println(str);  
 }  
​  
 // 删除  
 redisTemplate.delete("username");  
}

操作hash

// 2.操作Hash  
@Test  
public void testHash() {  
 HashOperations hashOperations \= redisTemplate.opsForHash();  
​  
 /\*  
 \* 添加一条数据  
 \*     参数一：redis的key  
 \*     参数二：hash的key  
 \*     参数三：hash的value  
 \*/  
 hashOperations.put("userInfo","name","lisi");  
​  
 // 添加多条数据  
 Map map \= new HashMap();  
 map.put("age", "20");  
 map.put("sex", "1");  
 hashOperations.putAll("userInfo", map);  
​  
 // 获取一条数据  
 String name \= hashOperations.get("userInfo", "name");  
 System.out.println(name);  
​  
 // 获取多条数据  
 List keys \= new ArrayList<>();  
 keys.add("age");  
 keys.add("sex");  
 List resultlist \=hashOperations.multiGet("userInfo", keys);  
 for (String str : resultlist) {  
 System.out.println(str);  
 }  
​  
 // 获取Hash类型所有的数据  
 Map userMap \= hashOperations.entries("userInfo");  
 for (Entry userInfo : userMap.entrySet()) {  
 System.out.println(userInfo.getKey() + "--" + userInfo.getValue());  
 }  
​  
 // 删除 用于删除hash类型数据  
 hashOperations.delete("userInfo", "name");  
}

操作list

// 3.操作list  
@Test  
public void testList() {  
ListOperations listOperations \= redisTemplate.opsForList();  
​  
// 左添加(上)  
//        listOperations.leftPush("students", "Wang Wu");  
//        listOperations.leftPush("students", "Li Si");  
​  
// 左添加(上) 把value值放到key对应列表中pivot值的左面，如果pivot值存在的话  
//listOperations.leftPush("students", "Wang Wu", "Li Si");  
​  
// 右添加(下)  
//        listOperations.rightPush("students", "Zhao Liu");  
​  
// 获取 start起始下标 end结束下标 包含关系  
List students \= listOperations.range("students", 0,2);  
for (Object stu : students) {  
System.out.println(stu);  
}  
​  
// 根据下标获取  
Object stu \= listOperations.index("students", 1);  
System.out.println(stu);  
​  
// 获取总条数  
Long total \= listOperations.size("students");  
System.out.println("总条数：" + total);  
​  
// 删除单条 删除列表中存储的列表中几个出现的Li Si。  
listOperations.remove("students", 1, "Li Si");  
​  
// 删除多条  
redisTemplate.delete("students");  
}

操作set

// 4.操作set-无序  
@Test  
public void testSet() {  
 SetOperations setOperations \= redisTemplate.opsForSet();  
 // 添加数据  
 String\[\] letters \= new String\[\]{"aaa", "bbb", "ccc", "ddd", "eee"};  
 //setOperations.add("letters", "aaa", "bbb", "ccc", "ddd", "eee");  
 setOperations.add("letters", letters);  
​  
 // 获取数据  
 Set let \= setOperations.members("letters");  
 for (Object letter: let) {  
 System.out.println(letter);  
 }  
​  
 // 删除  
 setOperations.remove("letters", "aaa", "bbb");  
}

操作sorted set

// 5.操作sorted set-有序  
@Test  
public void testSortedSet() {  
 ZSetOperations zSetOperations \= redisTemplate.opsForZSet();  
​  
 ZSetOperations.TypedTuple objectTypedTuple1 \=  
 new DefaultTypedTuple("zhangsan", 7D);  
 ZSetOperations.TypedTuple objectTypedTuple2 \=  
 new DefaultTypedTuple("lisi", 3D);  
 ZSetOperations.TypedTuple objectTypedTuple3 \=  
 new DefaultTypedTuple("wangwu", 5D);  
 ZSetOperations.TypedTuple objectTypedTuple4 \=  
 new DefaultTypedTuple("zhaoliu", 6D);  
 ZSetOperations.TypedTuple objectTypedTuple5 \=  
 new DefaultTypedTuple("tianqi", 2D);  
 Set> tuples \= new HashSet>();  
 tuples.add(objectTypedTuple1);  
 tuples.add(objectTypedTuple2);  
 tuples.add(objectTypedTuple3);  
 tuples.add(objectTypedTuple4);  
 tuples.add(objectTypedTuple5);  
​  
 // 添加数据  
 zSetOperations.add("score", tuples);  
​  
 // 获取数据  
 Set scores \= zSetOperations.range("score", 0, 4);  
 for (Object score: scores) {  
 System.out.println(score);  
 }  
​  
 // 获取总条数  
 Long total \= zSetOperations.size("score");  
 System.out.println("总条数：" + total);  
​  
 // 删除  
 zSetOperations.remove("score", "zhangsan", "lisi");  
}

获取所有key&删除

// 获取所有key  
@Test  
public void testAllKeys() {  
 // 当前库key的名称  
 Set keys \= redisTemplate.keys("\*");  
 for (String key: keys) {  
 System.out.println(key);  
 }  
}  
​  
// 删除  
@Test  
public void testDelete() {  
 // 删除 通用 适用于所有数据类型  
 redisTemplate.delete("score");  
}

设置key的失效时间

@Test  
public void testEx() {  
 ValueOperations valueOperations \= redisTemplate.opsForValue();  
 // 方法一：插入一条数据并设置失效时间  
 valueOperations.set("code", "abcd", 180, TimeUnit.SECONDS);  
 // 方法二：给已存在的key设置失效时间  
 boolean flag \= redisTemplate.expire("code", 180, TimeUnit.SECONDS);  
 // 获取指定key的失效时间  
 Long l \= redisTemplate.getExpire("code");  
}

![t0N4wn.png](https://s1.ax1x.com/2020/06/04/t0N4wn.png)

SpringDataRedis整合使用哨兵机制

application.yml

spring:  
 redis:  
 \# Redis服务器地址  
 host: 192.168.10.100  
 \# Redis服务器端口  
 port: 6379  
 \# Redis服务器端口  
 password: root  
 \# Redis服务器端口  
 database: 0  
 \# 连接超时时间  
 timeout: 10000ms  
 lettuce:  
 pool:  
 \# 最大连接数，默认8  
 max-active: 1024  
 \# 最大连接阻塞等待时间，单位毫秒，默认-1ms  
 max-wait: 10000ms  
 \# 最大空闲连接，默认8  
 max-idle: 200  
 \# 最小空闲连接，默认0  
 min-idle: 5  
 #哨兵模式  
 sentinel:  
 #主节点名称  
 master: mymaster  
 #节点  
 nodes:  192.168.10.100:26379,192.168.10.100:26380,192.168.10.100:26381

Bean注解配置

@Bean  
public RedisSentinelConfiguration redisSentinelConfiguration(){  
 RedisSentinelConfiguration sentinelConfig \= new RedisSentinelConfiguration()  
 // 主节点名称  
 .master("mymaster")  
 // 主从服务器地址  
 .sentinel("192.168.10.100", 26379)  
 .sentinel("192.168.10.100", 26380)  
 .sentinel("192.168.10.100", 26381);  
 // 设置密码  
 sentinelConfig.setPassword("root");  
 return sentinelConfig;  
}

如何应对缓存穿透、缓存击穿、缓存雪崩问题

Key的过期淘汰机制

　Redis可以对存储在Redis中的缓存数据设置过期时间，比如我们获取的短信验证码一般十分钟过期，我们这时候就需要在验证码存进Redis时添加一个key的过期时间，但是这里有一个需要格外注意的问题就是：并非key过期时间到了就一定会被Redis给删除。

定期删除

　Redis 默认是每隔 100ms 就随机抽取一些设置了过期时间的 Key，检查其是否过期，如果过期就删除。为什么是随机抽取而不是检查所有key？因为你如果设置的key成千上万，每100毫秒都将所有存在的key检查一遍，会给CPU带来比较大的压力。

惰性删除

　定期删除由于是随机抽取可能会导致很多过期 Key 到了过期时间并没有被删除。所以用户在从缓存获取数据的时候，redis会检查这个key是否过期了，如果过期就删除这个key。这时候就会在查询的时候将过期key从缓存中清除。

内存淘汰机制

　仅仅使用定期删除 + 惰性删除机制还是会留下一个严重的隐患：如果定期删除留下了很多已经过期的key，而且用户长时间都没有使用过这些过期key，导致过期key无法被惰性删除，从而导致过期key一直堆积在内存里，最终造成Redis内存块被消耗殆尽。那这个问题如何解决呢？这个时候Redis内存淘汰机制应运而生了。Redis内存淘汰机制提供了6种数据淘汰策略：

  • volatile-lru：从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。

  • volatile-ttl：从已设置过期时间的数据集中挑选将要过期的数据淘汰。

  • volatile-random：从已设置过期时间的数据集中任意选择数据淘汰。

  • allkeys-lru：当内存不足以容纳新写入数据时移除最近最少使用的key。

  • allkeys-random：从数据集中任意选择数据淘汰。

  • no-enviction（默认）：当内存不足以容纳新写入数据时，新写入操作会报错。

　一般情况下，推荐使用volatile-lru策略，对于配置信息等重要数据，不应该设置过期时间，这样Redis就永远不会淘汰这些重要数据。对于一般数据可以添加一个缓存时间，当数据失效则请求会从DB中获取并重新存入Redis中。

缓存击穿

　首先我们来看下请求是如何取到数据的：当接收到用户请求，首先先尝试从Redis缓存中获取到数据，如果缓存中能取到数据则直接返回结果，当缓存中不存在数据时从DB获取数据，如果数据库成功取到数据，则更新Redis，然后返回数据

SpringDataRedis--乐字节Java_第5张图片
定义：高并发的情况下，某个热门key突然过期，导致大量请求在Redis未找到缓存数据，进而全部去访问DB请求数据，引起DB压力瞬间增大。

解决方案：缓存击穿的情况下一般不容易造成DB的宕机，只是会造成对DB的周期性压力。对缓存击穿的解决方案一般可以这样：

  • Redis中的数据不设置过期时间，然后在缓存的对象上添加一个属性标识过期时间，每次获取到数据时，校验对象中的过期时间属性，如果数据即将过期，则异步发起一个线程主动更新缓存中的数据。但是这种方案可能会导致有些请求会拿到过期的值，就得看业务能否可以接受，

  • 如果要求数据必须是新数据，则最好的方案则为热点数据设置为永不过期，然后加一个互斥锁保证缓存的单线程写。

缓存穿透

定义：缓存穿透是指查询缓存和DB中都不存在的数据。比如通过id查询商品信息，id一般大于0，***者会故意传id为-1去查询，由于缓存是不命中则从DB中获取数据，这将会导致每次缓存都不命中数据导致每个请求都访问DB，造成缓存穿透。

解决方案：

  • 利用互斥锁，缓存失效的时候，先去获得锁，得到锁了，再去请求数据库。没得到锁，则休眠一段时间重试

  • 采用异步更新策略，无论key是否取到值，都直接返回。value值中维护一个缓存失效时间，缓存如果过期，异步起一个线程去读数据库，更新缓存。需要做缓存预热(项目启动前，先加载缓存)操作。

  • 提供一个能迅速判断请求是否有效的拦截机制，比如，利用布隆过滤器，内部维护一系列合法有效的key。迅速判断出，请求所携带的Key是否合法有效。如果不合法，则直接返回。

  • 如果从数据库查询的对象为空，也放入缓存，只是设定的缓存过期时间较短，比如设置为60秒。

缓存雪崩

定义：缓存中如果大量缓存在一段时间内集中过期了，这时候会发生大量的缓存击穿现象，所有的请求都落在了DB上，由于查询数据量巨大，引起DB压力过大甚至导致DB宕机。

解决方案：

  • 给缓存的失效时间，加上一个随机值，避免集体失效。如果Redis是集群部署，将热点数据均匀分布在不同的Redis库中也能避免全部失效的问题

  • 使用互斥锁，但是该方案吞吐量明显下降了。

  • 设置热点数据永远不过期。

  • 双缓存。我们有两个缓存，缓存A和缓存B。缓存A的失效时间为20分钟，缓存B不设失效时间。自己做缓存预热操作。然后细分以下几个小点

    1. 从缓存A读数据库，有则直接返回

    2. A没有数据，直接从B读数据，直接返回，并且异步启动一个更新线程。

    3. 更新线程同时更新缓存A和缓存B。