• Redis-SpringBoot实战与缓存问题

    在xx/config包下配置   Redis默认是JDK序列化，我们要配置成JSON序列化，解决乱码问题

    1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
    2. import com.fasterxml.jackson.annotation.PropertyAccessor;
    3. import com.fasterxml.jackson.databind.ObjectMapper;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6. import org.springframework.data.redis.connection.RedisConnectionFactory;
    7. import org.springframework.data.redis.core.RedisTemplate;
    8. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    9. import org.springframework.data.redis.serializer.StringRedisSerializer;
    10.  
    11. @Configuration
    12. public class RedisConfig {
    13.  
    14.     //固定模板
    15.     @Bean
    16.     @SuppressWarnings("all")
    17.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    18.         //我们为方便开发，一般直接使用<String, Object>
    19.         RedisTemplate<String, Object> template = new RedisTemplate();
    20.         template.setConnectionFactory(factory);
    21.  
    22.         //Json序列化配置
    23.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    24.         ObjectMapper om = new ObjectMapper();
    25.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    26.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    27.         jackson2JsonRedisSerializer.setObjectMapper(om);
    28.         //string的序列化
    29.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    30.  
    31.         //Key采用String的序列化方式
    32.         template.setKeySerializer(stringRedisSerializer);
    33.         //hash的key也采用String的序列化方式
    34.         template.setHashKeySerializer(stringRedisSerializer);
    35.         //value序列化方式采用jackson
    36.         template.setValueSerializer(jackson2JsonRedisSerializer);
    37.         //hash的value序列化方式采用jackson
    38.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
    39.         template.afterPropertiesSet();
    40.  
    41.         return template;
    42.  
    43.     }
    44. }

    在xx/utils包下配置工具类，来简化操作命令 

    1. import org.springframework.beans.factory.annotation.Autowired;
    2. import org.springframework.data.redis.core.RedisTemplate;
    3. import org.springframework.stereotype.Component;
    4. import org.springframework.util.CollectionUtils;
    5.  
    6. import java.util.Collection;
    7. import java.util.List;
    8. import java.util.Map;
    9. import java.util.Set;
    10. import java.util.concurrent.TimeUnit;
    11.  
    12. @Component
    13. public class RedisUtil {
    14.     @Resource
    15.     private RedisTemplate<String, Object> redisTemplate;
    16.     // =============================common============================
    17.     /**
    18.      * 指定缓存失效时间
    19.      * @param key 键
    20.      * @param time 时间(秒)
    21.      */
    22.     public boolean expire(String key, long time) {
    23.         try {
    24.             if (time > 0) {
    25.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
    26.             }
    27.             return true;
    28.         } catch (Exception e) {
    29.             e.printStackTrace();
    30.             return false;
    31.         }
    32.     }
    33.     /**
    34.      * 根据key 获取过期时间
    35.      * @param key 键 不能为null
    36.      * @return 时间(秒) 返回0代表为永久有效
    37.      */
    38.     public long getExpire(String key) {
    39.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    40.     }
    41.     /**
    42.      * 判断key是否存在
    43.      * @param key 键
    44.      * @return true 存在 false不存在
    45.      */
    46.     public boolean hasKey(String key) {
    47.         try {
    48.             return redisTemplate.hasKey(key);
    49.         } catch (Exception e) {
    50.             e.printStackTrace();
    51.             return false;
    52.         }
    53.     }
    54.     /**
    55.      * 删除缓存
    56.      * @param key 可以传一个值 或多个
    57.      */
    58.     @SuppressWarnings("unchecked")
    59.     public void del(String... key) {
    60.         if (key != null && key.length > 0) {
    61.             if (key.length == 1) {
    62.                 redisTemplate.delete(key[0]);
    63.             } else {
    64.                 redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
    65.             }
    66.         }
    67.     }
    68.     // ============================String=============================
    69.     /**
    70.      * 普通缓存获取
    71.      * @param key 键
    72.      * @return 值
    73.      */
    74.     public Object get(String key) {
    75.         return key == null ? null : redisTemplate.opsForValue().get(key);
    76.     }
    77.     /**
    78.      * 普通缓存放入
    79.      * @param key 键
    80.      * @param value 值
    81.      * @return true成功 false失败
    82.      */
    83.     public boolean set(String key, Object value) {
    84.         try {
    85.             redisTemplate.opsForValue().set(key, value);
    86.             return true;
    87.         } catch (Exception e) {
    88.             e.printStackTrace();
    89.             return false;
    90.         }
    91.     }
    92.     /**
    93.      * 普通缓存放入并设置时间
    94.      * @param key 键
    95.      * @param value 值
    96.      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
    97.      * @return true成功 false 失败
    98.      */
    99.     public boolean set(String key, Object value, long time) {
    100.         try {
    101.             if (time > 0) {
    102.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    103.             } else {
    104.                 set(key, value);
    105.             }
    106.             return true;
    107.         } catch (Exception e) {
    108.             e.printStackTrace();
    109.             return false;
    110.         }
    111.     }
    112.     /**
    113.      * 递增
    114.      * @param key 键
    115.      * @param delta 要增加几(大于0)
    116.      * @return
    117.      */
    118.     public long incr(String key, long delta) {
    119.         if (delta < 0) {
    120.             throw new RuntimeException("递增因子必须大于0");
    121.         }
    122.         return redisTemplate.opsForValue().increment(key, delta);
    123.     }
    124.     /**
    125.      * 递减
    126.      * @param key 键
    127.      * @param delta 要减少几(小于0)
    128.      * @return
    129.      */
    130.     public long decr(String key, long delta) {
    131.         if (delta < 0) {
    132.             throw new RuntimeException("递减因子必须大于0");
    133.         }
    134.         return redisTemplate.opsForValue().increment(key, -delta);
    135.     }
    136.     // ================================Map=================================
    137.     /**
    138.      * HashGet
    139.      * @param key 键 不能为null
    140.      * @param item 项 不能为null
    141.      * @return 值
    142.      */
    143.     public Object hget(String key, String item) {
    144.         return redisTemplate.opsForHash().get(key, item);
    145.     }
    146.     /**
    147.      * 获取hashKey对应的所有键值
    148.      * @param key 键
    149.      * @return 对应的多个键值
    150.      */
    151.     public Map<Object, Object> hmget(String key) {
    152.         return redisTemplate.opsForHash().entries(key);
    153.     }
    154.     /**
    155.      * HashSet
    156.      * @param key 键
    157.      * @param map 对应多个键值
    158.      * @return true 成功 false 失败
    159.      */
    160.     public boolean hmset(String key, Map<String, Object> map) {
    161.         try {
    162.             redisTemplate.opsForHash().putAll(key, map);
    163.             return true;
    164.         } catch (Exception e) {
    165.             e.printStackTrace();
    166.             return false;
    167.         }
    168.     }
    169.     /**
    170.      * HashSet 并设置时间
    171.      * @param key 键
    172.      * @param map 对应多个键值
    173.      * @param time 时间(秒)
    174.      * @return true成功 false失败
    175.      */
    176.     public boolean hmset(String key, Map<String, Object> map, long time) {
    177.         try {
    178.             redisTemplate.opsForHash().putAll(key, map);
    179.             if (time > 0) {
    180.                 expire(key, time);
    181.             }
    182.             return true;
    183.         } catch (Exception e) {
    184.             e.printStackTrace();
    185.             return false;
    186.         }
    187.     }
    188.     /**
    189.      * 向一张hash表中放入数据,如果不存在将创建
    190.      * @param key 键
    191.      * @param item 项
    192.      * @param value 值
    193.      * @return true 成功 false失败
    194.      */
    195.     public boolean hset(String key, String item, Object value) {
    196.         try {
    197.             redisTemplate.opsForHash().put(key, item, value);
    198.             return true;
    199.         } catch (Exception e) {
    200.             e.printStackTrace();
    201.             return false;
    202.         }
    203.     }
    204.     /**
    205.      * 向一张hash表中放入数据,如果不存在将创建
    206.      * @param key 键
    207.      * @param item 项
    208.      * @param value 值
    209.      * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
    210.      * @return true 成功 false失败
    211.      */
    212.     public boolean hset(String key, String item, Object value, long time) {
    213.         try {
    214.             redisTemplate.opsForHash().put(key, item, value);
    215.             if (time > 0) {
    216.                 expire(key, time);
    217.             }
    218.             return true;
    219.         } catch (Exception e) {
    220.             e.printStackTrace();
    221.             return false;
    222.         }
    223.     }
    224.     /**
    225.      * 删除hash表中的值
    226.      * @param key 键 不能为null
    227.      * @param item 项 可以使多个 不能为null
    228.      */
    229.     public void hdel(String key, Object... item) {
    230.         redisTemplate.opsForHash().delete(key, item);
    231.     }
    232.     /**
    233.      * 判断hash表中是否有该项的值
    234.      * @param key 键 不能为null
    235.      * @param item 项 不能为null
    236.      * @return true 存在 false不存在
    237.      */
    238.     public boolean hHasKey(String key, String item) {
    239.         return redisTemplate.opsForHash().hasKey(key, item);
    240.     }
    241.     /**
    242.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    243.      * @param key 键
    244.      * @param item 项
    245.      * @param by 要增加几(大于0)
    246.      * @return
    247.      */
    248.     public double hincr(String key, String item, double by) {
    249.         return redisTemplate.opsForHash().increment(key, item, by);
    250.     }
    251.     /**
    252.      * hash递减
    253.      * @param key 键
    254.      * @param item 项
    255.      * @param by 要减少记(小于0)
    256.      * @return
    257.      */
    258.     public double hdecr(String key, String item, double by) {
    259.         return redisTemplate.opsForHash().increment(key, item, -by);
    260.     }
    261.     // ============================set=============================
    262.     /**
    263.      * 根据key获取Set中的所有值
    264.      * @param key 键
    265.      * @return
    266.      */
    267.     public Set<Object> sGet(String key) {
    268.         try {
    269.             return redisTemplate.opsForSet().members(key);
    270.         } catch (Exception e) {
    271.             e.printStackTrace();
    272.             return null;
    273.         }
    274.     }
    275.     /**
    276.      * 根据value从一个set中查询,是否存在
    277.      * @param key 键
    278.      * @param value 值
    279.      * @return true 存在 false不存在
    280.      */
    281.     public boolean sHasKey(String key, Object value) {
    282.         try {
    283.             return redisTemplate.opsForSet().isMember(key, value);
    284.         } catch (Exception e) {
    285.             e.printStackTrace();
    286.             return false;
    287.         }
    288.     }
    289.     /**
    290.      * 将数据放入set缓存
    291.      * @param key 键
    292.      * @param values 值 可以是多个
    293.      * @return 成功个数
    294.      */
    295.     public long sSet(String key, Object... values) {
    296.         try {
    297.             return redisTemplate.opsForSet().add(key, values);
    298.         } catch (Exception e) {
    299.             e.printStackTrace();
    300.             return 0;
    301.         }
    302.     }
    303.     /**
    304.      * 将set数据放入缓存
    305.      * @param key 键
    306.      * @param time 时间(秒)
    307.      * @param values 值 可以是多个
    308.      * @return 成功个数
    309.      */
    310.     public long sSetAndTime(String key, long time, Object... values) {
    311.         try {
    312.             Long count = redisTemplate.opsForSet().add(key, values);
    313.             if (time > 0) {
    314.                 expire(key, time);
    315.             }
    316.             return count;
    317.         } catch (Exception e) {
    318.             e.printStackTrace();
    319.             return 0;
    320.         }
    321.     }
    322.     /**
    323.      * 获取set缓存的长度
    324.      * @param key 键
    325.      * @return
    326.      */
    327.     public long sGetSetSize(String key) {
    328.         try {
    329.             return redisTemplate.opsForSet().size(key);
    330.         } catch (Exception e) {
    331.             e.printStackTrace();
    332.             return 0;
    333.         }
    334.     }
    335.     /**
    336.      * 移除值为value的
    337.      * @param key 键
    338.      * @param values 值 可以是多个
    339.      * @return 移除的个数
    340.      */
    341.     public long setRemove(String key, Object... values) {
    342.         try {
    343.             Long count = redisTemplate.opsForSet().remove(key, values);
    344.             return count;
    345.         } catch (Exception e) {
    346.             e.printStackTrace();
    347.             return 0;
    348.         }
    349.     }
    350.     // ===============================list=================================
    351.     /**
    352.      * 获取list缓存的内容
    353.      * @param key 键
    354.      * @param start 开始
    355.      * @param end 结束 0 到 -1代表所有值
    356.      * @return
    357.      */
    358.     public List<Object> lGet(String key, long start, long end) {
    359.         try {
    360.             return redisTemplate.opsForList().range(key, start, end);
    361.         } catch (Exception e) {
    362.             e.printStackTrace();
    363.             return null;
    364.         }
    365.     }
    366.     /**
    367.      * 获取list缓存的长度
    368.      * @param key 键
    369.      * @return
    370.      */
    371.     public long lGetListSize(String key) {
    372.         try {
    373.             return redisTemplate.opsForList().size(key);
    374.         } catch (Exception e) {
    375.             e.printStackTrace();
    376.             return 0;
    377.         }
    378.     }
    379.     /**
    380.      * 通过索引 获取list中的值
    381.      * @param key 键
    382.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
    383.      * @return
    384.      */
    385.     public Object lGetIndex(String key, long index) {
    386.         try {
    387.             return redisTemplate.opsForList().index(key, index);
    388.         } catch (Exception e) {
    389.             e.printStackTrace();
    390.             return null;
    391.         }
    392.     }
    393.     /**
    394.      * 将list放入缓存
    395.      * @param key 键
    396.      * @param value 值
    397.      * @return
    398.      */
    399.     public boolean lSet(String key, Object value) {
    400.         try {
    401.             redisTemplate.opsForList().rightPush(key, value);
    402.             return true;
    403.         } catch (Exception e) {
    404.             e.printStackTrace();
    405.             return false;
    406.         }
    407.     }
    408.     /**
    409.      * 将list放入缓存
    410.      * @param key 键
    411.      * @param value 值
    412.      * @param time 时间(秒)
    413.      * @return
    414.      */
    415.     public boolean lSet(String key, Object value, long time) {
    416.         try {
    417.             redisTemplate.opsForList().rightPush(key, value);
    418.             if (time > 0) {
    419.                 expire(key, time);
    420.             }
    421.             return true;
    422.         } catch (Exception e) {
    423.             e.printStackTrace();
    424.             return false;
    425.         }
    426.     }
    427.     /**
    428.      * 将list放入缓存
    429.      * @param key 键
    430.      * @param value 值
    431.      * @return
    432.      */
    433.     public boolean lSet(String key, List<Object> value) {
    434.         try {
    435.             redisTemplate.opsForList().rightPushAll(key, value);
    436.             return true;
    437.         } catch (Exception e) {
    438.             e.printStackTrace();
    439.             return false;
    440.         }
    441.     }
    442.     /**
    443.      * 将list放入缓存
    444.      *
    445.      * @param key 键
    446.      * @param value 值
    447.      * @param time 时间(秒)
    448.      * @return
    449.      */
    450.     public boolean lSet(String key, List<Object> value, long time) {
    451.         try {
    452.             redisTemplate.opsForList().rightPushAll(key, value);
    453.             if (time > 0) {
    454.                 expire(key, time);
    455.             }
    456.             return true;
    457.         } catch (Exception e) {
    458.             e.printStackTrace();
    459.             return false;
    460.         }
    461.     }
    462.     /**
    463.      * 根据索引修改list中的某条数据
    464.      * @param key 键
    465.      * @param index 索引
    466.      * @param value 值
    467.      * @return
    468.      */
    469.     public boolean lUpdateIndex(String key, long index, Object value) {
    470.         try {
    471.             redisTemplate.opsForList().set(key, index, value);
    472.             return true;
    473.         } catch (Exception e) {
    474.             e.printStackTrace();
    475.             return false;
    476.         }
    477.     }
    478.     /**
    479.      * 移除N个值为value
    480.      * @param key 键
    481.      * @param count 移除多少个
    482.      * @param value 值
    483.      * @return 移除的个数
    484.      */
    485.     public long lRemove(String key, long count, Object value) {
    486.         try {
    487.             Long remove = redisTemplate.opsForList().remove(key, count, value);
    488.             return remove;
    489.         } catch (Exception e) {
    490.             e.printStackTrace();
    491.             return 0;
    492.         }
    493.     }
    494. }

    在service层进行应用

    1.     @Override
    2.     public Product findById(Integer id) {
    3.         if (redisUtil.hasKey("productId_" + id)) {    //如果有就读取缓存
    4.             System.out.println("redis缓存读取了"+"   productId_" + id);
    5.             return (Product) redisUtil.get("productId_" + id);
    6.         } else {      //否则存入缓存
    7.             // 根据参数id调用私有方法执行查询，获取商品数据
    8.             Product product = productMapper.findById(id);
    9.             // 判断查询结果是否为null
    10.             if (product == null) {
    11.                 // 是：抛出ProductNotFoundException
    12.                 throw new ProductNotFoundException("尝试访问的商品数据不存在");
    13.             }
    14.             // 将查询结果中的部分属性设置为null
    15.             product.setPriority(null);
    16.             product.setCreatedUser(null);
    17.             product.setCreatedTime(null);
    18.             product.setModifiedUser(null);
    19.             product.setModifiedTime(null);
    20.             redisUtil.set("productId_" + id,product,3000);
    21.             System.out.println("redis存入缓存"+"  productId_" + id+":"+product);
    22.             // 返回查询结果
    23.             return product;
    24.         }
    25.     }

    缓存雪崩

    Redis由于某些原因不可用（宕机）或者大量缓存由于超时时间相同在同一时间段失效（大批key失效/热点数据失效），大量请求直接到达数据库(Mysql)，数据库压力过大导致系统崩溃。

     

    解决方案：

    • 搭建集群

             这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。（异地多活!)

    • 限流降级

          这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

    •  数据预热
             预先读取一遍数据。缓存的过期时间用随机值，尽量让不同的key的过期时间不同（例如：定时任务新建大批量key，设置的过期时间不同）

    set（Key，value，time + Math.random() * 10000）；
     

    缓存击穿 (量太大，缓存过期)

    缓存击穿，跟缓存雪崩有点像，但是又有一点不一样，缓存雪崩是因为大面积的缓存失效，打崩了DB，而缓存击穿不同的是缓存击穿是指一个Key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个Key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个完好无损的桶上凿开了一个洞。

    • 分布式互斥锁：这种方案思路比较简单，但是存在一定的隐患，如果在查询数据库 + 和 重建缓存（key失效后进行了大量的计算）时间过长，也可能会存在死锁和线程池阻塞的风险，高并发情景下吞吐量会大大降低！但是这种方法能够较好地降低后端存储负载，并在一致性上做得比较好。

    • 热点数据永不过期：这种方案由于没有设置真正的过期时间，实际上已经不存在热点key产生的一系列危害，但是会存在数据不一致的情况，同时代码复杂度会增大。

    缓存穿透

       缓存穿透是指查询一个根本不存在的数据，缓存层和持久层都不会命中。在日常工作中出于容错的考虑，如果从持久层查不到数据则不写入缓存层，缓存穿透将导致不存在的数据每次请求都要到持久层去查询，失去了缓存保护后端持久的意义

      造成缓存穿透的基本原因有两个。第一，自身业务代码或者数据出现问题（例如：set 和 get 的key不一致），第二，一些恶意攻击、爬虫等造成大量空命中（爬取线上商城商品数据，超大循环递增商品的ID）

    • 缓存空对象：从缓存取不到的数据，在数据库中也没有取到，这时也可以将对应Key的Value对写为null、位置错误、稍后重试这样的值具体取啥问产品，或者看具体的场景，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。

      这样可以防止攻击用户反复用同一个id暴力攻击，但是我们要知道正常用户是不会在单秒内发起这么多次请求的，那网关层Nginx有配置项，可以让运维对单个IP每秒访问次数超出阈值的IP都拉黑。
       

    • 布隆过滤器拦截：

    •  

    Redis 缓存穿透 + 缓存雪崩 + 缓存击穿的原因和解决方案_骑驴的小牧童的博客-CSDN博客_redis的缓存穿透和缓存雪崩

    阿里面试Redis最常问的三个问题：缓存雪崩、击穿、穿透（带答案）_敖 丙的博客-CSDN博客 

  • 相关阅读:
    MySQL-常用数据库操作SQL汇总
    了解一下，我是如何用Python在业余时间赚5千外快的
    618京东到家APP-门详页反爬实战
    高科技电子行业采购供应链管理
    MySQL高级：（二）存储引擎
    基于FPGA的超声波测距
    Thread的常用方法
    在C#开发中使用第三方组件LambdaParser、DynamicExpresso、Z.Expressions，实现动态解析/求值字符串表达式
    【Java】DDD领域驱动设计理解
    轻量级的VsCode为何越用越大？为什么吃了我C盘10G？如何无痛清理VsCode缓存？手把手教你为C盘瘦身
  • 原文地址：https://blog.csdn.net/m0_46845579/article/details/125452632