• Java大牛必会|分布式缓存实现方案之Spring Cache

    一. 场景

    小白：杨哥，今天我做分布式缓存时，看到公司用了Spring Cache，这个技术你能给我讲讲吗？

    杨哥：没问题！来，听杨哥给你说分布式缓存怎么搞。

    二. 缓存介绍

    2.1 缓存是高并发的第一策略

    2.2 适合缓存的数据

    2.3 缓存的重要指标

    2.3.1 缓存命中率

    从缓存中读取数据的次数：总读取次数 = 比率，命中率越高越好。

    • 命中率 = 从缓存中读取次数 / (总读取次数[从缓存中读取次数 + 从慢速设备上读取的次数])；

    • Miss率 = 没有从缓存中读取的次数 / (总读取次数[从缓存中读取次数 + 从慢速设备上读取的次数])

    2.3.2 移除策略

    参见上图！

    三. 基于Redis实现缓存

    3.1搭建环境

    3.1.1 添加核心依赖

    1. <dependency>
    2.     <groupId>org.springframework.boot</groupId>
    3.     <artifactId>spring-boot-starter-data-redis</artifactId>
    4. </dependency>

    3.1.2 配置Redis

    1. @Configuration
    2. public class RedisConfig  {
    3.  
    4.     @Autowired
    5.     private RedisTemplate redisTemplate;
    6.     
    7.     //序列化设置一下
    8.     @PostConstruct
    9.     public void setRedisTemplate() {
    10.         redisTemplate.setKeySerializer(new StringRedisSerializer());
    11.         redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
    12.     }
    13.  
    14. }

    3.2 缓存实现

    3.2.1 实现流程

    3.2.2 核心代码

    这里我们以查询省份信息为例进行实现。

    1. @Override
    2. public DsAprovinces selectById(Integer id) {
    3.  
    4.     String key = String.valueOf(id);
    5.     DsAprovinces dsAprovinces= null;
    6.     //1.从redis查
    7.     dsAprovinces = (DsAprovinces)redisTemplate.opsForValue().get(key);
    8.  
    9.     //2.如果不空
    10.     if(null!= dsAprovinces) {
    11.         System.out.println("redis中查到了");
    12.         return dsAprovinces;
    13.     }
    14.  
    15.     //3.查询数据库
    16.     dsAprovinces = dsAprovincesMapper.selectById(id);
    17.  
    18.     //3.放入缓存
    19.     if(null!= dsAprovinces) {
    20.         System.out.println("从数据库中查,放入缓存....");
    21.         redisTemplate.opsForValue().set(key,dsAprovinces);
    22.         redisTemplate.expire(key,60, TimeUnit.SECONDS); //60秒有效期
    23.     }
    24.  
    25.     return dsAprovinces;
    26. }

    3.3 数据库的增删改联动

    3.3.1 实现流程

    3.3.2 核心代码

    1. //更新:确保机制：实行双删
    2. public int update(DsAprovinces dsAprovinces) {
    3.     
    4.     redisTemplate.delete(String.valueOf(dsAprovinces.getId()));
    5.     int i = dsAprovincesMapper.updateById(dsAprovinces);
    6.     redisTemplate.delete(String.valueOf(dsAprovinces.getId()));
    7.  
    8.     return  i;
    9. }

    四. 基于Spring Cache实现缓存

    4.1 Spring Cache优点

    根据上图可知，Spring Cache具有如下优点：

    • 基于注解，代码清爽简洁；

    • 支持各种缓存：Spring Cache并非一种具体的缓存技术，而是基于各种缓存产品(如Guava、EhCache、Redis等)进行的一层封装，结合SpringBoot开箱即用的特性用起来会非常方便；

    • 可以实现复杂的逻辑；

    • 可以对缓存进行回滚

    4.2 Spring Cache包结构

    4.3 常用注解

    • @Cacheable //查询

    • @CachePut //增改

    • @CacheEvict //删除

    • @Caching //组合多个注解

    • @CacheConfig //在类上添加，抽取公共配置

    4.4 代码实现

    4.4.1 配置类

    1. @Configuration
    2. @EnableCaching //开启spring缓存
    3. public class MyCacheConfig extends CachingConfigurerSupport {
    4.  
    5.     //使用redis做为缓存
    6.     @Bean
    7.     public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    8.         //1.redis缓存管理器
    9.         RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.builder(connectionFactory);
    10.         //2.设置一些参数 //统一设置20s有效期
    11.         builder.cacheDefaults(RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(2000)));
    12.         builder.transactionAware();
    13.         RedisCacheManager build = builder.build();
    14.         return build;
    15.     }
    16.  
    17.     //可以自定义key的生成策略
    18.     @Override
    19.     public KeyGenerator keyGenerator() {
    20.  
    21.         return  new KeyGenerator() {
    22.             @Override
    23.             public Object generate(Object target, Method method, Object... objects) {
    24.                 //1.缓冲
    25.                 StringBuilder sb = new StringBuilder();
    26.                 //2.类名
    27.                 sb.append(target.getClass().getSimpleName());
    28.                 //3.方法名
    29.                 sb.append(method.getName());
    30.                 //4.参数值
    31.                 for (Object obj : objects) {
    32.                     sb.append(obj.toString());
    33.                 }
    34.                 return sb.toString();
    35.             }
    36.         };
    37.  
    38.     }
    39.  
    40. }

    4.4.2service层实现类

    1. @Service
    2. @Primary
    3. @CacheConfig(cacheNames = "provinces") //key键会添加provinces::
    4. public class AprovincesServiceImpl2 implements IAprovincesService {
    5.  
    6.     @Autowired
    7.     private DsAprovincesMapper  dsAprovincesMapper;
    8.  
    9.     @Autowired
    10.     private RedisTemplate redisTemplate;
    11.  
    12.     @Override
    13.     @Cacheable(key = "#id")
    14.     //@Cacheable
    15.     public DsAprovinces selectById(Integer id) {
    16.  
    17.         //3.查询数据库
    18.         DsAprovinces dsAprovinces = dsAprovincesMapper.selectById(id);
    19.  
    20.         return dsAprovinces;
    21.     }
    22.  
    23.     //更新:确保机制：实行双删
    24.     @CachePut(key = "#dsAprovinces.id")
    25.     public DsAprovinces update(DsAprovinces dsAprovinces) {
    26.         dsAprovincesMapper.updateById(dsAprovinces);
    27.  
    28.         return dsAprovinces;
    29.     }
    30.  
    31.     //添加
    32.     @CachePut(key = "#dsAprovinces.id")
    33.     public DsAprovinces save(DsAprovinces dsAprovinces) {
    34.  
    35.         dsAprovincesMapper.insert(dsAprovinces);
    36.  
    37.         return  dsAprovinces;
    38.     }
    39.     
    40.     //删除
    41.     @CacheEvict
    42.     public int delete(Integer id) {
    43.         int i = dsAprovincesMapper.deleteById(id);
    44.         return  i;
    45.     }
    46. }

    4.5 缺点

    任何一种技术都不是十全十美的，Spring Cache也不例外，它也有一些缺点，比如：

    • 不能保证数据的一致性：保存和修改数据是，是先修改数据库，然后再进行更新缓存。如果不满意延迟效果，可以不用cache ，用双删。

    • 过期进间配置：过期时间统一配置。

    五.缓存一致性问题

    我们在实现Redis缓存时，其实会存在缓存一致性的问题，比如下图所示：

    5.1 代码同步更新

    强一致性，但代码耦合高。

    5.2 代码异步更新

    有延迟，借助设计模式或者mq。

    5.3 缓存自己的TTL

    缓存有一定的延迟，可能造成缓存击穿，或者雪崩问题。

    5.4 用定时任务

    要把握好更新频率。

    六.分布式锁的实现

    6.1 实现流程

    解释说明：

    • 缓存击穿和雪崩可以用分布式解决。

    • 线程1，代码当前线程

    • 线程2，代表和线程1的同类线程。

    • 线程3，代表其它线程。

    6.2 实现代码

    6.2.1 核心代码

    1. @Service
    2. public class AprovincesServiceImpl3 implements IAprovincesService {
    3.  
    4.     @Autowired
    5.     private DsAprovincesMapper  dsAprovincesMapper;
    6.  
    7.     @Autowired
    8.     private RedisTemplate redisTemplate;
    9.  
    10.     @Autowired
    11.     public CacheManager cacheManager;
    12.     @Override
    13.     public DsAprovinces selectById(Integer id) {
    14.  
    15.         System.out.println("=======================开始");
    16.         //1.从缓存中取数据
    17.         Cache provinces1 = cacheManager.getCache("provinces");
    18.         Cache.ValueWrapper provinces = cacheManager.getCache("provinces").get(id);
    19.         //2. 如果缓存中有数据，则返回
    20.         if(null != provinces) {
    21.             System.out.println("====从缓从中拿数据=======");
    22.             return (DsAprovinces)provinces.get();
    23.         }
    24.  
    25.         //3.如果缓存中没有，先加把锁
    26.         doLock(id+"");
    27.         //
    28.         DsAprovinces dsAprovinces = null;
    29.  
    30.         try {
    31.  
    32.             //4.0从第二个线程进来后，查一下
    33.             provinces = cacheManager.getCache("provinces").get(id);
    34.             if(null != provinces) {
    35.                 System.out.println("====从缓从中拿数据=======");
    36.                 return (DsAprovinces)provinces.get();
    37.             }
    38.  
    39.             //4.查询数据库
    40.             dsAprovinces = dsAprovincesMapper.selectById(id);
    41.  
    42.             //5.把数据放入缓存
    43.             if(null != dsAprovinces) {
    44.                 System.out.println("查询数据库，并放入缓存....");
    45.                 cacheManager.getCache("provinces").put(id,dsAprovinces);
    46.             }
    47.         } catch (Exception e) {
    48.             e.printStackTrace();
    49.         } finally {
    50.             releaseLock(id+"");
    51.         }
    52.  
    53.  
    54.         return dsAprovinces;
    55.     }
    56.  
    57.  
    58.     //=====================================分布式加锁和释放锁封装start=========================
    59.     //分布式存放锁,这个map是线程安全的
    60.     private ConcurrentHashMap<String,Lock> locks = new ConcurrentHashMap<>();
    61.  
    62.     //依据主键进行加锁
    63.     private  void doLock(String id) {
    64.         //1.创建一个可重入锁
    65.         ReentrantLock newlock = new ReentrantLock();
    66.         //2.如 果存在id,则返回旧值，如果不存在, 放入，返回null
    67.         Lock old = locks.putIfAbsent(id,newlock);
    68.  
    69.         //3.如果已存在id
    70.         if(null != old) {
    71.             old.lock();
    72.         }else {
    73.             newlock.lock();
    74.         }
    75.     }
    76.  
    77.     //释放 一下
    78.     private void releaseLock(String id) {
    79.         //获取到锁
    80.         ReentrantLock lock = (ReentrantLock)locks.get(id);
    81.  
    82.         //判断
    83.         if(null != lock && lock.isHeldByCurrentThread() ) {
    84.             lock.unlock();
    85.         }
    86.  
    87.     }
    88.     //=====================================分布式加锁和释放锁封装end=========================
    89.     

    6.2.2 测试CountDownLatch

    1. CountDownLatch cw = new CountDownLatch(8);
    2.  
    3. @GetMapping("/selectById1/{id}")
    4. public DsAprovinces selectById1(@PathVariable Integer id) {
    5.  
    6.     for (int i = 0; i < 8; i++) {
    7.         new Thread(
    8.                 new Runnable() {
    9.                     @Override
    10.                     public void run() {
    11.                         try {
    12.                             cw.await();
    13.                             aprovincesService.selectById(id);
    14.                         } catch (InterruptedException e) {
    15.                             e.printStackTrace();
    16.                         } finally {
    17.                         }
    18.  
    19.                     }
    20.                 }
    21.         ).start();
    22.         cw.countDown();
    23.     }
    24.  
    25.  
    26.     return  aprovincesService.selectById(id);
    27. }

    6.2.3测试结果

    七. 小结

    至此，杨哥就带大家利用Spring Cache实现了分布式缓存，我们在开发时要依据具体的业务逻辑具体地分析解决。其实在项目中并没有固定的格式，只要大家选择适合自己项目场景的方案即可。不知道你现在还有哪些问题呢？可以在评论区给我留言哦。

    *威哥Java学习交流Q群：691533824
    加群备注：CSDN推荐      

  • 相关阅读:
    Vue跨域详解
    C++ | 高维数组、指针、返回指向数组的指针的函数
    vc可用hex字符串转char*
    MATLAB | 如何绘制三维曲线、曲面、多边形投影(三视图)？
    LeetCode 0141. 环形链表 - 三种方法解决
    近世代数之群
    Spire.Office for Java 8.10.2 同步更新Crk
    「Spring Boot 系列」09. Spring Boot集成MyBatis-Plus实现CRUD
    大一学生作品《前端框架开发技术》 期末网页制作 HTML+CSS+JavaScript 个人主页网页设计实例
    Java.lang.Class类 getMethod()方法有什么功能呢？
  • 原文地址：https://blog.csdn.net/finally_vince/article/details/127123333