redis缓存实战讲解

1. 为什么要用 Redis

redis 是一个高性能的key-value内存数据库，它支持常用的5种数据结构：String字符串、Hash哈希表、List列表、Set集合、Zset有序集合 等数据类型。

Redis它解决了两个问题：

1. ==性能==

   通常数据库的连接操作，一般都要几十毫秒，而Redis的读操作一般仅需不到1毫秒。通常只要把数据库的数据缓存进redis，就能得到几十倍甚至上百倍的性能提升。

2. ==并发==

   在最大并发的情况下，所有的请求直接访问数据库，数据库会出现连接异常，甚至卡死在数据库中。为了解决大并发卡死的问题，一般的做法是采用Redis做一个缓冲，让请求先访问到redis，而不是直接访问到数据库。

2. Redis启动

1.简单启动

​ 进入redis 安装目录下，启动命令：./redis-server

​ 进入redis客户端交互，./redis-cli -h {host} -p {port} [-a pwd] 然后所有的操作都是在交互的操作下进行。

2.以守护进程启动(~为什么要以守护进程启动~)

​ 因为以方式一启动redis，则必须保证redis窗口必须打开，且无法进行其他操作。

​ ( 1 ) 修改redis.conf配置文件 将 daemonize no 修改为 daemonize yes

​ ( 2 ) 指定redis.conf配置文件启动 ./redis-server ./redis.conf

3. String 数据结构的字符串、整数、浮点操作

字符串操作

==SET语法：==

​ SET key value [NX] [EX <seconds>] [PX [millseconds]] 设置一对key value

必选参数说明：

• SET：命令
• key：待设置的key
• value：设置key的value

可选参数说明：

• NX：表示key不存在才设置，如果存在则返回null
• XX：表示key存在时才设置，如果不在村则返回null
• EX seconds：设置过期时间，过期时间精准为秒
• PX millseconds：设置过期时间，过期时间精准为毫秒

==SETNX语法：==

​ SETNX key value 所有参数必须为必选参数，设置一对key value，如果key存在，则设置失败，等同于SET key value NX

==SETEX语法：==

​ SETEX key value 所有参数为必选参数，设置一对key value，并设置过期时间，单位为秒，等同于 SET key value EX seconds

==PSETEX语法：==

​ PSETEX key value 所有参数为必选参数，设置一对key value，并设置过期时间，单位为毫秒，等同于PSETEX key value EX seconds

==MSET语法：==

​ MSET key1 value [key2 value2 key3 value3 ...] 批量存值，所有参数为必选，key value至少为一对，该命令的功能是设置多对key-value值。

==MGET语法：==

​ MGET key1 [key2 key3] 批量取值，所有参数为必选，key的值至少为一个，获取多个key 的value值，key值返回对应的value，不存在的返回null

==GETSET语法：==

​ GETSET key value1 先拿key查出value的值，然后再修改新值。所有参数为必选参数，既获取指定key的value，并设置key的新值为value1

==SETRANGE语法：==

​ SETRANGE key offset value 为某个key，修改偏移量offset后的值为value。所有参数为必选参数，设置指定key，偏移量offset后的值为value，影响范围为value 的长度，offset不能小于0

==GETRANGE语法：==

​ GETRANGE key start end 截取字符串，所有参数为必选参数，获取指定key的指定区间的value值，start、end可以为负数，如果为负数则反向取区间

==APPEND语法:==

​ APPEND key str 字符串拼接

==SUBSTR语法:==

​ SUBSTR key start end 截取字符串

---

整数操作

==INCR语法：==~应用场景—>点赞~

​ INCR key 计数器，所有参数为必选，指定key做加1操作，指定key对应的值必须为整型，否则返回错误，操作成功后返回操作后的值

==DECR语法：==

​ DECR key 所有参数为必选，指定key做减1操作，指定key对应的值必须为整型，否则返回错误，操作成功后返回操作后的值。为INCR的逆操作。

==INCRBY语法：==

​ INCRBY key data 加法。所有参数为必选参数，指定key做加data操作，指定key对应的值和data必须为整型，否则返回错误，操作成功后返回操作的值。

==DECRBY语法：==

​ DECRBY key data 减法。所有参数为必选参数，指定key做减data操作，指定key对应的值和data必须为整型，否则返回错误，操作成功后返回操作后的值。

---

浮点数操作

==INCRBYFLOAT语法：==

