谷粒商城の缓存篇

于 2024-09-07 11:45:25 发布
阅读量764 收藏 21
点赞数 12
分类专栏： 项目实践 文章标签： 缓存 后端 redis springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77599076/article/details/141746039
版权

文章目录

前言

  本篇重点介绍谷粒商城首页整合缓存技术，从本地缓存（Map）到分布式缓存（Redis），描述常见的缓存三大问题（缓存穿透，缓存雪崩，缓存击穿）及解决方案，并且在解决的过程中引用成熟的Redisson方案。最后到缓存一致性的问题及解决，整合Spring Cache。

  对应视频P151-P172

一、本地缓存和分布式缓存

1.本地缓存

  本地缓存存储在单个应用服务器的内存中，属于该服务器的进程空间。仅在当前服务器节点内有效，不会在多个服务器之间共享。
本地缓存最简单的实现方式：通过Map：

    private HashMap<String,Object> map = new HashMap<>();
		
    @Test
    public Object testMapCache(){
        Object key = map.get("key");
        if (key !=null){
            return key;
        }
        //查询数据库相关逻辑...假设查询到的值为value
        map.put("key","value");
        return "value";
    }

  不考虑缓存一致性，穿透，击穿等问题，上面的案例就是通过Map做本地缓存最简单的实现。

2.分布式缓存

  目前市面上大多数的项目都是采用微服务的架构，同一个服务也可能部署多个实例。而如上面所说，本地缓存仅在当前服务器节点内有效。假设现在有三台服务器：
Alt
  初始状态下三台服务器都没有缓存，第一次用户访问了服务器1，查询数据库后将结果存入了缓存。下一次由于负载均衡，访问到了服务器2：
Alt
  由于缓存此时只存在于服务器1，这次用户又需要去数据库中查询，然后放入服务器2的缓存中。
  为了解决这样的问题，在微服务的架构中，引入了缓存中间件对不同服务间的缓存进行统一管理。常用的是Redis。

二、项目实战

1.配置Redis

  		 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

spring:
	redis:
		host: xxx
		port: 6379

  Redis为我们封装了两个模版，分别是redisTemplate和stringRedisTemplate，stringRedisTemplate的key和value默认都是String类型的，在项目中使用时，只需要注入对应的模版即可。
Alt

2.整合业务代码

  在项目中，需要加入缓存的业务场景是，首页渲染三级分类菜单。
  缓存这一块的坑点很多，在整合业务代码前，有必要先介绍一下缓存常见的三大问题及解决方案：

2.1 缓存击穿

  假设数据库中的某张A表，数据的主键ID是从1-1000，如果使用1001的ID去查询数据，是无论如何都查询不到的，查询到的会是空值。如果没有将这个空值存入缓存，那么通过伪造请求等方式不断地使用不存在的ID作为条件去查询数据库，也会导致数据库崩溃的情况。
  解决方式：如果根据查询条件查询到的结果不存在，就缓存一个空值或进行约定，缓存一个特定的值。也可以通过布隆过滤器，或加强参数校验的方式解决。

2.2 缓存雪崩

  这种情况主要是出现在大并发量的场景下，大量的热点key同时失效，导致这一刻的所有请求都打到数据库上。
  解决方式：给不同的key设置随机的过期时间，或者设置永不过期。

2.3 缓存穿透

  区别于缓存雪崩，击穿主要是体现在某个热点key失效，导致大量的请求在查询缓存无果的情况下，都去数据库中查询。
  解决方式：加锁，让同一时刻只有一个线程能查询到数据库。但是涉及到多线程锁的问题时，一般就不会有那么简单了。我们知道锁有本地锁和分布式锁，也有乐观锁和悲观锁。
  如果直接使用synchronized关键字进行加锁，在单体应用下是没问题的。synchronized关键字是锁当前的JVM。在微服务架构下，每个服务都有自己的JVM，假设我的product服务部署在了8台服务器上，每个服务器锁自己的JVM，最后还是有可能8个请求同时打在数据库上。所以需要一个全局的锁去统一管理这些服务。通过Redis也可以自己实现分布式锁，但是其中有很多坑点。

