Caffeine——5 分钟学会 Caffeine，轻松优化你的项目

已于 2025-04-17 15:24:06 修改
阅读量776 收藏 30
点赞数 13
文章标签： spring java spring boot caffe
于 2025-04-17 09:56:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51161807/article/details/147294119
版权

一、Caffeine 简介

Caffeine 是一个高性能的 Java 缓存库，提供了接近最佳的命中率。它是 Google Guava Cache 的改进版本，广泛应用于需要高效缓存的场景。Caffeine 的设计目标是提供灵活、线程安全的缓存机制，支持多种淘汰策略和配置。

主要特性

  1. 高性能：基于 ConcurrentHashMap 实现，提供了极高的并发性能。
  2. 多种淘汰策略：
    • 基于大小的淘汰（maximum size）。
    • 基于时间的淘汰（expire after access/write）。
    • 基于引用（弱引用、软引用）。
  3. 异步加载：支持异步缓存加载，适合高并发场景。
  4. 统计功能：提供缓存命中率、加载时间等统计信息。
  5. 轻量级：API 简洁，易于集成。

二、Caffeine 的核心概念

  1. Cache：基本的缓存接口，支持手动加载数据。
  2. LoadingCache：自动加载缓存，当缓存未命中时自动调用加载函数。
  3. AsyncCache 和 AsyncLoadingCache：异步版本的缓存，适合需要非阻塞操作的场景。
  4. Eviction（淘汰）：
    • Size-based：当缓存大小超过限制时，移除最少使用的条目（LRU）。
    • Time-based：基于访问时间或写入时间设置过期。
    • Reference-based：使用弱引用或软引用进行垃圾回收。
  5. Refresh：支持在指定时间后自动刷新缓存条目。

三、Caffeine 的主要 API

  1. 构建缓存：

    • 使用 Caffeine.newBuilder() 创建缓存配置。
    • 配置项包括：
      • maximumSize(long)：最大缓存条目数。
      • expireAfterAccess(Duration)：最后访问后多久过期。
      • expireAfterWrite(Duration)：写入后多久过期。
      • refreshAfterWrite(Duration)：写入后多久刷新。
      • weakKeys() / weakValues()：使用弱引用。
      • recordStats()：启用统计功能。

  2. 操作缓存：

    • cache.get(key, mappingFunction)：获取或加载值。
    • cache.put(key, value)：手动放入值。
    • cache.invalidate(key)：移除缓存条目。
    • cache.cleanUp()：手动触发清理过期条目。

  3. 统计：

    • cache.stats()：获取缓存统计信息（如命中率、平均加载时间）。

四、代码示例

1. 基本缓存使用

以下示例展示如何创建一个简单的 Caffeine 缓存，设置最大大小为 100，访问后 10 秒过期。

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.Cache;

import java.util.concurrent.TimeUnit;

public class BasicCaffeineExample {
    public static void main(String[] args) {
        // 创建缓存：最大100条，访问后10秒过期
        Cache<String, String> cache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterAccess(10, TimeUnit.SECONDS)
                .build();

        // 放入数据
        cache.put("key1", "value1");

        // 获取数据
        String value = cache.getIfPresent("key1");
        System.out.println("key1 的值: " + value);

        // 使用 get 方法，miss 时提供默认值
        String value2 = cache.get("key2", k -> "defaultValue");
        System.out.println("key2 的值: " + value2);
    }
}

输出：

key1 的值: value1
key2 的值: defaultValue

2. LoadingCache 自动加载

以下示例展示如何使用 LoadingCache 自动加载数据。

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;

import java.util.concurrent.TimeUnit;

public class LoadingCacheExample {
    public static void main(String[] args) {
        // 创建 LoadingCache，自动加载数据
        LoadingCache<String, String> cache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .build(key -> loadValue(key));

        // 获取数据，自动触发加载
        String value = cache.get("key1");
        System.out.println("key1 的值: " + value);

        // 批量获取
        System.out.println("批量获取: " + cache.getAll(java.util.Arrays.asList("key1", "key2")));
    }