​ INCRBYFLOAT key num 增量。在原有key上加上浮点数。

4.SpringBoot 集成 Redis

📕 步骤一 : pom文件引入redis依赖jar包

• 引入swagger2、swagger-ui、mysql驱动、web、test、junit、lombok、连接池、redis等依赖jar包

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-redis</artifactId>
  4. <version>1.4.7.RELEASE</version>
  5. </dependency>

📕 步骤二 ：配置文件中加入redis配置信息

• ```yaml

  设置端口

  server:

  1. port: 9090

  指定mapper.xml的位置

  mybatis:

  1. mapper-locations: classpath*:/com/rikc/redis/mapper/xml/*.xml

  数据库驱动和ip

  spring:

  1. datasource:
  2. driverClassName: com.mysql.jdbc.Driver
  3. url: jdbc:mysql://localhost:3306/boot_user?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
  4. username: root
  5. password: jiejie01
  6. #redis配置信息
  7. redis:
  8. database: 0
  9. host: 192.168.150.132
  10. port: 6379
  11. password: jiejie01
  12. #swagger配置信息
  13. swagger2:
  14. enabled: true

  logging:

  1. level:
  2. com:
  3. rikc: debug

4. 📕 步骤三 : 使用redisTemplate操作数据进行增删改查
6. - ```java
7. package com.example.demo.service.impl;
9. import com.example.demo.entity.User;
10. import com.example.demo.mapper.UserMapper;
11. import com.example.demo.service.UserService;
12. import org.springframework.beans.factory.annotation.Autowired;
13. import org.springframework.cache.annotation.Cacheable;
14. import org.springframework.data.redis.core.RedisTemplate;
15. import org.springframework.data.redis.core.StringRedisTemplate;
16. import org.springframework.data.redis.core.ValueOperations;
17. import org.springframework.stereotype.Service;
18. import org.springframework.util.ObjectUtils;
20. import javax.annotation.Resource;
22. @Service
23. public class UserServiceImpl implements UserService {
25. private static final String CATCH_KEY_USER="user:";
27. @Resource
28. private UserMapper userMapper;
29. @Autowired
30. private RedisTemplate redisTemplate;
31. @Autowired
32. private StringRedisTemplate stringRedisTemplate;
34. public void createUser(User user) {
35. userMapper.insertSelective(user);
36. //缓存key
37. String key = CATCH_KEY_USER+user.getId();
38. //到数据库里面再重新捞出新数据出来,做缓存。
39. user = userMapper.selectByPrimaryKey(user.getId());
40. redisTemplate.opsForValue().set(key,user);
42. }
44. public void updateUser(User user1) {
45. userMapper.updateByPrimaryKeySelective(user1);
46. String key = CATCH_KEY_USER+user1.getId();
47. redisTemplate.opsForValue().set(key,user1);
48. }
51. public User findUserById(int id) {
52. ValueOperations valueOperations = redisTemplate.opsForValue();
53. User user = (User) valueOperations.get(CATCH_KEY_USER + id);
54. if(ObjectUtils.isEmpty(user)){
55. user = userMapper.selectByPrimaryKey(id);
56. valueOperations.set(CATCH_KEY_USER + id,user);
57. }
58. return user;
59. }
61. @Override
62. public void deletedUser(int id) {
64. }
65. }

1.问题搜集

1.为什么使用IDEA配置文件无法连接Redis。

​ 解决方案 ： 修改Redis配置文件redis.conf。 bind 0.0.0.0 即使Redis可以被外网连接，同时关闭linux防火墙 systemctl disable firewalld

2.redis存储数据为什么需要序列化？

​ 解决方案 ： 进redis的数据必须序列化 Serializable

3.优化Redis的序列化，修改为JSON形式。

​ 原因 : 因为redisTemplate默认使用的是JdkSerializationRedisSeralizer，会出现两个问题：

1. 被序列化的对象必须实现Serializable接口。
2. 被序列化会出现乱码，导致value值可读性差。

​ 解决方案 :

• 先把user实体类的序列化删除

