CacheLoader和装饰器模式

于 2024-08-21 16:46:45 发布
阅读量528 收藏 20
点赞数 10
分类专栏： Java开发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43349479/article/details/141397377
版权

CacheLoader

CacheLoader 是 Google Guava 库中的一个类，用于定义如何加载缓存中的值。它通常与 LoadingCache 一起使用，以便在缓存中不存在某个键时自动加载相应的值。以下是 CacheLoader 的基本使用方法：

  1. 引入依赖：首先，你需要在项目中引入 Guava 库的依赖。对于 Maven 项目，可以在 pom.xml 中添加以下依赖：

    <dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

  2. 创建 CacheLoader：实现 CacheLoader 的 load 方法，该方法定义了如何加载缓存中的值。

    import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.cache.CacheBuilder;

import java.util.concurrent.TimeUnit;

public class CacheLoaderExample {

    public static void main(String[] args) {
        // 创建 CacheLoader
        CacheLoader<String, String> loader = new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                // 定义如何加载缓存中的值
                return "Value for " + key;
            }
        };

        // 创建 LoadingCache
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存过期时间
                .build(loader);

        // 使用缓存
        try {
            System.out.println(cache.get("key1")); // 输出: Value for key1
            System.out.println(cache.get("key2")); // 输出: Value for key2
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

  3. 配置缓存：在创建 LoadingCache 时，可以使用 CacheBuilder 来配置缓存的各种属性，例如过期时间、最大缓存大小等。

    LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存过期时间
        .maximumSize(100) // 设置缓存的最大大小
        .build(loader);

  4. 使用缓存：通过 cache.get(key) 方法来获取缓存中的值。如果缓存中不存在该键，则会调用 CacheLoader 的 load 方法来加载值。

    try {
    String value = cache.get("key1");
    System.out.println(value); // 输出: Value for key1
} catch (Exception e) {
    e.printStackTrace();
}

通过 CacheLoader 和 LoadingCache，可以实现缓存的自动加载和管理。

在 Google Guava 的缓存库中，cache.refresh 和 cache.invalidate 是两个常用的方法，用于管理缓存中的数据。它们的作用和使用场景有所不同：

1. cache.refresh

cache.refresh 方法用于异步地重新加载缓存中的值，而不会立即删除旧值。它会触发 CacheLoader 的 load 方法来重新加载数据，但在新值加载完成之前，旧值仍然可以被访问。

使用场景
  • 当你希望在后台异步更新缓存中的值，而不影响当前的读取操作时，可以使用 cache.refresh。
  • 适用于需要定期刷新缓存数据的场景。
示例代码
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import java.util.concurrent.TimeUnit;

public class CacheRefreshExample {

    private static LoadingCache<String, String> cache;

    static {
        CacheLoader<String, String> loader = new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                // 从数据库加载数据
                return loadFromDatabase(key);
            }
        };

        cache = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build(loader);
    }

    public static void main(String[] args) {
        // 初次加载
        System.out.println(cache.getUnchecked("key1"));

        // 刷新缓存
        cache.refresh("key1");

        // 等待刷新完成
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 重新加载
        System.out.println(cache.getUnchecked("key1"));
    }

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

2. cache.invalidate

cache.invalidate 方法用于立即删除缓存中的指定键及其对应的值。下次访问该键时，会触发 CacheLoader 的 load 方法来重新加载数据。

使用场景
  • 当你知道缓存中的数据已经过期或不再有效时，可以使用 cache.invalidate 来删除缓存中的数据。
  • 适用于需要手动控制缓存失效的场景。
示例代码
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import java.util.concurrent.TimeUnit;

public class CacheInvalidateExample {

    private static LoadingCache<String, String> cache;

    static {
        CacheLoader<String, String> loader = new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                // 从数据库加载数据
                return loadFromDatabase(key);
            }
        };

        cache = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build(loader);
    }

    public static void main(String[] args) {
        // 初次加载
        System.out.println(cache.getUnchecked("key1"));

        // 使缓存失效
        cache.invalidate("key1");

        // 重新加载
        System.out.println(cache.getUnchecked("key1"));
    }

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

总结

  • cache.refresh：用于异步地重新加载缓存中的值，不会立即删除旧值，适用于需要定期刷新缓存数据的场景。
  • cache.invalidate：用于立即删除缓存中的指定键及其对应的值，适用于需要手动控制缓存失效的场景。

在使用 Google Guava 的 LoadingCache 时，cache.get 方法会在缓存中没有找到对应键的值时调用 CacheLoader 的 load 方法来加载数据。