    private static String loadValue(String key) {
        // 模拟从数据库加载数据
        return "value-for-" + key;
    }
}

输出：

key1 的值: value-for-key1
批量获取: {key1=value-for-key1, key2=value-for-key2}

3. 异步加载缓存

以下示例展示如何使用 AsyncLoadingCache 进行异步加载。

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.AsyncLoadingCache;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class AsyncCacheExample {
    public static void main(String[] args) throws Exception {
        // 创建异步 LoadingCache
        AsyncLoadingCache<String, String> cache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .buildAsync(key -> loadValueAsync(key));

        // 异步获取数据
        CompletableFuture<String> future = cache.get("key1");
        System.out.println("key1 的值: " + future.get());

        // 批量异步获取
        CompletableFuture<?> all = cache.getAll(java.util.Arrays.asList("key1", "key2"));
        System.out.println("批量获取: " + all.get());
    }

    private static CompletableFuture<String> loadValueAsync(String key) {
        // 模拟异步加载
        return CompletableFuture.supplyAsync(() -> "value-for-" + key);
    }
}

输出：

key1 的值: value-for-key1
批量获取: {key1=value-for-key1, key2=value-for-key2}

4. 统计缓存性能

以下示例展示如何启用统计并查看缓存的命中率等信息。

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;

import java.util.concurrent.TimeUnit;

public class CacheStatsExample {
    public static void main(String[] args) {
        // 创建缓存并启用统计
        LoadingCache<String, String> cache = Caffeine.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .recordStats()
                .build(key -> "value-for-" + key);

        // 触发多次访问
        cache.get("key1");
        cache.get("key1");
        cache.get("key2");

        // 打印统计信息
        System.out.println("缓存统计: " + cache.stats());
    }
}

输出（示例，可能因运行环境不同而变化）：

缓存统计: CacheStats{hitCount=1, missCount=2, loadSuccessCount=2, loadFailureCount=0, totalLoadTime=..., evictionCount=0, evictionWeight=0}

五、Caffeine 的使用场景

  1. Web 应用：缓存用户会话、页面数据等。
  2. 数据库查询缓存：减少数据库查询压力。
  3. 配置管理：缓存动态加载的配置信息。
  4. 高并发场景：利用异步加载提升性能。

六、注意事项

  1. 内存管理：合理设置 maximumSize，避免内存溢出。
  2. 过期策略：根据业务场景选择合适的淘汰策略（访问后过期 vs 写入后过期）。
  3. 线程安全：Caffeine 是线程安全的，但加载函数需要确保线程安全。
  4. 异步加载：异步缓存需要妥善处理异常和超时。

七、依赖引入

在 Maven 项目中引入 Caffeine：

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version>
</dependency>

八、Caffeine 高级用法

1. 自定义淘汰策略

Caffeine 允许通过 weigher 和 evictionListener 自定义淘汰逻辑：

  • Weigher：为缓存条目指定权重，代替简单的条目计数。
  • EvictionListener：监听被淘汰的条目，用于记录或触发后续操作。
示例：自定义权重和淘汰监听
import com.github.benmanes.caffeine.cache.*;

import java.util.concurrent.TimeUnit;

public class CustomEvictionExample {
    public static void main(String[] args) {
        // 创建缓存，设置最大权重为100，并监听淘汰事件
        Cache<String, String> cache = Caffeine.newBuilder()
                .maximumWeight(100)
                .weigher((String key, String value) -> key.length() + value.length()) // 权重为键值长度之和
                .evictionListener((key, value, cause) -> 
                    System.out.println("淘汰: key=" + key + ", value=" + value + ", 原因=" + cause))
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .build();

        // 存入数据
        cache.put("key1", "value1"); // 权重: 4 + 6 = 10
        cache.put("key2", "long-value2"); // 权重: 4 + 11 = 15
        cache.put("largeKey", "very-large-value"); // 权重: 8 + 15 = 23

        // 触发淘汰
        cache.put("newKey", "another-large-value"); // 可能导致淘汰
    }
}