• 创建redis的配置类RedisConfiguration

  1. package com.example.demo.config;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.data.redis.connection.RedisConnectionFactory;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  8. import org.springframework.data.redis.serializer.StringRedisSerializer;
  10. @Configuration
  11. public class RedisConfig {
  12. /**
  13. * 重写redis序列化方式,使用json方式：
  14. * 当我们的数据存储到Redis的时候，我们的键(key)和值(value)都是通过Spring提供的Serialize序列化到Redis的内存中。
  15. * RedisTemplate默认使用的是JdkSerializationRedisSerializer
  16. * StringRedisTemplate默认使用的是StringRedisSerializer。
  17. *
  18. * Spring Data JPA为我们提供了下面的Serializer:
  19. * GenericToStringSerializer、Jackson2JsonRedisSerializer、
  20. * JacksonJsonRedisSerializer、JdkSerializationRedisSerializer、
  21. * OxmSerializer、StringRedisSerializer。
  22. */
  23. @Bean
  24. public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
  25. RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
  26. redisTemplate.setConnectionFactory(redisConnectionFactory);
  27. //创建一个json的序列化对象
  28. GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  29. //设置value的序列化方式json
  30. redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  31. //设置key的序列化方式string
  32. redisTemplate.setKeySerializer(new StringRedisSerializer());
  33. //设置HashKey的序列化方式为String
  34. redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  35. //设置HashValue的序列化方式为Json
  36. redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  37. redisTemplate.afterPropertiesSet();
  38. return redisTemplate;
  39. }
  41. }

• flushdb 清空redis的旧数据，因为修改了序列化，老数据以及不能兼容了，必须清空。

• 往redis重写初始化数据。

5. SpringCache 集成 Redis

1. 为什么要使用SpringCache，它解决了什么问题。

   ​ 解决方案 : SpringCache 是Spring3.1版本发布出来的，它是对使用缓存进行封装和抽象，通过在方法上使用annotation注解就能拿到缓存结果。正是因为使用了annotation，所以它解决了业务代码和缓存代码的耦合度问题，即在不侵入业务代码的基础上让现有代码即可支持缓存，让开发人员无感知的使用了缓存。

   ​ ==(注意：对于redis的缓存，springcache只支持String，其他的Hash、List、Set、Zset都不支持，要特别注意。)==

2. SpringCache 集成 Redis

   • pom文件加入依赖

     1. <dependency>
     2. <groupId>org.springframework.boot</groupId>
     3. <artifactId>spring-boot-starter-cache</artifactId>
     4. </dependency>
     5. <dependency>
     6. <groupId>org.apache.commons</groupId>
     7. <artifactId>commons-pool2</artifactId>
     8. <version>2.6.2</version>
     9. </dependency>
     10. <dependency>
     11. <groupId>org.springframework.boot</groupId>
     12. <artifactId>spring-boot-starter-data-redis</artifactId>
     13. </dependency>

   • 配置文件，加入redis配置信息

     1. spring.redis.database=0
     2. spring.redis.host=192.168.150.132
     3. spring.redis.port=6379
     4. spring.redis.password=jiejie01
     5. # 连接池最大连接数(使用负数表示没有限制)
     6. spring.redis.lettuce.pool.max-active=8
     7. # 连接池最大阻塞等待时间
     8. spring.redis.lettuce.pool.max-wait=-1ms
     9. # 连接池中的最大空闲连接 8
     10. spring.redis.lettuce.pool.max-idle=8
     11. # 连接池中的最小空闲连接
     12. spring.redis.lettuce.pool.min-idle=0
     13. # 连接超时时间(毫秒)
     14. spring.redis.timeout=5000ms

   • 开启缓存配置，设置序列化

     重点是 @EnableCaching

     1. @Configuration
     2. @EnableCaching
     3. public class RedisConfig {
     5. @Primary
     6. @Bean
     7. public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
     8. RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
     9. redisCacheConfiguration = redisCacheConfiguration
     10. //设置缓存的默认超时时间：30分钟
     11. .entryTtl(Duration.ofMinutes(30L))
     12. //如果是空值,不缓存
     13. .disableCachingNullValues()
     14. //设置key序列化器
     15. .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerialize()))
     16. //设置value序列化器
     17. .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerialize()));
     18. return RedisCacheManager
     19. .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
     20. .cacheDefaults(redisCacheConfiguration)
     21. .build();
     22. }
     24. /**
     25. * key序列化器
     26. * @return
     27. */
     28. private RedisSerializer<String> keySerialize(){
     29. return new StringRedisSerializer();
     30. }
     32. /**
     33. * value序列化器
     34. * @return
     35. */
     36. private RedisSerializer<Object> valueSerialize(){
     37. return new GenericJackson2JsonRedisSerializer();
     38. }
     40. }

   • 使用注解进行业务开发

     ```java
     package com.example.demo.service.impl;

     import com.example.demo.entity.User;
     import com.example.demo.mapper.UserMapper;
     import com.example.demo.service.UserService;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.cache.annotation.CacheEvict;
     import org.springframework.cache.annotation.CachePut;
     import org.springframework.cache.annotation.Cacheable;
     import org.springframework.data.redis.core.RedisTemplate;
     import org.springframework.data.redis.core.StringRedisTemplate;
     import org.springframework.data.redis.core.ValueOperations;
     import org.springframework.stereotype.Service;
     import org.springframework.util.ObjectUtils;

     import javax.annotation.Resource;

     @Service
     @CacheConfig(cacheNames = {“user”})
     public class UserServiceImpl implements UserService {

     1. private static final String CATCH_KEY_USER="user:";
     3. @Resource
     4. private UserMapper userMapper;
     5. @Autowired
     6. private RedisTemplate redisTemplate;
     7. @Autowired
     8. private StringRedisTemplate stringRedisTemplate;
     10. public void createUser(User user) {
     11. userMapper.insertSelective(user);
     12. //缓存key
     13. String key = CATCH_KEY_USER+user.getId();
     14. //到数据库里面再重新捞出新数据出来,做缓存。
     15. user = userMapper.selectByPrimaryKey(user.getId());
     16. redisTemplate.opsForValue().set(key,user);
     18. }
     19. @CachePut(key = "#user1.id")
     20. public User updateUser(User user1) {
     21. userMapper.updateByPrimaryKeySelective(user1);
     22. return userMapper.selectByPrimaryKey(user1.getId());
     23. }

1. @Cacheable(key = "#id")
2. public User findUserById(Integer id) {
3. return userMapper.selectByPrimaryKey(id);
4. }
6. @CacheEvict(key = "#id")
7. public void deletedUser(Integer id) {
8. userMapper.deleteByPrimaryKey(id);
9. }
10. }
12. ```