2.4 业务代码1.0版

  加入缓存后的业务流程图：
Alt
  我们先不考虑分布式锁的实现，完成第一版加入缓存的业务代码：
  这里有几点需要注意下：

  1. 存入缓存的key必须唯一，可以加上当前用户或者业务的前缀。例如我将商品列表放入缓存，商品列表可以被不同的用户访问，又带有查询条件，可以这样设计key：用户标识:查询条件1_查询条件2_查询条件3
  2. 某个线程获取到了锁，在查询数据库前，需要先再次查询缓存中是否有值。
  3. 将数据库查询结果，放入缓存必须在锁的范围内，否则可能存在，A线程查到了数据然后释放了锁，准备放入缓存，在放入缓存的过程中，B线程获取到了锁，又去查了一遍数据库的问题。
  4. 向Redis中存储的数据，一般约定使用JSON字符串的方式进行存储，在读取时进行反序列化。
@Slf4j
@Service("categoryService")
public class CategoryServiceImpl extends ServiceImpl<CategoryDao, CategoryEntity> implements CategoryService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

	   @Override
    public Map<String, List<CategoryJsonVO>> getCategoryJson() {
        //从缓存中获取
        String category = stringRedisTemplate.opsForValue().get(RedisConstants.CATEGORY_KEY);
        //缓存中不为空
        if (StringUtils.isNotBlank(category)) {
            log.info("查询到了结果");
            return JSON.parseObject(category, new TypeReference<Map<String, List<CategoryJsonVO>>>() {
            });
        }

        /*
        缓存空值解决缓存穿透
        设置过期时间（随机值）解决缓存雪崩
        加锁解决缓存击穿
         */
        //查询pms_category表的全量数据
        Map<String, List<CategoryJsonVO>> map;
        map = this.getCateGoryFromDB();
        return map;
    }

  /**
     * 从数据库查询三级分类
     * @return 查询结果
     */
    private Map<String, List<CategoryJsonVO>> getCateGoryFromDB() {
        synchronized (this) {
            log.info("获取到了锁");
            //再看下缓存中有没有
            //从缓存中获取
            String category = stringRedisTemplate.opsForValue().get(RedisConstants.CATEGORY_KEY);
            //缓存中不为空
            if (StringUtils.isNotBlank(category)) {
                log.info("查询到了结果");
                return JSON.parseObject(category, new TypeReference<Map<String, List<CategoryJsonVO>>>() {
                });
            }
            log.info("开始查询数据库");
            List<CategoryEntity> list = list();
            Map<String, List<CategoryJsonVO>> map = list.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
                //查出某个一级分类下的所有二级分类
                //            List<CategoryEntity> entityList = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
                List<CategoryEntity> entityList = list.stream().filter(categoryEntity -> categoryEntity.getParentCid().equals(v.getCatId())).collect(Collectors.toList());
                List<CategoryJsonVO> categoryJsonVOS = entityList.stream().map(categoryEntity -> {
                    CategoryJsonVO jsonVO = new CategoryJsonVO();
                    jsonVO.setCatalog1Id(String.valueOf(categoryEntity.getParentCid()));
                    jsonVO.setId(String.valueOf(categoryEntity.getCatId()));
                    jsonVO.setName(categoryEntity.getName());
                    //查出某个二级分类下的所有三级分类
                    //                List<CategoryEntity> entityListThree = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", categoryEntity.getCatId()));
                    List<CategoryEntity> entityListThree = list.stream().filter(categoryEntity1 -> categoryEntity1.getParentCid().equals(categoryEntity.getCatId())).collect(Collectors.toList());
                    List<CategoryJsonVO.CatalogJsonThree> catalogJsonThrees = entityListThree.stream().map(categoryEntity1 -> {
                        CategoryJsonVO.CatalogJsonThree catalogJsonThree = new CategoryJsonVO.CatalogJsonThree();
                        catalogJsonThree.setId(String.valueOf(categoryEntity1.getCatId()));
                        catalogJsonThree.setName(categoryEntity1.getName());
                        catalogJsonThree.setCatalog2Id(String.valueOf(categoryEntity1.getParentCid()));
                        return catalogJsonThree;
                    }).collect(Collectors.toList());
                    jsonVO.setCatalog3List(catalogJsonThrees);
                    return jsonVO;
                }).collect(Collectors.toList());

                return categoryJsonVOS;
            }));
            //向缓存中存一份(序列化)
            stringRedisTemplate.opsForValue().set(RedisConstants.CATEGORY_KEY, CollectionUtils.isEmpty(map) ? "0" : JSON.toJSONString(map), 1, TimeUnit.DAYS);
            return map;

        }
    }

}