输出（示例，可能因实际淘汰顺序不同）：

淘汰: key=key1, value=value1, 原因=SIZE

说明：

  • weigher 计算键值对的内存占用（这里简化为字符串长度）。
  • evictionListener 记录淘汰原因（如 SIZE 表示因大小限制淘汰）。

2. 刷新策略

Caffeine 支持 refreshAfterWrite，在指定时间后异步刷新缓存条目，而不会直接过期。这对于需要保持数据新鲜但不希望阻塞读取的场景（如热点数据）非常有用。

示例：异步刷新
import com.github.benmanes.caffeine.cache.*;

import java.util.concurrent.TimeUnit;

public class RefreshExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建 LoadingCache，写入后5秒刷新
        LoadingCache<String, String> cache = Caffeine.newBuilder()
                .refreshAfterWrite(5, TimeUnit.SECONDS)
                .build(key -> loadValue(key));

        // 第一次获取
        System.out.println("第一次获取: " + cache.get("key1"));

        // 等待刷新触发
        Thread.sleep(6000);
        System.out.println("刷新后获取: " + cache.get("key1"));
    }

    private static String loadValue(String key) {
        // 模拟加载新数据
        return "value-for-" + key + "-" + System.currentTimeMillis();
    }
}

输出（示例）：

第一次获取: value-for-key1-1698765432100
刷新后获取: value-for-key1-1698765438100

说明：

  • refreshAfterWrite 不会让条目立即失效，而是异步调用加载函数。
  • 读取时返回旧值，直到新值加载完成。

3. 两级缓存（结合 Redis）

具体看我上篇的Caffeine+Redis实现两级缓存

九、Caffeine 优化技巧

  1. 批量加载优化：

    • 实现 CacheLoader.loadAll 方法，减少多次数据库查询。

    • 示例（参考你的问题关于 loadAll）：

      LoadingCache<String, String> cache = Caffeine.newBuilder()
    .build(new CacheLoader<String, String>() {
        @Override
        public String load(String key) {
            return loadFromDatabase(key);
        }

        @Override
        public Map<String, String> loadAll(Iterable<? extends String> keys) {
            // 批量查询数据库
            Map<String, String> result = new HashMap<>();
            for (String key : keys) {
                result.put(key, loadFromDatabase(key));
            }
            return result;
        }
    });

  2. 异步加载优化：

    • 使用 AsyncLoadingCache 避免阻塞主线程。

    • 配置线程池（如 ForkJoinPool）以控制加载线程：

      Caffeine.newBuilder()
    .executor(ForkJoinPool.commonPool())
    .buildAsync(key -> loadValueAsync(key));

  3. 统计分析：

    • 启用 recordStats()，定期分析命中率，调整 maximumSize 或过期时间。
    • 示例：通过 cache.stats().hitRate() 检查命中率，若低于预期，增加缓存容量。

  4. 热点数据处理：

    • 对于热点数据，使用 refreshAfterWrite 保持新鲜度。
    • 结合 Redis Pub/Sub（如你的 initPubSub 场景）广播失效消息，确保分布式环境一致性。

十、常见问题及解决方案

  1. 缓存穿透：

    • 问题：查询不存在的键导致频繁访问数据库。

    • 解决：缓存空值或使用布隆过滤器。

    • 示例：

      String value = cache.get(key, k -> {
    String dbValue = loadFromDatabase(k);
    return dbValue != null ? dbValue : "NULL"; // 缓存空值
});

  2. 缓存雪崩：

    • 问题：大量缓存同时过期，导致数据库压力激增。

    • 解决：设置随机过期时间或使用 refreshAfterWrite。

    • 示例：

      Caffeine.newBuilder()
    .expireAfterWrite(Duration.ofSeconds(ThreadLocalRandom.current().nextInt(5, 15)));

  3. 内存溢出：

    • 问题：缓存条目过多导致 OOM。
    • 解决：严格设置 maximumSize 或使用 weigher 控制内存。

  4. 布隆过滤器结合Caffeine实现过滤案例

    <dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.0.0-jre</version>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.8</version>