• SpringCache 常用注解

  ==@CacheConfig==

  🌳 @CacheConfig(cacheNames={“user”})是类级别的注解，统一该类的所有缓存注解前缀。前缀名称为 user::

  ==@Cacheable==

  🌳 @Cacheable(key = “#id”[,cacheNames = {“user”}]) 是方法级别的注解，用于将方法的结果缓存起来。key的结果为 user::id 。方法执行时，先从缓存中读取数据，如果缓存中没有数据，再执行方法体，并将结果存储到缓存中。

  <u>注意事项 ：@CacheConfig 一般配合 @Cacheable 一起使用。</u>

  <u>调用方法时传入id = 100,那么redis对应的key = user::100,value通过采用GenericJackson2JsonRedisSerializer序列化为json</u>

1. ==@CachePut==
3. 🌳 @CachePut是方法级别的注解，一般用于更新缓存。
5. ```java
6. @CachePut(key = "#user1.id")
7. public User updateUser(User user1) {
8. userMapper.updateByPrimaryKeySelective(user1);
9. return userMapper.selectByPrimaryKey(user1.getId());
10. }
11. ```
13. 以上方法被调用时，先执行方法体，然后SpringCache通过返回更新缓存，即key = "user1.id",value = User
15. ==@CacheEvict==
17. 🌳 @CacheEvict是方法级别的注解，用于删除缓存。当方法被调用时，先执行方法体，再通过方法参数删除缓存。
19. ​

1. SpringCache的大坑小坑

   1. 对于Redis的缓存，SpringCache只支持String，其他的Hash、List、Set、ZSet都不支持。所以其他类型只能使用RedisTemplate。
   2. 对于多表查询的数据缓存，springcache是不支持的，对于多表的整体缓存，只能用redisTemplate。

6. 微信文章阅读量场景及解决方案

:name_badge: 微信文章阅读量场景场景介绍:

​ 在微信公众号里面的文章，每个用户阅读一遍文章，该篇文章的阅读量就会加1。对于这种并发量大的场景，不可能采用数据库来做计算，通常都是使用redis的incr命令来实现。

:name_badge: 微信文章的阅读计数量原理：redis INCR命令

​ ==INCR命令==，它的全称是increment，用途就是计数器。

​ 每次执行一次INCR命令，都将key的value值自动加1。

​ 如果key不存在，那么key的值初始化为0，然后再执行INCR命令。

​ :name_badge: 简单demo测试

1. @Test
2. public void test4(){
3. Integer id = 1003;
4. String key = "article:"+id;
5. long n = stringRedisTemplate.opsForValue().increment(key);
6. log.info("key={},阅读量为{}",key,n);
7. }

​ :name_badge: 技术缺陷

​ 需要频繁修改redis，耗费CPU，高并发修改会导致redis CPU 100%

7. Hash 数据结构:存储Java对象

1. 什么是redis的hash数据结构

​ ==redis的hash数据结构==,其实就是string的升级版，它把string数据结构的key-value中的value升级为hash(和java中的hash一样的结构)。等同于 Map<String,HashMap<String,String>> hash = new HashMap();

​ 每个hash的存储大小 ：可以存储 2 的(32-1)方的键值对(40多亿)

2. redis的Hash结构经典场景：存储Java对象

把一个Product对象，存储进redis的hash结构。

1. @Data
2. public class Product {
3. //商品id
4. private long id;
5. //商品名称
6. private String name;
7. //商品价格
8. private Integer price;
9. //商品详情
10. private String detail;
11. }

==HSET Key field value语法：==

​ hset key field value 将哈希表 key 中的字段field的值设为value。

==HGET key field语法：==

​ hget key field 获取存储在哈希表中指定字段的值。

==HMSET key field value1 [field2 value2…]语法：==

​ hmset key field value1 field2 value2... 同时将多个field-value[阈 - 值]设置到哈希表key中。

==HMGET key field1 [field2 field3…]语法：==

​ hmget key field1 field2 field3... 获取所有给定字段的值。

==HKEY key语法：==

​ HKEY key 获取指定hash中所有value值

==HVALS key语法：==

​ hvals key 获取指定hash中所有value值。

==HGETALL key语法：==

​ hgetall key 获取指定hash中所有field value值

==HLEN key语法：==

​ hlen key 获取指定hash中元素的个数

==HINCRBY key field data (整形)语法：==

​ hincrby key field data (整形) 给指定field对应的value值加上data数值。

==HINCRBYFLOAT key field data (浮点型)语法：==

​ HINCRBYFLOAT key field data(浮点型) 给指定field对应的value 值加上data 数值

==HEXISTS key field语法：==

​ hexists key field 检查指定的field是否存在

==HDEL key field1 [field2、field3]语法：==

​ hdel key field1 field2 field3... 删除一个或多个哈希字段

3.String和Hash的不同应用场景

📕 Redis存储Java对象，一般是String或Hash两种。那么到底什么时候用String？什么时候用Hash?

​ 解决方案 :

• String的存储通常用在频繁读操作，它的存储格式是json，即把java对象转换成json，然后存入redis中

• Hash的存储场景应用在频繁写操作。即，当对象的某个属性值频繁修改时，不适用string+json的数据结构，因为不灵活，每次修改都要把整个对象转存为json存储。

  如果采用hash，就可以针对某个属性单独修改，不用序列号去修改整个对象。例如:商品的库存、价格、关注数、评价数经常变动时，就使用存储hash结果。

8. 京东购物车实战

:taco: 京东购物车多种场景分析 ：

1. 先登录京东账号，清空以前购物车，然后添加一件商品A，保证你的购物车只有一件商品A。
2. 退出登录，购物车添加商品B，然后关闭浏览器再打开（请问购物车的商品B是否存在？）
3. 再次登录你的京东账号。(请问:你的购物车有几件商品？)

:taco: 图解分析：双11高并发的京东购物车技术实现

• 

• 

• 

:taco: 购物车的经典redis场景

1. 往购物车中添加两件商品，采用hash数据结果。key = cart：user：用户id

   1. hset cart:user:1000 101 1
   2. hset cart:user:1000 102 2
   3. hgetall cart:user:1000
   4. ## 结果
   5. 1)"101"
   6. 2）"1"
   7. 3）"102"
   8. 4）"2"

