Redis：黑马点评项目之商品缓存

已于 2022-03-27 22:24:17 修改
阅读量2.1k 收藏 8
点赞数 1
文章标签： java spring 开发语言
于 2022-03-27 14:58:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49569564/article/details/123753096
版权

一、缓存更新策略

缓存可以减轻数据库压力，但也会存在数据库与缓存不一致的问题；
如果数据库数据更新，缓存没有更新，那查到的就是缓存中的旧数据；

  1. 内存淘汰：不用自己维护，利用redis内存淘汰机制，当内存不足时淘汰部分数据，下次查询时更新缓存；在一定程度上可以保证一致性；但是这种一致性不是我们能控制的，淘汰哪一部分数据，什么时候淘汰，不确定；好处是没有维护成本；
  2. 超时剔除：给缓存数据添加过期时间TTL,到期自动删除缓存，下次查询更新缓存；这个一致性的强度取决于时间长短；一致性一般，维护成本也低；
  3. 主动更新：自己编写业务逻辑；在修改数据库同时，改缓存；维护成本高；
    根据业务场景选择对应的缓存更新策略：

在这里插入图片描述

二、主动更新策略

1、**Cache Aside Pattern：由缓存的调用者，在更新数据库的同时更新缓存；**用的最多;

Cache Aside Pattern：

1、删除缓存还是更新缓存？
更新缓存，数据库更新n次，缓存就更新n次，如果这n次没有什么查询，那无效写操作较多；
删除缓存，更新数据库时让缓存失效，查询时再更新缓存；用的较多

2、如何保证缓存与数据库的原子性，同时成功或者失败？
单体系统，将缓存与数据库操作放在一个事务里，利用事务本身特性保证；
分布式系统：缓存操作和数据库操作很可能是不同的服务；利用TCC分布式事务方案；

3、先操作缓存还是数据库？
都可以。但综合分析，先操作数据库，再操作缓存比较妥当。
先删除缓存，再操作数据库；
如果有线程安全问题，线程1与线程2同时对缓存和数据库操作，由于缓存的读写速度远高于数据库的读写速度，最终造成缓存与数据库不一致的概率还是较高的；

先操作数据库，再删缓存；在此操作上，可以在最后写缓存加上一个过期时间；
在这里插入图片描述

2、Read/Write Through Pattern : 缓存与数据库整合为一个服务，由服务来维护一致性。调用者调用该服务，无需关心缓存一致性问题；
3、Write Behind Caching Pattern : 调用者会操作缓存，由其他线程将缓存数据持久化到数据库；但是这种方法不能保证最终一致；

在这里插入图片描述

三、缓存穿透

客户端请求的数据在缓存和数据库都不存在，这样缓存永远不会生效，这些请求都会落到数据库；一般外部攻击，不断用不存在的数据请求数据库，最终造成数据库压力过大崩溃；

解决方案：
1、缓存空对象
在这里插入图片描述
2、布隆过滤：
内存占用少，没有多余的key;实现复杂，存在误判可能
在这里插入图片描述

在这里插入图片描述

/**
     * 获取店铺详情（通过设置null解决缓存穿透问题）
     *
     * @param id
     * @return {@link Result}
     */