</dependency>

    public class BloomFilterCacheExample {
    // 布隆过滤器：预期插入10万个元素，假阳性率0.01
    private final BloomFilter<String> bloomFilter = BloomFilter.create(
            Funnels.stringFunnel(StandardCharsets.UTF_8),
            100_000, // 预期元素数量
            0.01);   // 假阳性率  即误判率

    // Caffeine 缓存：最大1000条，访问后10秒过期
    private final Cache<String, String> cache = Caffeine.newBuilder()
            .maximumSize(1_000)
            .expireAfterAccess(10, TimeUnit.SECONDS)
            .build();

    // 初始化布隆过滤器（模拟从数据库加载已有键）
    public void initBloomFilter() {
        // 假设数据库中已有的键
        String[] existingKeys = {"user1", "user2", "user3"};
        for (String key : existingKeys) {
            bloomFilter.put(key);
        }
    }

    // 查询方法
    public String get(String key) {
        // 1. 检查布隆过滤器
        if (!bloomFilter.mightContain(key)) {
            System.out.println("布隆过滤器判定: " + key + " 不存在");
            return null; // 直接返回，跳过缓存和数据库
        }

        // 2. 查询 Caffeine 缓存
        String value = cache.get(key, k -> loadFromDatabase(k));
        return value;
    }

    // 模拟数据库查询
    private String loadFromDatabase(String key) {
        // 模拟数据库：只有特定键存在
        if (key.equals("user1") || key.equals("user2") || key.equals("user3")) {
            String value = "data-for-" + key;
            bloomFilter.put(key); // 确保布隆过滤器包含有效键
            return value;
        }
        // 不存在的键返回空值并缓存
        return "NULL"; // 缓存空值防止重复查询
    }

    // 失效缓存
    public void invalidate(String key) {
        cache.invalidate(key);
        // 注意：标准布隆过滤器不支持删除，可定期重建
    }

    public static void main(String[] args) {
        BloomFilterCacheExample example = new BloomFilterCacheExample();
        example.initBloomFilter();

        // 测试存在的键
        System.out.println("查询 user1: " + example.get("user1"));
        // 测试不存在的键
        System.out.println("查询 user999: " + example.get("user999"));
        // 测试缓存空值
        System.out.println("再次查询 user999: " + example.get("user999"));
    }
}

    输出：

    查询 user1: data-for-user1
布隆过滤器判定: user999 不存在
查询 user999: null
布隆过滤器判定: user999 不存在
再次查询 user999: null

  5. 布隆过滤器优化建议

    • 根据实际数据量调整 expectedInsertions 和 fpp（假阳性率）

    • 将布隆过滤器存储在 Redis（如 redisson 提供的 RBloomFilter），实现分布式共享。

    • 由于布隆过滤器不能删除值，为避免布隆过滤器过载，定期从数据库重建（如每天定时任务）。