1. 修改购物车的数据，为某件商品添加数量

   1. hincrby cart:user:1000 101 1
   2. hincrby cart:user:1000 102 200
   3. hgetall cart:user:1000
   4. ## 结果
   5. 1)"101"
   6. 2)"2"
   7. 3)"102"
   8. 4)"202"

2. 统计购物车有多少种商品

   1. hlen cart:user:1000
   2. ## 结果
   3. (integer) 2

3. 删除购物车某件商品

   1. hdel cart:user:1000 101
   2. ## 结果
   3. (integer) 1

:taco: SpringDataRedis代码实现

• SpringBoot+redis实现登录用户购物车功能

  ```java

  1. /**
  2. * 添加购物车
  3. * @param obj
  4. */
  5. @PostMapping("/addCart")
  6. public void addCart(Cart obj) {
  7. try {
  8. String key = CART_KEY + obj.getUserId();
  9. Boolean hashKey = redisTemplate.opsForHash().getOperations().hasKey(key);
  10. //存在
  11. if(hashKey){
  12. redisTemplate.opsForHash().put(key,obj.getProductId(),obj.getAmount());
  13. }else{
  14. redisTemplate.opsForHash().put(key,obj.getProductId(),obj.getAmount());
  15. redisTemplate.expire(key,90, TimeUnit.DAYS);
  16. }
  17. //TOOD 发rabbitmq出去
  18. }catch (Exception e){
  19. log.error(e.getMessage());
  20. }
  21. }
  23. /**
  24. * 修改购物车
  25. * @param obj
  26. */
  27. @PostMapping("/updateCart")
  28. public void updateCart(Cart obj){
  29. String key = CART_KEY+obj.getProductId();
  30. redisTemplate.opsForHash().put(key,obj.getProductId(),obj.getAmount());
  31. }
  33. /**
  34. * 查看购物车
  35. * @param userId
  36. * @return
  37. */
  38. @PostMapping("/findAll")
  39. public CartPage findAll(String userId){
  40. Long size = redisTemplate.opsForHash().size(CART_KEY+userId);

1. Map<String,Integer> entries = redisTemplate.opsForHash().entries(userId);
2. List<Cart> cartList = new ArrayList<>();
3. for(Map.Entry<String,Integer> entry:entries.entrySet()){
4. Cart cart = new Cart();
5. cart.setUserId(userId);
6. cart.setProductId(entry.getKey());
7. cart.setAmount(String.valueOf(entry.getValue()));
8. cartList.add(cart);
9. }
10. CartPage cartPage = new CartPage();
11. cartPage.setCartList(cartList);
12. cartPage.setCount(size);
13. return cartPage;
14. }
16. /**
17. * 删除购物车
18. * @param userId
19. * @param productId
20. */
21. @PostMapping("/del")
22. public void delCart(Long userId,Long productId){
23. String key = CART_KEY+userId;
24. redisTemplate.opsForHash().delete(key,productId.toString());
25. //TOOD 发rabbitmq出去
26. }

2. - SpringBoot+Redis+Cookies实现未登录用户的购物车
4. ```java
5. @RestController
6. public class CookieCartController {
7. @Autowired
8. private HttpServletResponse response;
9. @Autowired
10. private HttpServletRequest request;
11. @Autowired
12. private IdGenerator idGenerator;
13. @Autowired
14. private RedisTemplate redisTemplate;
16. public static final String COOKIE_KEY = "cart:cookie";
18. /**
19. * 添加购物车
20. * @param obj
21. */
22. @PostMapping("/addCart")
23. public void addCart(CookieCart obj){
24. String cartId = getCookieCartId();
25. String key = COOKIE_KEY+cartId;
26. Boolean hashKey = redisTemplate.opsForHash().getOperations().hasKey(key);
27. if(hashKey){
28. redisTemplate.opsForHash().put(key,obj.getProductId(),obj.getAmount());
29. }else{
30. redisTemplate.opsForHash().put(key,obj.getProductId(),obj.getAmount());
31. redisTemplate.expire(key,90, TimeUnit.DAYS);
32. }
33. }
35. /**
36. * 更新购物车
37. * @param obj
38. */
39. @PostMapping("/updateCart")
40. public void updateCart(CookieCart obj){
41. String cartId = getCookieCartId();
42. String key = COOKIE_KEY+cartId;
43. redisTemplate.opsForHash().put(key,obj.getProductId(),obj.getAmount());
44. }
46. /**
47. * 删除购物车
48. */
49. @PostMapping("/delCart")
50. public void delCart(Long productId){
51. String cartId = getCookieCartId();
52. String key = COOKIE_KEY+cartId;
53. redisTemplate.opsForHash().delete(key,productId.toString());
54. }
55. /**
56. * 查看购物车
57. */
58. @PostMapping("/findAll")
59. public CartPage findAll(){
60. String cartId = getCookieCartId();
61. String key = COOKIE_KEY+cartId;
62. CartPage cartPages = new CartPage();
63. List<Cart> cartPage = new ArrayList<>();
65. Long size = redisTemplate.opsForHash().size(key);
67. Map<String,Integer> entries = redisTemplate.opsForHash().entries(key);
68. for(Map.Entry<String,Integer> entry: entries.entrySet()){
69. Cart cart = new Cart();
70. cart.setProductId(entry.getKey());
71. cart.setAmount(String.valueOf(entry.getValue()));
72. cartPage.add(cart);
73. }
74. cartPages.setCartList(cartPage);
75. return cartPages;
76. }
79. private String getCookieCartId(){
80. Cookie[] cookies = request.getCookies();
81. if (cookies!=null){
82. for (Cookie cookie:cookies){
83. if (cookie.getName().equals("cartId")){
84. return cookie.getValue();
85. }
86. }
87. }
88. long id = idGenerator.incrementId();
89. Cookie cookie = new Cookie("cartId",String.valueOf(id));
90. response.addCookie(cookie);
91. return id+"";
92. }
93. }
95. @Service
96. public class IdGenerator {
98. @Autowired
99. private StringRedisTemplate redisTemplate;
101. private static final String ID_KEY = "id:generator:cart";
103. /**
104. * 生成唯一Id
105. * @return
106. */
107. public long incrementId(){
108. return redisTemplate.opsForValue().increment(ID_KEY);
109. }
111. }