2.5 分布式锁1.0版

  下面我们自己先手动实现一个分布式锁：

 	  @Test
    public void testLock(){
        String uuid = UUID.randomUUID().toString();
        //获取锁
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock",uuid);
        //获取到了锁
        if (lock){
            try {
                //设置过期时间
                stringRedisTemplate.expire("lock",300, TimeUnit.SECONDS);
                //执行业务代码
            }catch (Exception e){
                //日志记录异常
            }finally {
                stringRedisTemplate.delete("lock");
            }
        }else {
            //未获取到锁就自旋继续尝试获取
            testLock();
        }

    }

  上面的代码有什么问题？可谓漏洞百出。

  1. 获取锁和设置过期时间分为了两个步骤去实现。：会导致一个什么样的问题？既然是两步，没有写在一条命令里，说明是非原子性的操作。如果两行代码之间出现了异常，那么过期时间就没有设置成功。那么能不能将设置过期时间写在finally块中？答案也是不行的，因为出现异常不仅仅可能是程序方面的异常，假设极端情况下机房停电了…所以为了解决这个问题，需要做如下的改动：
Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock",uuid,300, TimeUnit.SECONDS);
  1. 解锁时没有进行判断：会导致将其他线程的锁误删的问题。例如线程A拿到了锁，由于业务执行的时间较长，线程A的锁超时了，线程B拿到了锁，B在执行自己业务的时候，线程A执行完了业务，释放了B线程的锁…不是那么靠谱的解决方案：
 			if (stringRedisTemplate.opsForValue().get("lock").equals(uuid)){
           stringRedisTemplate.delete("lock");
       }

为什么说这个解决方案不是那么靠谱？引出了第三个问题

  1. 解锁时的条件判断非原子性操作：因为判断+解锁之间也是存在间隔时间的，必须要保证原子性。例如锁设置的key的value是1，设置的过期时间是10S，但是前面的操作花费了9.5S,判断的时间花费了0.6S，相当于key对应的value已经过期了。下一个线程进来又设置key的value是2（实际上lock对应的值变了，但是在判断的时候，获取到的lock的值还是之前的1），然后原来的线程解锁就把下一个线程的锁给解了。解决方案是使用lua脚本，包括后面引入的Redisson的底层很多也是通过lua脚本实现的
			String script = "if redis.call('get', KEYS[1]) == ARGV[1] then
			return redis.call('del', KEYS[1]) else return 0 end";
			//删除锁
			Long lock1 = redisTemplate.execute(new
			DefaultRedisScript<Long>(script, Long.class)
			, Arrays.asList("lock"), uuid);

  通过上述问题的发现与解决，看似我们自己实现的分布式锁没有问题了，其实不然，仔细深究还是会存在锁重入，重试等相关问题。

2.6 分布式锁2.0版

  引入Redisson：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <!-- 请使用最新版本 -->
    <version>3.16.3</version>
</dependency>

  进行配置：

@Configuration
public class RedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://自己的虚拟机地址:6379");
        return Redisson.create(config);
    }

}

  Redisson的基本使用及原理：