private Result getShopByIdWithCacheCross(Long id) {
        // 1、先查询redis
        String shopJson = redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 在redis有，返回,将json串转为
        if (StrUtil.isNotBlank(shopJson)) {
            // 这里的isNotBlank 方法 为null,为"",为”\t“都返回false
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        // 判断命中的是否是空字符串
        if (shopJson != null) {
            // 如果不是null空值，那一定是空字符串
            return Result.fail("店铺不存在");
        }
        // 2、redis没有，再查数据库
        Shop shop = getById(id);
        // 3、数据库没有，返回错误
        if (Objects.isNull(shop)) {
            // 解决缓存穿透，缓存一个空字符串
            redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("店铺不存在");
        }
        // 将查到的数据存入redis,设置过期时间为30min
        redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return Result.ok(shop);
    }

四、缓存雪崩

同一时段内，缓存key大面积失效或者redis服务宕机，导致请求落到数据库上，带来巨大压力；

解决方案：

  1. 给不同的key的过期时间，设置一个随机值；可以提前把一些导入到缓存中，在ttl后面可以跟上一个随机数，让过期时间分散在各个时间段，避免缓存同一时间大面积失效；
  2. **宕机情况：**利用redis集群，哨兵机制，提高服务的可用性；主从可以实现数据的同步；
  3. 给缓存业务添加降级限流策略；快速失败，降级服务；
  4. 给业务添加多级缓存；nginx缓存、redis缓存、层层加缓存；
    在这里插入图片描述

五、缓存击穿

缓存击穿问题也叫热点key问题，缓存中没有但数据库中有的数据，就是被一个高并发访问，并且缓存重建业务复杂的key突然失效了；无数的请求在瞬间给数据库带来巨大冲击；

解决方案：

1、利用互斥锁；
缺点：锁未释放，互相等待；其他线程就会一直等待，阻塞，导致性能问题；
在这里插入图片描述

2、逻辑过期；
在这里插入图片描述

在这里插入图片描述

六、用互斥锁解决缓存击穿问题

利用setNx命令；这个命令只有key不存在才会设置成功；

在这里插入图片描述

/**
     * 获取店铺详情（通过互斥锁解决缓存击穿问题）
     *
     * @param id
     * @return {@link Result}
     */
    private Shop getShopByIdWithCacheStave(Long id) {
        // 1、先查询redis
        String shopJson = redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 在redis有，返回,将json串转为
        if (StrUtil.isNotBlank(shopJson)) {
            // 这里的isNotBlank 方法 为null,为"",为”\t“都返回false
            return JSONUtil.toBean(shopJson, Shop.class);
        }
        // 判断命中的是否是空字符串
        if (shopJson != null) {
            // 如果不是null空值，那一定是空字符串
            return null;
        }
        // 2.1、redis没有，未命中，尝试获取锁  注意，lockKey与商铺key不一样
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        // 2.2判断是否获取了锁，如果未拿到，重试，循环，设置休眠时间
        Shop shop;
        try {
            if (!tryLock(lockKey)) {
                // 设置休眠时间
                Thread.sleep(10);
                return getShopByIdWithCacheStave(id);
            }
            // 2.3拿到了锁，再查数据库
            shop = getById(id);
            // todo 模拟重建的测试
            Thread.sleep(200);
            // 3、数据库没有，返回null
            if (Objects.isNull(shop)) {
                // 解决缓存穿透，缓存一个空字符串
                redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            // 将查到的数据存入redis,设置过期时间为30min
            redisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop), RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 4、try-catch-finally 无论抛不抛异常，最后都要释放锁
            realeseLock(lockKey);
        }
        return shop;
    }

 /**
     * 获取锁
     *
     * @param key
     * @return {@link boolean}
     */
    private boolean tryLock(String key) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, "1", 2, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(result);
    }

    /**
     * 释放锁
     *
     * @param key
     * @return {@link boolean}
     */
    private void realeseLock(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 重建缓存数据，RedisData
     *
     * @param id
     * @param expireTime
     * @return {@link boolean}
     */
    @Override
    public boolean saveHotData(Long id, Long expireTime) throws InterruptedException {

        String key = RedisConstants.CACHE_SHOP_KEY + id;
        Shop shop = getById(id);
        // 重建，模拟
        Thread.sleep(20L);
        if (Objects.nonNull(shop)) {
            RedisData data = new RedisData();
            // 设置比当前时间晚几个秒
            data.setExpireTime(LocalDateTime.now().plusSeconds(expireTime));
            data.setData(shop);
            redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(data));
            return Boolean.TRUE;
        } else {
            return Boolean.FALSE;
        }

    }

七、利用逻辑过期解决缓存击穿

在这里插入图片描述