• 合并登录用户和未登录用户的购物车

  1. @PostMapping("/mergeCart")
  2. public void mergeCart(Long userId){
  3. //第一步提取未登录用户的cookie的购物车数据
  4. String cartId = getCookieCartId();
  5. String keyCookie = COOKIE_KEY+cartId;
  6. Map<String,Integer> map = redisTemplate.opsForHash().entries(keyCookie);
  8. //第二步 把cookie中的购物车合并到登录用户的购物车
  9. String keyUser = "cart:user:"+userId;
  10. redisTemplate.opsForHash().putAll(keyUser,map);
  12. //第三步，删除redis未登录用户的cookie的购物车数据
  13. redisTemplate.delete(keyCookie);
  15. //第四步，删除未登录用户的cookie的cartId
  16. Cookie cookie = new Cookie("cartId",null);
  17. cookie.setMaxAge(0);
  18. response.addCookie(cookie);
  19. }
  20. zuoyong

9.Redis解决分布式系统的session不一致性问题

1. Session有什么作用

​ Session是客户端与服务端通讯会话跟踪技术，==服务端与客户端保持整个通讯的会话基本信息。==

​ 客户端在第一次访问服务端的时候，服务端会响应一个sesssionId并且把它存储到本地cookie中。在之后的访问会将cookie中的sessionId放入到请求头去访问服务器。如果通过这个sessionId没有找到对应的数据，那么服务器会创建一个新的sesssionId响应给客户端。