@Test
public void testRedisson() {
    RLock lock = redissonClient.getLock("lock");
    //默认过期时间30S，业务在执行完成之前每隔10S续期一次
    //如果设置了过期时间，就按照过期时间来，不会自动续期
    lock.lock();
    try {
    }finally {
        lock.unlock();
    }
}

  通过RLock lock = redissonClient.getLock("lock");可以获取一把锁，只要名称相同就代表是同一把锁。
  除了上面获取锁的方式，还有其他关于锁的操作，在官方文档中都有说明：
在这里插入图片描述Redisson官方文档中文版

  lock.lock();方法，如果没有设置过期时间，它有一个默认的30S过期时间，同时会每隔1/3默认时间自动续期，设置了过期时间，则按照实际的过期时间，即使业务没有执行完成也不会自动续期。
  项目实战篇以应用为主，限于篇幅不翻源码，源码解析会放在源码分析专栏后续更新。
  改造业务代码：

@Autowired
private RedissonClient redissonClient;

/**
 * 从数据库查询三级分类
 * 分布式锁解决缓存击穿
 * @return 查询结果
 */
private Map<String, List<CategoryJsonVO>> getCateGoryFromDB() {
	 //category_lock
    RLock lock = this.redissonClient.getLock(RedisConstants.CATEGORY_LOCK_KEY);
    lock.lock(10, TimeUnit.SECONDS);
    try {
   		-- 业务代码
    } finally {
        lock.unlock();
    }
}

2.7 Spring Cache及缓存一致性问题

2.7.1 Spring Cache

  简单来说，Spring Cache是基于声明式注解的缓存，对于缓存声明，Spring的缓存抽象提供了一组Java注解：

  • @Cacheable: 触发缓存的填充。
  • @CacheEvict: 触发缓存删除。
  • @CachePut: 更新缓存而不干扰方法的执行。
  • @Caching: 将多个缓存操作重新分组，应用在一个方法上。
  • @CacheConfig: 分享一些常见的类级别的缓存相关设置。

  详见Spring官方文档中文版

  在项目中使用，只需要引入依赖，并在配置文件中进行配置：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

# 配置spring cache 为redis
spring.cache.type=redis
spring.cache.redis.time-to-live=360000

  在方法上加入注解：

@Override
@Cacheable(value = {"category"},key = "'getLevelOneCateGory'") //放入缓存 如果缓存中有方法就不调用
public List<CategoryEntity> getLevelOneCateGory() {
    return list(new QueryWrapper<CategoryEntity>().eq("parent_cid", "0"));
}

  启动项目，通过redis客户端查看对应的缓存数据：
在这里插入图片描述  需要注意，默认的序列化方式不是JSON，而是JDK序列化。需要自定义配置：

@Configuration
@EnableCaching
@EnableConfigurationProperties(CacheProperties.class)
public class MyRedisCacheConfig {
    @Bean
    public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        //自定义键值的序列化
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        //自定义键和值的过期时间,从配置文件中读取
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }
        return config;
    }
}
2.7.2 缓存一致性问题

  缓存一致性问题简单来说，就是缓存中的数据和数据库最新的数据不一致，导致用户看到的数据非实时而是旧的缓存中的。
  解决缓存一致性问题，对于数据库写入方，一般有如下几种方案：

  • 先删除缓存再更新数据库
  • 先更新数据库再删除缓存

  上述两种方案都是有弊端的：
在这里插入图片描述
   先删除缓存再更新数据库对应上图的情况，用户读取到的数据还是未更新数据库前旧的数据。
在这里插入图片描述
  如果先更新数据库再删除缓存 也可能存在上图的情况，即如果B线程更新数据库的时间较长，并且此时C线程进行查询，C线程查询到的还是A线程更新数据库的结果，并且将A的操作结果写入缓存，获取到的依旧不是B最新操作的数据。
  既然两者都有弊端，那么就引入了第三种方式：延迟双删在这里插入图片描述  其实无论是何种方式，保证的都是缓存的最终一致性，如果对数据实时性的要求高，且数据更新频繁，应该去查数据库，而不是使用缓存。
  在项目中，采用先更新数据库再删除缓存 的策略，结合注解：

