此文档为拉钩Java高薪训练营2期课程学习过程，完成作业的文档。顺便说一句拉钩的课程，整个课程，体系非常全，价格上也是所有培训课程中最便宜的。如果希望构建一个整体的技术视野，非常推荐。

模拟拉勾网首页热门职位的缓存设计和实现

image.png
image.png
image.png

要求

  1. BS结构：springboot或ssm都行
  2. 设计合适的数据结构用于缓存数据
  3. 采用CacheAsidePattern方式读写缓存
  4. 分布式缓存可以采用RedisCluster或Tair搭建
  5. 当分布式缓存超时时读取本地GuavaCache
  6. 本地GuavaCache高并发访问时可以防止缓存击穿

整合 Reids

引入依赖

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

application.properties 配置

  1. spring.datasource.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf8&serverTimezone=GMT%2B8
  2. spring.datasource.username=root
  3. spring.datasource.password=Test_123
  5. spring.jpa.show-sql=true
  6. spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
  8. ######### thyemleaf ##############
  9. # 启用模板缓存 （默认开启，开发过程中，一般关闭，保证页面及时刷新）
  10. spring.thymeleaf.cache=false
  11. # 下面配置都可以直接采用默认配置
  12. # 模板编码
  13. spring.thymeleaf.encoding=UTF-8
  14. spring.thymeleaf.mode=HTML
  15. # 模板页面存放路径
  16. spring.thymeleaf.prefix=classpath:/templates/
  17. # 模板页面后缀
  18. spring.thymeleaf.suffix=.html
  20. ####### redis ###########
  21. spring.redis.cluster.nodes=192.168.158.124:7001,192.168.158.124:7002,192.168.158.124:7003,192.168.158.124:7004,192.168.158.124:7021,192.168.158.124:7022,192.168.158.124:7023,192.168.158.124:7024

RedisService 实现

  1. @Service
  2. public class RedisService {
  4.     private final String REDIS_HOT_POSITION_KEY = "lagou:hot-positions";
  6.     @Autowired
  7.     // 发现有一个 redisTemplate 和一个 stringRedisTemplate
  8.     @Qualifier("redisTemplate")
  9.     private RedisTemplate template;
  11.     /**
  12.      * 添加热门职位缓存
  13.      * @param positionList 热门职位
  14.      */
  15.     public void setHotPosition(List<HotPosition> positionList) {
  16.         BoundListOperations<String, HotPosition> ops = template.boundListOps(REDIS_HOT_POSITION_KEY);
  17.         for (HotPosition p : positionList) {
  18.             ops.leftPush(p);
  19.         }
  20.     }
  22.     /**
  23.      * 删除热门职位缓存
  24.      */
  25.     public void deleteHotPosition() {
  26.         template.unlink(REDIS_HOT_POSITION_KEY);
  27.     }
  29.     /**
  30.      * 获取所有热门职位
  31.      * @return 热门职位
  32.      */
  33.     public List<HotPosition> getHotPosition() {
  34.         return template.boundListOps(REDIS_HOT_POSITION_KEY).range(0, -1);
  35.     }
  36. }

整合 Guava

引入依赖

  1. <dependency>
  2.   <groupId>com.google.guava</groupId>
  3.   <artifactId>guava</artifactId>
  4.   <version>26.0-jre</version>
  5. </dependency>

GuavaCache 配置

  1. @Configuration
  2. public class GuavaCacheConfig {
  4.     @Bean
  5.     public Cache<Object, Object> localCache(){
  6.         return CacheBuilder.newBuilder().initialCapacity(10).maximumSize(20).build();
  7.     }
  8. }

GuavaCacheService 实现

  1. @Service
  2. public class GuavaCacheService {
  4.     private final String CACHE_HOT_POSITION_KEY = "lagou:hot-position";
  6.     @Autowired
  7.     private RedisService redisService;
  9.     @Autowired
  10.     private Cache<Object, Object> localCache;
  13.     public void loadHotPosition() {
  14.         List<HotPosition> hotPositions = redisService.getHotPosition();
  15.         localCache.put(CACHE_HOT_POSITION_KEY, hotPositions);
  16.     }
  18.     @SuppressWarnings("unchecked")
  19.     public List<HotPosition> getHotPositions() {
  20.         return (List<HotPosition>)localCache.getIfPresent(CACHE_HOT_POSITION_KEY);
  21.     }
  23. }

项目启动时初始化本地缓存

  1. @Component
  2. public class LocalCacheListener implements ApplicationListener<ApplicationStartedEvent> {
  4.     @Autowired
  5.     private GuavaCacheService guavaCacheService;
  7.     @Override
  8.     public void onApplicationEvent(ApplicationStartedEvent event) {
  9.         guavaCacheService.loadHotPosition();
  10.         System.out.println("guava 本地缓存初始化成功");
  11.     }
  12. }

整合 Redisson

整合 Redisson 防止缓存击穿：在 Redis 缓存不存在时，只允许一个线程查询数据库，其他的请求查询 Guava 本地缓存。