2. 分布式Session有什么问题？

• 

• 

3.优雅的设计session一致性，低耦合

• UserController session中获取或存放用户信息

  1. @RequestMapping("/login")
  2. public String login(HttpServletRequest request){
  3. String username = request.getParameter("username");
  4. String password = request.getParameter("password");
  5. HttpSession session = request.getSession();
  7. session.setAttribute("username",username);
  8. session.setAttribute("password",password);
  10. return "login successful";
  11. }
  12. @PostMapping("/queryUserInfo")
  13. public String queryUserInfo(HttpServletRequest request){
  14. HttpSession session = request.getSession();
  16. String username = (String)session.getAttribute("username");
  17. String password = (String)session.getAttribute("password");
  19. return "username"+username+",password="+password;
  20. }
  21. }

• 自定义HttpServletSession对象

  ```java
  package com.example.demo.filter;

import com.alibaba.fastjson.JSONObject;
import org.json.JSONException;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

import javax.servlet.ServletContext;
import javax.servlet.http.*;
import java.util.Enumeration;
import java.util.UUID;

public class MyHttpServletSession implements HttpSession {
@Autowired
private RedisTemplate redisTemplate;

1. HttpServletRequest request;
3. HttpServletResponse response;
5. public MyHttpServletSession(HttpServletRequest request, HttpServletResponse response) {
6. this.request = request;
7. this.response = response;
8. }
11. private ThreadLocal<String> local = new ThreadLocal<>();
13. @Override
14. public void setAttribute(String name, Object value) {
15. //将我们的登录信息保存到redis中。
16. String sessionId = getSessionFromCookie();
17. if(sessionId!=null){
18. sessionId = local.get();
19. if(sessionId==null){
20. sessionId = "user:"+ UUID.randomUUID();
21. local.set(sessionId);
22. }
23. }
24. JSONObject jsonpObject = new JSONObject();
25. jsonpObject.put(name,value);
26. redisTemplate.opsForValue().set(sessionId,jsonpObject.toString());
27. //将sessionId添加到cookie中。
28. Cookie cookie = new Cookie("sessionId", sessionId);
29. cookie.setPath("/");
30. response.addCookie(cookie);
31. }
33. @Override
34. public Object getAttribute(String name) {
35. String sessionFromCookie = getSessionFromCookie();
37. String userInfo = (String) redisTemplate.opsForValue().get(sessionFromCookie);
38. JSONObject jsonObject = JSONObject.parseObject(userInfo);
39. if (jsonObject.containsKey(name)){
40. return jsonObject.get(name);
41. }
42. return null;
43. }
45. private String getSessionFromCookie(){
46. Cookie[] cookies = request.getCookies();
47. if(cookies!=null){
48. for (Cookie cookie:cookies){
49. if("sessionId".equals(cookie.getName())){
50. return cookie.getValue();
51. }
52. }
53. };
54. return null;
55. }
59. @Override
60. public long getCreationTime() {
61. return 0;
62. }
64. @Override
65. public String getId() {
66. return null;
67. }
69. @Override
70. public long getLastAccessedTime() {
71. return 0;
72. }
74. @Override
75. public ServletContext getServletContext() {
76. return null;
77. }
79. @Override
80. public void setMaxInactiveInterval(int i) {
82. }
84. @Override
85. public int getMaxInactiveInterval() {
86. return 0;
87. }
89. @Override
90. public HttpSessionContext getSessionContext() {
91. return null;
92. }
96. @Override
97. public Object getValue(String s) {
98. return null;
99. }
101. @Override
102. public Enumeration<String> getAttributeNames() {
103. return null;
104. }
106. @Override
107. public String[] getValueNames() {
108. return new String[0];
109. }
111. @Override
112. public void putValue(String s, Object o) {
114. }
116. @Override
117. public void removeAttribute(String s) {
119. }
121. @Override
122. public void removeValue(String s) {
124. }
126. @Override
127. public void invalidate() {
129. }
131. @Override
132. public boolean isNew() {
133. return false;
134. }

}

2. - 自定义HttpServlet对象，保证获取到的是我们自定义的Session(一致性)
4. ```java
5. package com.example.demo.filter;
7. import javax.servlet.http.HttpServletRequest;
8. import javax.servlet.http.HttpServletRequestWrapper;
9. import javax.servlet.http.HttpServletResponse;
10. import javax.servlet.http.HttpSession;
12. public class MyHttpServletRequest extends HttpServletRequestWrapper {
14. HttpServletRequest request;
16. HttpServletResponse response;
19. public MyHttpServletRequest(HttpServletRequest request, HttpServletResponse response){
20. super(request);
21. this.request = request;
22. this.response = response;
23. }
26. @Override
27. public HttpSession getSession() {
29. //返回我们自己创建的session对象
30. return new MyHttpServletSession(request,response);
31. }
32. }

• 自定义过滤器，拦截请求

  ```java
  package com.example.demo.filter;

import javax.servlet.;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebFilter(urlPatterns = “/“)
public class SessionFilter implements Filter {

1. @Override
2. public void init(FilterConfig filterConfig) throws ServletException {
4. }
6. @Override
7. public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
8. HttpServletRequest request = new MyHttpServletRequest((HttpServletRequest) servletRequest,(HttpServletResponse) servletResponse);
9. filterChain.doFilter(request,servletResponse);
10. }
12. @Override
13. public void destroy() {
15. }

}

2. - 启动器上指定自定义过滤器包路径
4. ```java
5. package com.example.demo;
7. import org.springframework.boot.SpringApplication;
8. import org.springframework.boot.autoconfigure.SpringBootApplication;
9. import org.springframework.boot.web.servlet.ServletComponentScan;
10. import tk.mybatis.spring.annotation.MapperScan;
12. @SpringBootApplication
13. @MapperScan("com.example.demo.mapper")
14. @ServletComponentScan(basePackages = {"com.example.demo"})
15. public class DemoApplication {
17. public static void main(String[] args) {
18. SpringApplication.run(DemoApplication.class, args);
19. }
21. }