LoadingCache 的工作原理

  1. 缓存命中：如果缓存中存在对应键的值，cache.get 方法会直接返回该值。
  2. 缓存未命中：如果缓存中不存在对应键的值，cache.get 方法会调用 CacheLoader 的 load 方法来加载数据，并将加载的数据存入缓存，然后返回该值。

示例代码

以下是一个完整的示例，展示了 LoadingCache 如何在缓存未命中时调用 CacheLoader 的 load 方法：

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class LoadingCacheExample {

    private static LoadingCache<String, String> cache;

    static {
        CacheLoader<String, String> loader = new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                // 从数据库加载数据
                return loadFromDatabase(key);
            }
        };

        cache = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build(loader);
    }

    public static void main(String[] args) {
        try {
            // 初次加载，缓存未命中，调用 load 方法
            System.out.println(cache.get("key1")); // 输出: Value for key1

            // 再次加载，缓存命中，不调用 load 方法
            System.out.println(cache.get("key1")); // 输出: Value for key1

            // 模拟数据库更新
            updateDatabase("key1", "New Value for key1");

            // 使缓存失效
            cache.invalidate("key1");

            // 重新加载，缓存未命中，调用 load 方法
            System.out.println(cache.get("key1")); // 输出: New Value for key1
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

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

    private static void updateDatabase(String key, String newValue) {
        // 模拟更新数据库
        System.out.println("Database updated: " + key + " -> " + newValue);
    }
}

详细解释

  1. 创建 CacheLoader：

    CacheLoader<String, String> loader = new CacheLoader<String, String>() {
    @Override
    public String load(String key) throws Exception {
        // 从数据库加载数据
        return loadFromDatabase(key);
    }
};

    这里我们定义了一个 CacheLoader，它的 load 方法会在缓存未命中时被调用，从数据库加载数据。

  2. 创建 LoadingCache：

    cache = CacheBuilder.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build(loader);

    使用 CacheBuilder 创建一个 LoadingCache，并设置缓存的过期时间为 10 分钟。

  3. 使用 cache.get 方法：

    System.out.println(cache.get("key1")); // 输出: Value for key1

    初次加载时，缓存未命中，cache.get 方法会调用 CacheLoader 的 load 方法，从数据库加载数据并存入缓存。

  4. 使缓存失效：

    cache.invalidate("key1");

    使缓存中的键 key1 失效，下次访问时会重新加载数据。

  5. 重新加载数据：

    System.out.println(cache.get("key1")); // 输出: New Value for key1

    缓存失效后，再次访问时，cache.get 方法会再次调用 CacheLoader 的 load 方法，从数据库加载最新的数据。

总结

在使用 Google Guava 的 LoadingCache 时，cache.get 方法会在缓存未命中时调用 CacheLoader 的 load 方法来加载数据，并将加载的数据存入缓存。这样可以确保在缓存中找不到数据时，能够自动从数据源加载最新的数据。

装饰器模式

装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许你动态地向对象添加行为，而无需修改对象的类。装饰器模式通过创建一个装饰器类来包装原始类，从而在保持类接口不变的情况下扩展对象的功能。

主要角色

  1. Component：定义一个对象接口，可以给这些对象动态地添加职责。
  2. ConcreteComponent：实现 Component 接口的具体对象。
  3. Decorator：实现 Component 接口，并持有一个 Component 对象的引用。
  4. ConcreteDecorator：具体的装饰器类，扩展 Decorator 类，向 Component 添加职责。

示例代码

以下是一个使用装饰器模式的示例，展示了如何动态地向对象添加行为。假设我们有一个 Coffee 接口和一个 SimpleCoffee 类，我们希望通过装饰器模式向 SimpleCoffee 添加不同的装饰（如牛奶、糖等）。

Java 示例
// Component
interface Coffee {
    String getDescription();
    double getCost();
}

// ConcreteComponent
class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Simple Coffee";
    }

    @Override
    public double getCost() {
        return 5.0;
    }
}

// Decorator
abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }

    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription();
    }

    @Override
    public double getCost() {
        return decoratedCoffee.getCost();
    }
}

// ConcreteDecorator
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription() + ", Milk";
    }

    @Override
    public double getCost() {
        return decoratedCoffee.getCost() + 1.5;
    }
}

// ConcreteDecorator
class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription() + ", Sugar";
    }

    @Override
    public double getCost() {
        return decoratedCoffee.getCost() + 0.5;
    }
}