/**
     * 获取店铺详情（通过逻辑过期解决缓存击穿问题）
     *
     * @param id
     * @return {@link Result}
     */
   private Shop getShopByIdWithLogicalExpire(Long id) {
        // 1、先查询redis
        String shopJson = redisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // redis没有，未命中,返回null
        if (StrUtil.isBlank(shopJson)) {
            // 未命中，返回空
            return null;
        }
        // 2.1、redis有，命中，判断过期时间
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        // 2.2 过期时间在当前时间之后，未过期，返回shop
        RedisData data = JSONUtil.toBean(shopJson, RedisData.class);
        Shop toShop = JSONUtil.toBean((JSONObject) data.getData(), Shop.class);
        if (data.getExpireTime().isAfter(LocalDateTime.now())) {
            // 过期时间在当前时间之后，未过期，返回shop
            return toShop;
        }
        // 2.3 过期了，获取互斥锁，判断是否获取互斥锁
        boolean isGetLock = tryLock(lockKey);
        // 3.1 有互斥锁，重建，新开启一个线程，根据id查询数据库，将数据库数据写入redis
        if (isGetLock) {

            CACHE_EXPIRE_EXECUTOR.submit(() -> {
                try {
                    this.saveHotData(id, 20L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放锁
                    realeseLock(lockKey);
                }
            });

        }
        // 3.2 没有互斥锁。返回旧的商品信息
        return toShop;
    }

八、缓存工具封装

在这里插入图片描述

     private final StringRedisTemplate redisTemplate;

    /**
     * 构造函数注入redisTemplate
     * @param redisTemplate
     */
    public RedisCacheClient(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 将任意对象序列化json对象并存储在String类型的key中，并且可以设置过期时间
     */
    public void setExpireTime(String key, Object value, Long expireTime, TimeUnit timeUnit){
        redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),expireTime,timeUnit);
    }

    /**
     * 将任意对象序列化json对象并存储在String类型的key中，并且可以设置逻辑过期时间，处理缓存击穿问题
     */
    public void setLogicalExpireTime(String key, Object value, Long expireTime, TimeUnit timeUnit){
        RedisData data = new RedisData();
        // 设置逻辑过期时间，比当前时间晚 timeUnit 分钟/秒/小时
        // 传进来的expireTime不能确定是秒，所以把它转成秒
        data.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(expireTime)));
        data.setData(value);
        redisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(data));
    }

    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，利用缓存控制的方式解决缓存穿透问题
     * @param keyPrefix key的前缀
     * @param id id为泛型，不确定它的类型，不一定是long，只有用到的时候才会确定
     * @param objectType 具体要用到的对象类型
     * @param dbCallback 要根据id查询具体返回数据库对象的函数式方法
     * @param time 过期时间
     * @param unit 时间单位
     * @return {@link R}
     */
    public <R,ID> R getObjectWithCacheCross(String keyPrefix, ID id, Class<R> objectType, Function<ID,R> dbCallback , Long time, TimeUnit unit) {
        // KEY
        String key = keyPrefix + id;
        // 1、先查询redis
        String shopJson = redisTemplate.opsForValue().get(key);
        // 在redis有，返回,将json串转为
        if (StrUtil.isNotBlank(shopJson)) {
            // 这里的isNotBlank 方法 为null,为"",为”\t“都返回false
            return JSONUtil.toBean(shopJson, objectType);
        }
        // 判断命中的是否是空字符串
        if (shopJson != null) {
            // 如果不是null空值，那一定是空字符串
            return null;
        }
        // 2、redis没有，再查数据库
        R r = dbCallback.apply(id);
        // 3、数据库没有，返回错误
        if (Objects.isNull(r)) {
            // 解决缓存穿透，缓存一个空字符串
            redisTemplate.opsForValue().set(key, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        // 将查到的数据存入redis,设置过期时间为30min
        this.setExpireTime(key, r, time, unit);
        return r;
    }

    /**
     * 过期时间线程池
     */
    private static final ExecutorService CACHE_EXPIRE_EXECUTOR = Executors.newFixedThreadPool(10);


    /**
     * 根据指定的key查询缓存，并反序列化为指定类型，利用逻辑过期的方式解决缓存击穿问题
     * @param keyPrefix key的前缀
     * @param id id为泛型，不确定它的类型，不一定是long，只有用到的时候才会确定
     * @param objectType 具体要用到的对象类型
     * @param dbCallback 要根据id查询具体返回数据库对象的函数式方法
     * @param time 过期时间
     * @param unit 时间单位
     * @return {@link R}
     */
    public <R,ID> R getObjectWithLogicalExpire(String keyPrefix, ID id, Class<R> objectType, Function<ID,R> dbCallback , Long time, TimeUnit unit) {
        // key
        String key = keyPrefix + id;
        // 1、先查询redis
        String shopJson = redisTemplate.opsForValue().get(key);
        // redis没有，未命中,返回null
        if (StrUtil.isBlank(shopJson)) {
            // 未命中，返回空
            return null;
        }
        // 2.1、redis有，命中，判断过期时间
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        // 2.2 过期时间在当前时间之后，未过期，返回shop
        RedisData data = JSONUtil.toBean(shopJson, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) data.getData(), objectType);
        if (data.getExpireTime().isAfter(LocalDateTime.now())) {
            // 过期时间在当前时间之后，未过期，返回shop
            return r;
        }
        // 2.3 过期了，获取互斥锁，判断是否获取互斥锁
        boolean isGetLock = tryLock(lockKey);
        // 3.1 有互斥锁，重建，新开启一个线程，根据id查询数据库，将数据库数据写入redis
        if (isGetLock) {
            CACHE_EXPIRE_EXECUTOR.submit(() -> {
                try {
                    // 缓存重建
                    // 1.1 更新数据库,这里不知道具体用到的逻辑，用函数先apply，执行
                    R r1 = dbCallback.apply(id);
                    // 1.2再写入缓存
                    this.setLogicalExpireTime(lockKey,r1,time,unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    realeseLock(lockKey);
                }
            });

        }
        // 3.2 没有互斥锁。返回旧的商品信息
        return r;
    }


    /**
     * 获取锁
     *
     * @param key
     * @return {@link boolean}
     */
    private boolean tryLock(String key) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(key, "1", 2, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(result);
    }

    /**
     * 释放锁
     *
     * @param key
     * @return {@link boolean}
     */
    private void realeseLock(String key) {
        redisTemplate.delete(key);
    }
m0_49569564
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
商品详情优化——利用redis进行缓存
weixin_58153822的博客
11-05 957
商品优化详情，利用redis进行缓存，以及解决缓存击穿、缓存穿透、缓存雪崩问题。
【Redis】Redis实战：黑马点评之商户查询缓存
qq_50675319的博客
09-17 1190
在原来的业务逻辑中，如果用户查询缓存未命中，会去直接查询数据库，在这种情况下，如果用户查询的是热点数据且缓存重建比较复杂，就容易出现缓存击穿问题，这里我们可以假设商铺查询就是热点数据，需要针对缓存击穿问题设计相应的解决方案 相较于原来从缓存中查询不到数据后直接查询数据库而言，现在的方案是进行查询之后，如果从缓存未命中，则进行互斥锁的获取，获取互斥锁后，判断是否获得到了锁，如果没有获得锁，则休眠，过一段时间再对上述业务逻辑进行重试，获取到锁的线程可以需要去查询数据库并将数
基于Redis缓存商城分类以及商品信息Demo
10-15
基于Redis缓存商城分类以及商品信息，实现商城数据高速精确访问，源码，jar包
一篇文章学会Redis-redis缓存商品
wangzhenxing991026的博客
09-21 2033
我们常学的数据库是MySQl，Redis，Oracle 其中MySQl，Oracle是关系型数据库，而Redis是就是NoSQl（Not Only SQl)，意味“不仅仅是SQL",是一项全新的数据库理念，泛指非关系型的数据库。而Redis就是非关系型数据库 关系型数据库与非关系型数据库的区别 1） 关系型数据库特点（Mysql Oracle SqlServer） 数据是由一张张的表组成，而且这些表与表之间有关系（一对一，一对多，多对多） 数据是存在硬盘上，每次访问时，是将数据从硬盘读取到内存中
面试项目准备：黑马点评项目总结
最新发布
LSP20020926的博客
07-25 1559
使用 Redis 解决了在集群模式下的 Session共享问题,使用拦截器实现用戶的登录校验和权限刷新基于Cache Aside模式解决数据库与缓存的一致性问题使用 Redis 对高频访问的信息进行缓存 ，降低了数据库查询的压力 ,解决了缓存穿透、雪崩、击穿问题使用 Redis + Lua脚 本实现对用戶秒杀资格的预检 ，同时用乐观锁解决秒杀产生的超卖问题使用Redis分布式锁解决了在集群模式下一人一单的线程安全问题基于stream结构作为消息队列,实现异步秒杀下单。
redis商品详情的缓存
qq_25881443的博客
10-17 749
redis实现商品查询缓存【解决常见问题】
小柚的博客
10-26 1154
当我们客户端访问不存在的数据时，先请求redis，但是此时redis中没有数据，此时会访问到数据库，但是数据库中也没有数据，这个数据穿透了缓存，直击数据库，我们都知道数据库能够承载的并发不如redis这么高，如果大量的请求同时过来访问这种不存在的数据，这些请求就都会访问到数据库，简单的解决方案就是哪怕这个数据在数据库中也不存在，我们也把这个数据存入到redis中去，这样，下次用户过来访问这个不存在的数据，那么在redis中也能找到这个数据就不会进入到缓存了。因为锁能实现互斥性。
【Redis】Redis实战：黑马点评之秒杀优化
qq_50675319的博客
09-21 1070
通过加锁可以解决在单机情况下的一人一单安全问题，但是在集群模式下就不行了。1.我们将服务启动两份，端口分别为8081和8082：2.然后修改nginx的conf目录下的nginx.conf文件，配置反向代理和负载均衡：3.重新加载nginx，命令为4.经过测试，最终发现在集群模式下，有多少个服务，用户最多就能下多少单，也就是说在集群模式下，我们之前使用的悲观锁失效了为什么会出现上述现象呢？
菜鸟项目练习：黑马点评项目总结
热门推荐
qq_47960640的博客
11-15 1万+
用来配合学习Redis的知识。1.1 项目使用的技术栈1.2项目架构采用单体架构后端部署在Tomcat上，前端部分部署在Nginx。
travel:黑马旅游网项目
05-26
黑马旅游网项目 SQL数据库文件在resources文件夹下 登录注册功能 注册需要发送邮件激活，发送需要需要先修改自己的代码设置自己邮箱的地址和授权码。 为了保证账户激活的唯一性设置了32随机码 网站首页的分类数据是...
redis多级缓存搭建资料
05-31
结合实际业务场景，例如电商网站的商品详情页，可以先从本地缓存（如JVM内存）查找商品信息，未命中再查询Redis一级缓存，最后若仍无结果，则访问数据库并将数据存入二级缓存。 总结，Redis多级缓存的搭建涉及到多...
黑马点评给店铺类型查询业务添加缓存（List实现)
Blocking The Sky
06-28 257
【代码】黑马点评给店铺类型查询业务添加缓存（List实现)
使用redis实现商品的缓存
V1363的博客
08-21 1439
使用redis实现商品的缓存redis做缓存，因为redis是跑在内存中的故速度快1.在要实现商品缓存的dubbo_product消费者模块下2.dubbo_redis模块pom和application配置（配置集群版redis）3.总结 redis做缓存，因为redis是跑在内存中的故速度快 1.在要实现商品缓存的dubbo_product消费者模块下 1.首先pom里面要依赖配置文件，application.yml也要加载redis配置文件 application.yml: 2.ProductSe
淘淘商城第78讲——查询商品详情添加缓存的分析
李阿昀的博客
06-11 4104
通过上文的学习，我相信大家一定实现了商品详情页面展示，接下来我们将学习如何在商品详情页面展示时添加缓存。 因为查询商品详情涉及到查询数据库，当网站访问量很大时，查询商品详情都去查询数据库的话，数据库的压力是难以承受的，为了解决这个问题就要引入缓存了，即使用Redis做缓存。但是引入缓存又有一个问题需要考虑，那就是缓存资源是非常有限的，如果我们把大量的商品详情信息都放到缓存当中的话，缓存的压力是非常
[参考]redis存储商品信息，自增订单或商品id，缓存评论！
u012572955的专栏
04-22 8820
RedisKeyUtils public class RedisKeyUtils { //商品id自增key public final static String ITEMS_ID = "ITEMS:ID"; //商品排行榜key public static final String ITEMS_SELLSORT = "ITEMS:SELLSORT"; //商品信息key
SSM秒杀系统（九）商品详情页添加redis缓存
张毅的博客
05-07 788
该部分引入了redis缓存。 为什么要使用redis缓存，我们不是已经添加了ehcache缓存吗？ 首先redis缓存相比于ehcache具有一定优势： 集群环境下，那么每台服务器的ehcache是不同步的，这样会出问题的，ehcache只适合单机环境 redis是设置单独的缓存服务器，所有集群服务器统一访问redis，不会出现缓存不同步的情况，也就是redis缓存是共享的 并且redis的效率...
黑马点评作业P37_店铺类型查询业务添加缓存
m0_73865631的博客
11-02 509
首先是ShopTypeController。然后service层添加方法。
Nginx+Lua+redis， 商品详情页缓存技术
勇往直前
02-19 1472
需要使用openresty软件 1  lua配置     test.lua 需要写入缓存逻辑 \#user nobody; worker_processes 2; error_log logs/error.log; events { worker_connections 1024; } http { include mime....
Redis实战黑马点评(商户查询缓存)
m0_59166421的博客
09-13 106
采用主动更新的策略使用双写的方案在读的事后加入了有效时间在写的操作使用先更新数据库然后在操作缓存。
黑马点评项目实战：Redis应用与优化笔记
"该资源是关于黑马点评项目的个人笔记和项目优化调整，主要涉及Redis的使用，以及Java项目实践。笔记作者强调了Redis工具类的封装和分布式ID的生成作为重点学习内容，同时提到了项目中采用的Redis消息队列在实际应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值