阿畅AHNU
关注
本地缓存Caffeine使用教程
tttalk的博客
11-27 3706
Caffeine是一个基于Java1. 8的高性能本地缓存库。它提供了灵活的缓存配置选项，如缓存大小限制、过期策略、驱逐策略等。Caffeine是由guava演变而来的，性能和内存占用都优于guava，它的底层数据存储采用ConcurrentHashMap，从功能上可以将Caffeine视为带有淘汰策略的ConcurrentHashMap。Caffeine的Github网址。
Caffeine 项目使用教程
gitblog_00154的博客
09-26 583
Caffeine 项目使用教程 caffeine Livecode the Web! 项目地址: https://gitcode.com/gh_mirrors/caffei/caffeine ...
【本地缓存】caffeine缓存详解
最新发布
m0_74289770的博客
04-01 1979
给大家介绍一下本地缓存的使用，因为二级缓存是开发中必须要掌握的，可以很大程度上提供数据获取的性能，本篇主要给大家介绍的是caffeine。什么样的数据适合存到缓存里？最简单的就一句话：读多写少的数据。数据不需要频繁更改的数据就很适合存到缓存中，因为它在缓存里读取得更快，不需要在想数据库发送网络请求。当然还有一个重要的因素就是数据的一致性问题，需强一致性的数据，如果非必要，就不用存到缓存当中。废话不多说，直接先教大家怎么使用，再细讲里面的配置。
Caffeine教程
做的过程自我总结
02-09 1953
如果是想直接看官网教程的请移步：https://github.com/ben-manes/... 而如果还想结合实际应用场景，以及各种坑的，请看本文。 最近来了一个实习生小张，看了我在公司项目中使用的缓存框架Caffeine，三天两头跑来找我取经，说是要把Caffeine吃透，为此无奈的也只能一个个细心解答了。 后来这件事情被总监直到了，说是后面还有新人，让我将相关问题和细节汇总成一份教程，权当共享好了，该份教程也算是全网第一份，结合了目前我司游戏中业务场景的应用和思考，以及踩过的坑。 实习生小张：
UPnP PortMapper 项目教程
gitblog_00591的博客
08-19 317
UPnP PortMapper 项目教程 portmapperA tool for managing port forwardings via UPnP项目地址:https://gitcode.com/gh_mirrors/po/portmapper 1. 项目的目录结构及介绍 目录结构 portmapper/ ├── src/ │ ├── main/ │ │ ├── java/ │...
Caffeine 开源项目使用教程
gitblog_00750的博客
08-26 272
Caffeine 开源项目使用教程 caffeineSpeed up your Android development项目地址:https://gitcode.com/gh_mirrors/caff/caffeine 1. 项目的目录结构及介绍 Caffeine 项目的目录结构如下： caffeine/ ├── src/ │ ├── main/ │ │ ├── java/ │ │...
本地缓存：Caffeine入门使用
weixin_47552725的博客
12-28 3902
Caffeine是一款基于jdk8实现的缓存工具，在设计上参考了google的Guava cach组件，可以理解为是一个Guava Cache的加强版本，性能也是在其基础上有了提升。来查看组件的源码 ，并且他还编写了ConcurrentLinkedHashMap工具类，也被用于缓存的底层数据结构，这个类就是Guava cache的基础。我们知道Guava cache是基于LRU算法实现的一种缓存工具，LRU算法的缺点是短暂持续性冷数据流量会导致热数据的淘汰，造成数据的污染。
高性能缓存Caffeine的基本使用方式
自律使我自由
12-11 4905
Caffeine是基于JDK1.8版本的高性能本地缓存库，它是Guava的增强版，与ConcurrentLinkedHashMap相似，支持并发，并且可以在O(1)的时间复杂度内查找、写入元素。
本地缓存之王Caffeine 保姆级教程（值得珍藏）
a342874650的专栏
01-27 3198
在编程领域，缓存是不可或缺的一部分，从处理器到应用层，其应用无处不在。从根本上讲，缓存是利用空间换取时间的一种策略，通过优化数据存储方式，提高后续数据访问速度。 对于Java开发者来说，有很多常用的缓存解决方案，例如EhCache和Memcached等。这些解决方案的核心目标是提高系统吞吐量，减轻数据库等持久层的压力。
Caffeine本地缓存快速上手教程，通俗易懂
RudeTomatoes的博客
03-13 2992
使用缓存的优点是可以减少直接访问数据库的压力。Caffeine是目前单机版缓存性能最高的，提供了最优的缓存命中率。用法和java中的map集合比较类似，底层使用一个ConcurrencyHashMap来保存所有数据，可以理解为一个增强版的map集合，增强的功能有设置缓存过期时间，缓存数据驱逐，统计缓存数据等。本文会大量使用详细的代码示例，通俗易懂地帮助大家学会使用Caffeine本地缓存。
Java-缓存-内存缓存Caffeine基本使用
Java程序员的知识博客
02-17 1270
Caffeine作为当下本地缓存的王者被大量的应用再实际的项目中，可以有效的提高服务吞吐率、qps，降低rt本文将简单介绍下Caffeine的使用姿势。
Caffeine缓存指南
漫天飞雪
06-15 2554
Caffeine是一个由Ben Manes开发的高性能缓存库，灵感来源于Guava Cache，并在其基础上进行了大量的性能优化。Caffeine提供了一种近乎最优的缓存解决方案，具有低延迟、高吞吐量、灵活配置等特点。支持多种缓存策略，如LRU、LFU等提供细粒度的过期控制和自动刷新机制内置统计监控功能，便于性能调优易于集成，提供简单直观的API缓存是一种常见的性能优化技术，通过在内存中存储经常访问的数据，减少对数据库或其他外部数据源的访问，从而提高系统的响应速度。缓存策略。
【Caffeine】高性能缓存库，万字详解教程
热爱技术，享受生活
10-01 1646
大家在做项目时，遇到的第一个问题就是如何提高服务器的性能，从而提升用户的体验。当遇到这个问题时，不可避免的就会引出了缓存这个概念。而缓存（主要从服务端介绍） 又分本地缓存和分布式缓存以及数据库缓存。这三种缓存分别适应不同的场景，这里我们先介绍一下本地缓存。说到本地缓存，就不得不说到caffeine，caffeine 被称之为缓存之王。它为什么被这么多人推崇呢？这离不开它的高性能。首先，Caffeine是基于 Java 8 的高性能，接近最佳的缓存库。并且它 使用启发的 API 提供内存缓存。
caffeine缓存的使用
qq_44871116的博客
04-02 2937
caffeine
【Caffeine缓存】如何使用Caffeine存入缓存和查询缓存？本地缓存之王Caffeine简单快速上手
Sihang_Xie的博客
02-07 4370
Caffeine如何写入缓存？如何查询缓存？Caffeine如何设置缓存有效时间？Caffeine如何设置缓存大小上限？看完本篇文章，你会得到答案。
Caffeine的使用
Ostkakah的博客
09-10 1876
运行反向代理服务器也就是负责反向代理到三个nginx的nginx，该nignx也负责前端页面的跳转。该nginx的conf为下:突出位置就是该nginx需要反向代理的其他nginx的IP和端口。在资源比较有限的时候我们通常不适用上述的机构，而是用使用Caffeine进行二级缓存，在Cffeine没有查找到数据，我们才会去redis中查询数据。
Google Guava第三讲：Caffeine实战 - 从场景使用到原理分析
Jet_qi的博客
08-22 353
**摘要**：在本文中，我们来看看 Caffeine — 一个高性能的 Java 缓存库。本文先介绍为什么使用 Caffeine 缓存；接着讲解其底层数据结构，分析其性能优异的原因；然后结合实际业务，讲解 Caffeine 缓存使用方法、清理方法及使用过程中踩过的坑；最后讲解在使用本地缓存时可以优化的方向。
【学习笔记】本地缓存Caffeine介绍及使用
泽济天下的专栏
07-31 3862
在java开发过程中，缓存是我们经常会谈到的一个话题，而在java领域有个缓存框架号称本地缓存性能之王， Caffeine。
【学习总结】项目中用到的caffeine缓存
guo_123258的博客
04-15 2728
一、使用背景： 在开发中经常用到缓存，首先想到的是redis，但是我们只想缓存少量的数据，并且只是给代码内部使用。redis固然好用，但是每次练级也是需要网络io的，所以本地缓存使用就有必要了。 二、用过的本地缓存： 刚开始了解到guava cache可以作为本地缓存，但是了解到caffeine性能更优于guava cache，而且springboot2.0开始不再支持guava cache了，而是用了caffeine代替。 一张图说明问题： 三、怎么定义 不多说，先看看怎么在项目中使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值