// 使用示例
public class DecoratorPatternExample {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());

        coffee = new MilkDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());

        coffee = new SugarDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());
    }
}
输出
Simple Coffee $5.0
Simple Coffee, Milk $6.5
Simple Coffee, Milk, Sugar $7.0

详细解释

  1. Component 接口：

    interface Coffee {
    String getDescription();
    double getCost();
}

    定义了 Coffee 接口，包含两个方法：getDescription 和 getCost。

  2. ConcreteComponent 类：

    class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Simple Coffee";
    }

    @Override
    public double getCost() {
        return 5.0;
    }
}

    实现了 Coffee 接口的具体类 SimpleCoffee。

  3. Decorator 抽象类：

    abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }

    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription();
    }

    @Override
    public double getCost() {
        return decoratedCoffee.getCost();
    }
}

    实现了 Coffee 接口的抽象类 CoffeeDecorator，并持有一个 Coffee 对象的引用。

  4. ConcreteDecorator 类：

    class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription() + ", Milk";
    }

    @Override
    public double getCost() {
        return decoratedCoffee.getCost() + 1.5;
    }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription() + ", Sugar";
    }

    @Override
    public double getCost() {
        return decoratedCoffee.getCost() + 0.5;
    }
}

    实现了具体的装饰器类 MilkDecorator 和 SugarDecorator，分别向 Coffee 对象添加牛奶和糖的功能。

  5. 使用示例：

    public class DecoratorPatternExample {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());

        coffee = new MilkDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());

        coffee = new SugarDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());
    }
}

    创建了一个 SimpleCoffee 对象，并通过装饰器动态地向其添加牛奶和糖的功能。

总结

装饰器模式通过创建装饰器类来包装原始类，从而在保持类接口不变的情况下动态地向对象添加行为。它提供了一种灵活的方式来扩展对象的功能，而无需修改原始类的代码。