引入依赖

  1. <!-- redis 分布式锁  -->
  2. <!--        <dependency>-->
  3. <!--            <groupId>org.redisson</groupId>-->
  4. <!--            <artifactId>redisson-spring-boot-starter</artifactId>-->
  5. <!--            <version>3.10.6</version>-->
  6. <!--        </dependency>-->
  7. <dependency>
  8.   <groupId>org.redisson</groupId>
  9.   <artifactId>redisson</artifactId>
  10.   <version>3.11.4</version>
  11. </dependency>
  • 上面的 starter 没找到集群的配置，所以下面自己整合一下 Redis 集群

Redis 配置

  1. @Component
  2. @ConfigurationProperties(prefix = "spring.redis")
  3. public class RedisProperties {
  5.     private String password;
  6.     private cluster cluster;
  8.     public static class cluster {
  9.         private List<String> nodes;
  11.         public List<String> getNodes() {
  12.             return nodes;
  13.         }
  15.         public void setNodes(List<String> nodes) {
  16.             this.nodes = nodes;
  17.         }
  18.     }
  20.     public String getPassword() {
  21.         return password;
  22.     }
  24.     public void setPassword(String password) {
  25.         this.password = password;
  26.     }
  28.     public RedisProperties.cluster getCluster() {
  29.         return cluster;
  30.     }
  32.     public void setCluster(RedisProperties.cluster cluster) {
  33.         this.cluster = cluster;
  34.     }
  35. }

Redisson 配置

  1. @Configuration
  2. public class RedissonConfig {
  4.     @Autowired
  5.     private RedisProperties redisProperties;
  7.     @Bean
  8.     public Redisson redisson() {
  9.         //redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
  10.         List<String> clusterNodes = new ArrayList<>();
  11.         for (int i = 0; i < redisProperties.getCluster().getNodes().size(); i++) {
  12.             clusterNodes.add("redis://" + redisProperties.getCluster().getNodes().get(i));
  13.         }
  14.         Config config = new Config();
  15.         ClusterServersConfig clusterServersConfig = config.useClusterServers()
  16.                 .addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));
  17.         clusterServersConfig.setPassword(redisProperties.getPassword());
  18.         return (Redisson) Redisson.create(config);
  19.     }
  20. }

缓存模式查询逻辑

  1. @Service
  2. public class HotPositionServiceImpl implements IHotPositionService {
  4.     private final String LOCK_HOT_POSITION = "lock:hot-position";
  5.     @Autowired
  6.     private RedisService redisService;
  8.     @Autowired
  9.     private HotPositionDao hotPositionDao;
  11.     @Autowired
  12.     private GuavaCacheService guavaCacheService;
  14.     @Autowired
  15.     private Redisson redisson;
  17.     /**
  18.      * 首先从 Redis 缓存中查询数据，如果 Redis 缓存为空，通过分布式锁限制只允许一个线程到数据库里查询数据。
  19.      * 并将查询到的数据更新到 Redis 和 Guava 缓存。
  20.      * 其他的线程直接读取 Guava 缓存中的数据。
  21.      *
  22.      * @return 热门职位
  23.      */
  24.     @Override
  25.     public List<HotPosition> findAllHotPosition() {
  26.         List<HotPosition> hotPosition = redisService.getHotPosition();
  27.         if (hotPosition != null && hotPosition.size() > 0) {
  28.             System.out.println("直接从 Redis 缓存中加载数据");
  29.             return hotPosition;
  30.         }
  31.         System.out.println("Redis 缓存数据为空 ");
  32.         RLock lock = redisson.getLock(LOCK_HOT_POSITION);
  33.         boolean canLock = false;
  34.         try {
  35.             canLock = lock.tryLock(100L, TimeUnit.MILLISECONDS);
  36.             if (canLock) {
  37.                 // 获取锁成功
  38.                 // 模拟耗时操作，测试从本地 guava 缓存中读取数据
  39.                 Thread.sleep(1000L);
  40.                 System.out.println("休眠 1000L 完成");
  41.                 // 从数据库获取数据
  42.                 List<HotPosition> hotPositionList = hotPositionDao.findAll();
  43.                 // 更新 redis 缓存
  44.                 redisService.setHotPosition(hotPositionList);
  45.                 // 更新本地缓存
  46.                 guavaCacheService.loadHotPosition();
  47.                 System.out.println("从数据库获取数据，并写入缓存成功");
  48.                 return hotPositionList;
  49.             }
  50.         } catch (InterruptedException e) {
  51.             e.printStackTrace();
  52.         } finally {
  53.             // 如果时当前线程锁住，需要解锁
  54.             if (canLock) {
  55.                 lock.unlock();
  56.             }
  57.         }
  58.         // 如果获取锁失败（超时）, 直接从本地缓存取
  59.         System.out.println("从本地 guava 缓存中读取数据");
  60.         return guavaCacheService.getHotPositions();
  61.     }
  62. }