/**
 * 修改
 * 修改时删除缓存
 */
@CacheEvict(value = {"category"},key = "'getLevelOneCateGory'")
@RequestMapping("/update")
public R update(@RequestBody CategoryEntity category){
	categoryService.updateById(category);
    return R.ok();
}
2.7.3 Spring Cache的弊端

  主要体现在解决缓存击穿问题上，在手动编写逻辑时，是通过Redisson分布式锁的方式解决的，而Spring Cache的注解默认是不加锁的，如果加锁，需要在注解中设置sync为true，并且这里的锁是本地锁，非分布式锁。

西岭千秋雪_
关注
  • 12
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《谷粒商城》2020基础篇sql及数据库设计文件
11-23
《谷粒商城》2020基础篇sql及数据库设计文件。项目采用SpringCloudAlibaba技术栈。由业务集群系统+后台管理系统构成，打通了微服务分布式开发及全栈开发技能，包含前后分离全栈开发、Restful接口、数据校验、网关、...
谷粒商城——缓存的读写一致性
qq_45007794的博客
03-24 423
如果修改完数据库，需要保证缓存中的数据也更新为相应的最新值。此时需要在更新数据库之前加上写锁，在更新/删除完缓存后才释放写锁。
谷粒商城-缓存-SpringCache
weixin_56674682的博客
04-30 1581
目录 缓存-SpringCache-简介 缓存-SpringCache-整合&体验@Cacheable 缓存-SpringCache-@Cacheable的细节设置 缓存-SpringCache-自定义缓存配置 缓存-SpringCache-@CacheEvict 缓存-SpringCache-原理与不足 缓存-SpringCache-简介 缓存的编写逻辑：查询缓存，缓存命中从缓存中获取；缓存未命中则从数据库中查询并存入缓存。 对于数据一致性问题可以采用：①双写模式 ②失效
谷粒商城学习-笔记大全
epitomizelu的专栏
07-04 1228
1，谷粒商城-01-项目介绍 2，谷粒商城笔记-02-项目整体效果展示
【谷粒商城】全网最全笔记(1/4)
热门推荐
努力充实，远方可期
06-23 38万+
本文重点记录老师讲的话 和 一些配置流程，笔记中有的内容尽量少记录。 边看视频变更新，我尽快更新。
谷粒商城分布式高级篇总结文档
qq_39564710的博客
02-18 1458
Elasticsearch 举例，mysql中保存一个数据可能是正向索引，每条数据都有id存在这，在电影表中检索红海行动，用like，mysql匹配所有的记录，看每一条记录中是否是红海行动，这样非常慢。 es首先把红海行动拆成两个单词，红海，行动，es中保存1号文档，额外又维护一张倒排索引表，存了红海，和行动的单词，在一号记录里面有，所以如图所示 查询红海特工行动，会查到12345，五条记录，3号和5号都命中两个，但是3号3个单词命中两个，5号四个单词命中两个，根据相关性得分，.
谷粒商城 缓存
qq_51682771的博客
10-20 329
CacheConfig 在类级别共享缓存的相同配置。json需要配一下，不然序列化复杂数据类型会抛异常。@CachePut 不影响方法执行更新缓存。@Caching 组合以上多个操作。@CacheEvict 删除缓存。@Cacheable 保存到缓存。
谷粒商城-缓存使用&分布式锁&SpringCache（5天）
weixin_44925329的博客
01-13 1233
• 我们能放入缓存的数据本就不应该是实时性、一致性要求超高的。所以缓存数据的时候加上过期时间，保证每天拿到当前最新数据即可。• 我们不应该过度设计，增加系统的复杂性• 遇到实时性、一致性要求高的数据，就应该查数据库，即使慢点。/*** 需要将配置文件中的配置设置上* 1、使配置类生效* 1）开启配置类与属性绑定功能EnableConfigurationProperties* 2）注入就可以使用了。
谷粒商城-分布式高级篇-分布式锁与缓存
HGW的博客
04-02 3185
谷粒商城-分布式高级篇-分布式锁与缓存
《谷粒商城2020》高级篇完整代码包括java代码和html
11-30
20210827更新删除了无用的会引起误会的文件夹，基础篇和高级篇分开为两个压缩包，增加了基础篇资料和高级篇资料，以及需要的相关软件，sql文件（在基础篇资料源码中）包含初级篇和高级篇完整代码，纯手工打造，都已...
2020谷粒商城笔记资料，文档课件笔记+源代码（基础篇+高级篇
09-21
2020谷粒商城笔记资料，谷粒商城2020文档课件笔记+源代码（基础篇+高级篇） 谷粒商城2020文档课件笔记+源代码（基础篇+高级篇） 2020谷粒商城笔记资料（基础篇+高级篇） 尚硅谷谷粒商城笔记，很全。基础篇，高级篇...
谷粒商城资料整理课件.zip_谷粒商城课件
07-01
基础篇\课件\谷粒商城-分布式基础-图.pdf 运维篇\课件\K8S部署&DevOps.pdf 高级篇\课件\01、Reactive&WebFlux.pdf 高级篇\课件\02、接口幂等性.pdf 高级篇\课件\03、本地事务&分布式事务.pdf 高级篇\课件\04、性能与...
《谷粒商城》2020基础篇完整代码
11-22
《谷粒商城》2020基础篇完整代码，纯手工打造。完美复刻，教程代码。都已调通。 项目采用SpringCloudAlibaba技术栈。由业务集群系统+后台管理系统构成，打通了微服务分布式开发及全栈开发技能，包含前后分离全栈开发...
vue如何实现路由缓存
weixin_44594219的博客
09-03 585
（以下示例皆是以vue3+vite+ts项目为例）
IDEAJ真正修改maven(.m2)在Windows环境下缓存路径
最新发布
Zhang Phil
09-04 684
1，File -ProjectStructure - Artifacts ，点击上放的 "+"号，在弹出的框中选择 “JAR” - From modules with dependencies...2，弹出框中填上 Main函数所在的主类等信息，再点击 OK3, 此时就可以build出jar包了。IntelliJ IDEA修改默认.m2和.gradle缓存路径_idea设置.m2路径-CSDN博客。虽然C盘user下仍有部分缓存文件，但这不要紧，这是idea的次要索引类文件，很小很少。
redis之缓存淘汰策略
weixin_45116867的博客
09-03 657
当Redis设置了最大内存限制（通过 maxmemory 配置项），并且当前使用的内存达到了这个限制，Redis会根据设定的淘汰策略来移除一些键，以便为新的键腾出内存。需要注意config set maxmwmery命令重启就失效了，想要永久修改，需要编辑redis的配置文件并重启redis服务。数据达到过期时间，不做处理，等下次访问该数据时，如果未过期，返回数据；输出的值为0，0代表redis的最大占用内存等同于服务器的最大内存。定期删除就是基于立即删除和惰性删除的折中的一种删除算法。
前端缓存介绍以及实现方案
weixin_47970316的博客
09-03 968
设置合适的 HTTP 缓存头（如 Cache-Control, ETag, Last-Modified）是实现磁盘缓存的关键。Service Worker 可以提供更精细的缓存控制浏览器会根据缓存策略和资源大小、生命周期自动决定是否将资源存储到磁盘上。HTTP 304：是一种服务器响应状态码，用于确认客户端的缓存副本是最新的，从而避免不必要的数据传输。内存缓存：存储在浏览器内存中，读取速度最快，但生命周期较短，适合短期内频繁使用的资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值