你这个代码我看不懂
关注
  • 10
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Guava Cache缓存的使用和介绍
.... 永远年轻，永远热泪盈眶
10-15 1万+
源码地址：https://github.com/google/guava API：https://google.github.io/guava/releases/snapshot-jre/api/docs/   范例 LoadingCache&lt;Key, Graph&gt; graphs = CacheBuilder.newBuilder() .maximumSize(...
wild-match-map:在分层的CacheLoader映射上使用具体的或通配符名称
05-10
创建该库的目的是与EventEmitter和EventTarget都制定的隐蔽原理形成鲜明的对比：这些库显式地阻止了对绑定的了解，EventEmitter提供了描述侦听器的功能，但没有描述发射器，EventTarget拒绝承认侦听器和发射器。...
Guava 源码中7种设计模式的实现分析
2301_78976656的博客
08-09 565
最近有小伙伴在 Guava 组件的使用上交流了一些问题，组件的使用很简单，优秀的人不仅仅在使用，学习 Guava 的源码设计是提高自己编程思想和能力的关键，跟着高手走，吃喝啥都有，跟着高手混，未来一定顺。哈哈，下面 V 哥从 Guava 源码中使用到的设计模式来详细介绍一下，希望能帮助你更好的理解设计模式的精髓，开整。Guava 源码中使用到的设计模式主要包括以下几种：建造者模式（Builder Pattern）：在 Guava 中， 类就是使用了建造者模式，它允许用户通过链式调用方法来设置缓存的各种参数，
科普文：Java基础系列之【Guava中7种设计模式分析】
为无为，事无事，味无味。
08-15 787
Guava 源码中使用到的设计模式主要包括以下几种：建造者模式（Builder Pattern）：在 Guava 中， 类就是使用了建造者模式，它允许用户通过链式调用方法来设置缓存的各种参数，如初始容量、最大大小、过期时间等，最后通过 方法构建并返回一个缓存实例。这种模式使得构建过程非常清晰，并且易于维护和扩展。代理模式（Proxy Pattern）：Guava 中的 类是代理模式的一个应用，它提供了一个默认的代理实现，使得用户在实现自己的代理类时，可以只关注自己关心的方法，其他方法可以委托给被代理的对
高并发之——Guava Cache
冰河的专栏
10-27 6202
最近需要用到缓存来存放临时数据，又不想采用Redis，Java自带的Map功能太少，发现Google的Guava提供的Cache模块功能很强大，于是选择使用它。 本地缓存 本地缓存作用就是提高系统的运行速度，是一种空间换时间的取舍。它实质上是一个做key-value查询的字典，但是相对于我们常用HashMap它又有以下特点： 1.并发性：由于目前的应用大都是多线程的，所以缓存需要支持并发的写...
Google Guava与缓存操作相关的类
Life is for sharing的博客
04-07 426
文章目录1.示例2.适用3.种类3.1来自于CacheLoader3.2来自于Callable3.3直接插入4.淘汰4.1基于大小的淘汰4.2基于时间的淘汰4.2.1测试定时淘汰4.3基于引用的淘汰4.4显式删除4.5删除监听器4.6什么时候进行清除？4.7刷新5.特性5.1统计5.2`asMap`6.中断 Caches：正确地进行本地缓存，并支持各种过期行为。 1.示例 LoadingCache...
本地缓存组件 Guava cache 详解
天行健，君子以自强不息；地势坤，君子以厚德载物。
09-24 695
缓存分为本地缓存和远端缓存。常见的远端缓存有Redis，MongoDB；本地缓存一般使用map的方式保存在本地内存中。一般我们在业务中操作缓存，都会操作缓存和数据源两部分。如：put数据时...
Guava缓存值CacheBuilder介绍
热门推荐
徐刘根的博客
08-05 3万+
范例LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder() .maximumSize(1000) .expireAfterWrite(10, TimeUnit.MINUTES) .removalListener(MY_LISTENER) .build( new
具有GlassFish和一致性的高性能JPA –第2部分
最佳 Java 编程
05-07 132
在我的四部分系列的第二部分中，我将解释将Coherence与EclipseLink和GlassFish一起使用的策略第一。这描述了配置Coherence的JPA支持的Cache所必须采取的步骤，以及如何在GlassFish中使用它。高性能数据存储。 一般的做法 您可以将Coherence API与通过JPA映射的数据库支持的缓存一起使用。 网格通过JPA CacheLoader和Ca...
Spring Boot缓存实战 Caffeine示例
08-27
这些配置将创建一个名为 foo 和 bar 的缓存，最大数量为 500，存活时间为 10 分钟。 三、使用 @EnableCaching 注解开启缓存支持 使用 @EnableCaching 注解可以让 Spring Boot 开启对缓存的支持。例如： @...
Android WebView、Webkit内核深入讲解资料.docx
11-29
StreamLoader是所有内容加载器的基类，采用消息驱动的状态机模型，将数据加载到Frame中。URL处理功能，如URL编码和解码，由URLUtil类提供，帮助开发者更好地处理网页链接。 综上所述，Android WebView的实现涉及...
Nginx内容缓存以及常见参数配置详析
09-29
除了配置参数，Nginx的缓存管理还包括两个额外的进程：cachemanager和cacheloader。cachemanager周期性地启动，检查高速缓存的状态，如果高速缓存大小超过配置的限制，则删除最近访问过的数据。cacheloader在Nginx...
基于Java的实例源码-ehcache(Java缓存框架 EhCache).zip
06-26
7. **缓存加载器（CacheLoader）**：当缓存中没有请求的数据时，可以通过CacheLoader从其他数据源（如数据库）加载。 8. **分布式缓存**：EhCache支持通过Terracotta服务器实现分布式缓存，使得多台服务器共享同一...
【链表在Java中DeBug】
最新发布
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 261
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
Linux配置Maven环境
Java全栈开发者
08-18 455
官网地址：https://maven.apache.org/download.cgi。获取其对应的下载链接（也可以使用下载到本地后，手动上传到服务器的方式）切到自己想要存放的路径后，使用wget下载。使用pwd查看文件路径，ll查看文件名称。这里以当前最新版本3.9.8为例。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 964
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
【Spring框架】
m0_71941456的博客
08-18 1014
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 529
【代码】springboot网上商品订单转手系统bootpf
cacheLoader reload
07-27
CacheLoader的reload方法是用于异步刷新缓存项的方法。在使用refreshAfterWrite策略时，当调用get方法获取缓存项时，如果缓存项已经过期，会触发reload方法重新加载缓存项的值。需要注意的是，为了实现异步刷新，需要重写CacheLoader的reload方法，并在该方法中实现异步加载缓存项的逻辑。\[3\] #### 引用[.reference_title] - *1* [guava cache 源码分析01 cacheBuilder && cacheLoader](https://blog.csdn.net/kuaipao19950507/article/details/101479478)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [本地缓存-loadingCache](https://blog.csdn.net/String_guai/article/details/121109056)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你这个代码我看不懂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值