Ehcache（二次封装，每个元素可自定义过期时间）

已于 2022-08-31 08:37:22 修改
阅读量2.5k 收藏 5
点赞数 8
分类专栏： Java 文章标签： java Ehcache 缓存 代码 自定义过期时间
于 2022-08-29 00:36:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39651356/article/details/126576733
版权

文章目录

Ehcache

官网： https://www.ehcache.org/
 
优势： 持续维护
 
作用： Java写的缓存工具

<!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.10.1</version>
</dependency>

概念

官网文档： https://www.ehcache.org/documentation/3.10/expiry.html
内置过期策略==ExpiryPolicyBuilder
no expiry：永不过期
time-to-live：固定持有时间（不会由于你访问而重新计算过期时间）- 类似session过期时间策略
time-to-idle：访问元素之后重新开始计算元素过期时间 - 类似redis的过期时间策略

 
 

官网文档： https://www.ehcache.org/documentation/3.10/cache-event-listeners.html
事件监听==EventType
EVICTED：
EXPIRED：keyValue键值对过期
REMOVED：删除keyValue键值对
CREATED：首次设置keyValue键值对
UPDATED：keyValue键值对的value值变更

代码

简单使用
public class OtherTest {
    @Test
    public void test10() {


        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("preConfigured",
                        CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                                        ResourcePoolsBuilder.heap(100))
                                .build())
                .build(true);
        
        //必须key、value的类型一致，否则也找不到，非常的严格
        Cache<Long, String> preConfigured
                = cacheManager.getCache("preConfigured", Long.class, String.class);

        Cache<Long, String> myCache = cacheManager.createCache("myCache",
                CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                        ResourcePoolsBuilder.heap(100)).build());

        myCache.put(1L, "da one!");
        String value = myCache.get(1L);
        Console.log("=================");
        Console.log(value);
        Console.log("=================");

        cacheManager.close();

    }
}

在这里插入图片描述

工具封装
/**
 * Java缓存（封装ehcache）
 * 官网：https://www.ehcache.org/documentation/3.10/getting-started.html
 *
 * @author LinRuChang
 * @version 1.0
 * @date 2022/08/30
 * @since 1.8
 **/
public class EhcacheUtil {

    protected static final CacheManager CACHE_MANAGER = CacheManagerBuilder.newCacheManagerBuilder().build(true);

    /**
     * 默认缓存容器名
     */
    protected static final String DEFAULT_CACHE_NAME = "DEFAULT_CACHE";

    static {
        //默认缓存容器创建
        createCacheIfNot(DEFAULT_CACHE_NAME);
    }


    public static Cache<? super Serializable, ? super Serializable> getCache(String cacheName) {
        return CACHE_MANAGER.getCache(cacheName,Serializable.class,Serializable.class);
    }

    /**
     * 线程安全的创建缓存容器
     * @param cacheName 缓存容器名字
     * @return
     */
    public static Cache<? super Serializable, ? super Serializable> createCache(String cacheName) {
        Assert.notBlank(cacheName, "缓存名缺失");
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        if(cache == null) {
            synchronized (EhcacheUtil.class) {
                cache = getCache(cacheName);
                if(cache == null) {
                    //缓存过期策略
                    CustomExpiryPolicy<Object, Object> customExpiryPolicy = new CustomExpiryPolicy<>();
                    //事件监听
                    CacheEventListenerConfigurationBuilder cacheEventListenerConfiguration = CacheEventListenerConfigurationBuilder
                            .newEventListenerConfiguration(new CustomCacheEventListener(cacheName), EventType.CREATED, EventType.values())
                            .ordered().asynchronous();

                    return CACHE_MANAGER.createCache(cacheName, CacheConfigurationBuilder.newCacheConfigurationBuilder(
                                    Serializable.class,
                                    Serializable.class,
                                    ResourcePoolsBuilder.heap(Long.MAX_VALUE))
                            .withExpiry(customExpiryPolicy)
                            .withService(cacheEventListenerConfiguration));
                }else {
                    return cache;
                }
            }
        }else {
            return cache;
        }
    }

    /**
     * 如果不存在则创建缓存对象
     *
     * @param cacheName 缓存名
     * @return 缓存对象
     */
    public static Cache<? super Serializable, ? super Serializable> createCacheIfNot(String cacheName) {
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        return cache != null ? cache : createCache(cacheName);
    }

    /**
     * 获取键值
     *
     * @param cacheName 缓存容器名 不设置默认使用{@link EhcacheUtil#DEFAULT_CACHE_NAME}
     * @param key       键名
     */
    public static <K extends Serializable> Serializable get(String cacheName, K key) {
        if (key == null) {
            return null;
        }
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        return (Serializable) (createCacheIfNot(cacheName).get(key));
    }


    /**
     * 获取键值 【从默认缓存容器中取{@link EhcacheUtil#DEFAULT_CACHE_NAME}】
     *
     * @param key 键名
     */
    public static <K extends Serializable> Serializable get(K key) {
        return get(DEFAULT_CACHE_NAME, key);
    }


    public static List<? extends Cache.Entry<? super Serializable, ? super Serializable>> getAllEntry(String cacheName) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        return CollUtil.newArrayList(cache);
    }
    public static List<? extends Cache.Entry<? super Serializable, ? super Serializable>> getAllEntry() {
        return getAllEntry(DEFAULT_CACHE_NAME);
    }


    /**
     * 获取容器{cacheName}所有键值
     * @param cacheName
     * @return
     */
    public static List<? super Serializable> getAllValues(String cacheName) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        return getAllEntry(cacheName).stream()
                .map(entry -> entry.getValue())
                .collect(Collectors.toList());
    }

    /**
     * 获取默认容器所有键值
     * @return
     */
    public static List<? super Serializable> getAllValues() {
        return getAllValues(DEFAULT_CACHE_NAME);
    }

    /**
     * 获取容器{cacheName}所有的键名
     * @return
     */
    public static List<? super Serializable> getAllKeys(String cacheName) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        return getAllEntry(cacheName).stream()
                .map(entry -> entry.getKey())
                .collect(Collectors.toList());
    }


    /**
     * 获取默认容器所有的键名
     * @return
     */
    public static List<? super Serializable> getAllKeys() {
        return getAllKeys(DEFAULT_CACHE_NAME);
    }


    /**
     * 获取键值 【从默认缓存容器中取{@link EhcacheUtil#DEFAULT_CACHE_NAME}】
     *
     * @param key 键名
     */
    public static <K extends Serializable, V> V getByType(K key, Class<V> resultType) {
        Serializable result = get(DEFAULT_CACHE_NAME, key);
        return Optional.ofNullable(result)
                .map(elem -> Convert.convert(resultType, elem))
                .orElse(null);

    }

    /**
     * 获取键值 【从默认缓存容器中取{@link EhcacheUtil#DEFAULT_CACHE_NAME}】
     *
     * @param key 键名
     */
    public static <K extends Serializable> String getStr(K key) {
        return getByType(key, String.class);
    }


    /**
     * 设置缓存
     *
     * @param cacheName 缓存容器名字，不设置默认使用{@link EhcacheUtil#DEFAULT_CACHE_NAME}
     * @param key       键名
     * @param value     键值
     * @param expireMs  键值对过期时间（单位毫秒）- 不设置、或负数默认为永不过期
     */
    public static <K extends Serializable, V extends Serializable> void set(String cacheName, K key, V value, Long expireMs) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);

        if (expireMs != null && expireMs >= 0) {
            CacheRuntimeConfiguration runtimeConfiguration = createCacheIfNot(cacheName).getRuntimeConfiguration();
            CustomExpiryPolicy expiryPolicy = (CustomExpiryPolicy) runtimeConfiguration.getExpiryPolicy();
            expiryPolicy.setExpire(key, Duration.ofMillis(expireMs));
        }

        createCacheIfNot(cacheName).put(key, value);
    }

    /**
     * 设置缓存（使用默认的缓存容器{@link EhcacheUtil#DEFAULT_CACHE_NAME）
     *
     * @param key      键名
     * @param value    键值
     * @param expireMs 键值对过期时间（单位毫秒）- 不设置、或负数默认为永不过期
     */
    public static <K extends Serializable, V extends Serializable> void set(String key, V value, Long expireMs) {
        set(DEFAULT_CACHE_NAME, key, value, expireMs);
    }

    /**
     * 设置缓存（使用默认的缓存容器{@link EhcacheUtil#DEFAULT_CACHE_NAME），键值对永不过期
     *
     * @param key   键名
     * @param value 键值
     */
    public static <V extends Serializable> void set(String key, V value) {
        set(key, value, null);
    }



    /**
     * 删除某个容器的某个键值对
     * @param cacheName 容器名
     * @param key 键名
     * @return
     */
    public static Serializable del(String cacheName, Serializable key) {
        cacheName  = StrUtil.blankToDefault(cacheName,DEFAULT_CACHE_NAME);
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);

        return Optional.ofNullable((Serializable)cache.get(key))
                .map(value -> {
                    cache.remove(key);
                    return value;
                })
                .orElse(null);
    }

    /**
     * 删除某人容器的某个键值对
     * @param key 键名
     * @return
     */
    public static Serializable del(Serializable key) {
        return del(DEFAULT_CACHE_NAME,key);
    }

    /**
     * 清空某个缓存容器的内容
     * @param cacheName 缓存容器名
     */
    public static void clear(String cacheName) {
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        if(cache != null) {
            cache.clear();
        }
    }

    /**
     * 销毁全部容器
     */
    public static void close() {
        CACHE_MANAGER.close();
    }


    /**
     * keyValue自定义过期时间
     * <p>
     * 参考的实现{@link ExpiryPolicyBuilder#noExpiration(),ExpiryPolicyBuilder#timeToLiveExpiration(Duration),ExpiryPolicyBuilder#timeToIdleExpiration(Duration)}
     * 文档<a href="https://www.ehcache.org/documentation/3.10/expiry.html"></a>
     *
     * @param <K>
     * @param <V>
     */
    private static class CustomExpiryPolicy<K, V> implements ExpiryPolicy<K, V> {

        private final ConcurrentHashMap<K, Duration> keyExpireMap = new ConcurrentHashMap();


        public Duration setExpire(K key, Duration duration) {
            return keyExpireMap.put(key, duration);
        }

        public Duration getExpireByKey(K key) {
            return Optional.ofNullable(keyExpireMap.get(key))
                    .orElse(null);
        }

        public Duration removeExpire(K key) {
            return keyExpireMap.remove(key);
        }


        @Override
        public Duration getExpiryForCreation(K key, V value) {
            return Optional.ofNullable(getExpireByKey(key))
                    .orElse(Duration.ofNanos(Long.MAX_VALUE));
        }


        @Override
        public Duration getExpiryForAccess(K key, Supplier<? extends V> value) {
            return getExpireByKey(key);
        }

        @Override
        public Duration getExpiryForUpdate(K key, Supplier<? extends V> oldValue, V newValue) {
            return getExpireByKey(key);
        }
    }

    /**
     * 自定义事件处理 == 当前主要是用于去除自定义键值对的Map过期时间东西，防止内存溢出
     * <p>
     * 文档<a href="https://www.ehcache.org/documentation/3.10/cache-event-listeners.html"></a>
     *
     * @param <K>
     * @param <V>
     */
    private static class CustomCacheEventListener<K, V> implements CacheEventListener<K, V> {

        String cacheName;

        Cache cache;

        CustomExpiryPolicy customExpiryPolicy;


        public CustomCacheEventListener(String cacheName) {
            this.cacheName = cacheName;
        }


        @Override
        public void onEvent(CacheEvent event) {
            Console.log("事件触发：{}======{}========{}", cacheName, event.getType(), event.getKey());
            this.cache = ObjectUtil.defaultIfNull(cache, CACHE_MANAGER.getCache(cacheName, Serializable.class, Serializable.class));
            this.customExpiryPolicy = ObjectUtil.defaultIfNull(customExpiryPolicy, (CustomExpiryPolicy) this.cache.getRuntimeConfiguration().getExpiryPolicy());
            if (StrUtil.equalsAnyIgnoreCase(event.getType().name(), EventType.EXPIRED.name(), EventType.EVICTED.name(), EventType.REMOVED.name())) {
                customExpiryPolicy.removeExpire(event.getKey());
            }
        }
    }


}

 
 

Demo测试

class EhcacheUtilTest {

    @Test
    void test1() {
        Cache<? super Serializable, ? super Serializable> test = EhcacheUtil.createCacheIfNot("test");
        test.put("name", "lrc");
        Object name = test.get("name");
        Console.log(name);
    }

    @Test
    @SneakyThrows
    void test2() {


        EhcacheUtil.set("name", "lrc");
        EhcacheUtil.set("year", 20, 1000L);
        EhcacheUtil.set("sport", "篮球",2000L);

        Console.log("\n========初始值========");
        Console.log("name：{}",EhcacheUtil.get("name"));
        Console.log("year：{}",EhcacheUtil.get("year"));
        Console.log("sport：{}",EhcacheUtil.get("sport"));

        Thread.sleep(1000);
        Console.log("\n========休眠1s后========");
        Console.log("name：{}",EhcacheUtil.get("name"));
        Console.log("year：{}",EhcacheUtil.get("year"));
        Console.log("sport：{}",EhcacheUtil.get("sport"));

        Thread.sleep(2000);
        Console.log("\n========休眠2s后========");
        Console.log("name：{}",EhcacheUtil.get("name"));
        Console.log("year：{}",EhcacheUtil.get("year"));
        Console.log("sport：{}",EhcacheUtil.get("sport"));

    }


    @Test
    @SneakyThrows
    void test3() {
        EhcacheUtil.set("testCacheContainer", "name", "lrc", 1000L);
        EhcacheUtil.set("testCacheContainer", "year", "20", null);

        Console.log("\n========初始值========");
        Console.log("name：{}",EhcacheUtil.get("testCacheContainer","name"));
        Console.log("year：{}",EhcacheUtil.get("testCacheContainer","year"));

        Thread.sleep(1000);
        Console.log("\n========休眠1s后========");
        Console.log("name：{}",EhcacheUtil.get("testCacheContainer","name"));
        Console.log("year：{}",EhcacheUtil.get("testCacheContainer","year"));

    }
    
    @Test
    @SneakyThrows
    void test4() {
        EhcacheUtil.set("year", 18);
        Console.log(EhcacheUtil.get("year"));

        EhcacheUtil.set("year", 25);
        Console.log(EhcacheUtil.get("year"));
    }    

}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

嗯嗯**
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【愚公系列】2024年01月 WPF+上位机+工业互联 093-Redis的基本使用
时光隧道
09-09 2万+
编程缓存工具主要有以下几种：内存缓存：内存缓存是将数据暂时存储在内存中，以提高应用程序的性能和响应时间。内存缓存通常涉及使用不同大小和类型的缓存区域，以缓存和重用数据。内存缓存的优点是快速、可靠、易于实现和管理。常用的内存缓存工具有Memcached、Redis等。硬盘缓存：硬盘缓存是将数据存储在磁盘上，以便在需要时更快地访问它们。硬盘缓存通常会在磁盘上创建一个缓存文件或目录，以保存已缓存的数据。硬盘缓存的优点是可以存储大量数据，而且可以长期保留数据。常用的硬盘缓存工具有文件系统缓存、数据库缓存等。数据库缓
springboot整合ehcache 设置缓存过期时间 简单示例
09-14
springboot 整合 ehcache 简单示例 1、添加依赖 pom.xml 2、添加配置文件ehcache.xml 3、添加注解@EnableCaching @Cacheable 4、插入缓存 5 读取缓存 6 设置缓存过期时间ehcache.xml -->timeToLiveSeconds。
EhCache 常用配置详解
zhouliyang77的博客
09-07 253
EhCache 常用配置详解 cache元素的属性： name：缓存名称 maxElementsInMemory：内存中最大缓存对象数 maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大 eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false overflowT...
Ehcache工具类
01-07
本工具类包括初始化cache 修改缓存容器配置 向指定容器中设置值 取值 删除指定的ehcache容器 删除所有容器 删除容器内所有元素 释放CacheManage 获取所有的cache名称
ehcache缓存过期时间和注解的使用。
热门推荐
shuixiou1的博客
03-27 2万+
一、过期时间： 详细配置说明请自行网上搜索。 timeToIdleSeconds表示最大空闲的时间，timeToLiveSeconds表示最大存活时间，(当为0时表示可以无限闲置或存活?此句好像存在疑问,特此来验证一下) 例子1：结果：5秒间隔内不过期，超过10秒一定过期，就不测试了，占用篇幅！备注：缓存的过期是访问后才过期! &lt;cache name="...
Ehcache缓存时间设置
weixin_33984032的博客
08-27 931
timeToLiveSeconds和timeToIdleSecondstimeToLiveSeconds=x：缓存自创建日期起至失效时的间隔时间x；timeToIdleSeconds=y：缓存创建以后，最后一次访问缓存的日期至失效之时的时间间隔y； 如果仅有timeToLiveSeconds那么自创建时间开始 间隔x后缓存失效；如果没有timeToLiveSeconds那么自最后一次访问缓存 间...
java 缓存周期_java编程之Ehcache3.x 缓存过期时间Java配置demo
weixin_32563411的博客
02-16 1106
import java.util.concurrent.TimeUnit;import org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.CacheConfiguration;import org.ehcache.config.builders.CacheConfigurationBuilder;...
随手记录第五话 -- SpringCache搭配Redis的实现以及设置每个key的过期时间
生生不息，则源源不断
08-18 1919
Spring 从3.1 开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager 接口来统一不同的缓存技术；并支持使用JCache（JSR-107）注解简化我们开发；Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合；Cache 接口下Spring 提供了各种xxxCache 的实现；如RedisCache ， EhCacheCache , ConcurrentMapCache 等；...
Hibernate二级缓存（Ehcache）
12-15
此外，Ehcache的配置可以通过ehcache.xml文件进行详细设置，包括缓存的最大元素数量、过期策略、更新策略等： ```xml maxEntriesLocalHeap="10000" eternal="false" timeToIdleSeconds="120" ...
Sage X3软件二次开发：SageX3数据库结构与优化
最新发布
kkchenjj的博客
08-19 1441
为了优化数据处理和确保数据一致性，Sage X3支持创建自定义存储过程。存储过程可以封装复杂的业务逻辑，提高数据操作的效率和安全性。-- 创建更新客户信用等级的存储过程ASBEGINEND;
使用ehcache的工具类
07-30
使用ehcahe时自己做的工具类，方便以后使用
009. Spring Boot(1.5.10版本)缓存技术(整合Ehcache+整合@Cacheable整合@CacheEvict+Redis(3.0.0))
凯凯的博客
12-17 938
Spring Boot 整合 Ehcache EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 ehcache提供了多种缓存策略，主要分为内存和磁盘两级，所以无需担心容量问题。 spring-boot是一个快速的集成框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从...
全面理解MyBatis的缓存机制
禅与计算机程序设计艺术
08-01 1596
MyBatis 是 Apache 开源项目，它是一款优秀的持久层框架。MyBatis 将数据库操作抽象成 Java 对象并通过 SQL 命令实现对数据库数据的 CRUD 操作，非常方便开发人员使用。在 MyBatis 中，提供了两种类型的缓存：一级缓存和二级缓存。Mybatis 通过 CacheManager 来管理所有缓存，它是一个接口，其默认实现类为 PerpetualCache。Mybatis 缓存主要是为了提高查询效率。
Ehcache封装的工具类
qq_43747119的博客
02-18 479
Ehcache封装的工具类
SpringBoot整合EhCache3.6加过期机制
不积跬步无以至千里，不积小流无以成江河
07-11 3593
Ehcache3.6官方文档：http://www.ehcache.org/documentation/3.6/getting-started.html 本来不想加缓存的，但奈何我的接口还要调用另外一个公司的接口，那个公司的接口老是超时，导致页面加载很慢，本来想用redis的key过期机制的，但还要对redis的配置进行修改，而redis用的又是阿里云RDS，但奈何密码又不在我在，还要去问。。。...
Eacache缓存+缓存的过期时间
qq_36074043的博客
07-08 2283
Eacache的属性： 引用jar包     name：Cache的唯一标识       maxElementsInMemory：内存中最大缓存对象数       maxElementsOnDisk：磁盘中最大缓存对象数，若是0表示无穷大       eternal：Element是否永久有效，一但设置了，timeout将不起作用       overflowToDisk：配置
Ehcache 过期参数说明
zhushidan的博客
08-04 1531
Ehcache 缓存过期时间的说明:     timeToIdleSeconds="3" timeToLiveSeconds="5"     timeToIdleSeconds指缓存元素空闲的时间,如果从最后一次访问这个元素到当前时间差超出这个值则此元素会失效   timeToLiveSeconds指缓存元素的生存时间,从创建到死亡的时间长度   当然上面的参数是在没有设置...
前端小白闲着没事，封装一个可以设置过期时间的localStorage存储函数，在vue脚手架中使用
业余前端的职业经历
06-05 1382
本身localStorage 是没有这个功能的，除非手动删除要不永久保存在本地。 seesionStorage 我们就不考虑 他这个只要网页的标签关闭了 在当前标签就自动清除了存储。 在工作中 我们用的localStorage 比较多 这里再次 回想下 曾经的那个面试题 sessionStorage是关闭浏览器清除还是关闭标签清除； 答案是 关闭标签。 好了 不闲扯 直接步入正题 封装 函数，这里我也参考其他大佬的想法 本来也想着用 class 进行封装 可能想着 低版本可能支持的不是太好 就选择es5
EhCacheCacheManager能否自定义过期时间
07-15
是的，EhCacheCacheManager可以自定义缓存的过期时间。EhCache是一个流行的Java缓存库，它提供了灵活的配置选项来管理缓存的过期策略。您可以通过配置缓存的timeToIdleSeconds属性和timeToLiveSeconds属性来设置缓存项的空闲时间和生存时间。 - timeToIdleSeconds属性定义了缓存项在最后一次访问之后的空闲时间，如果在指定的时间内没有访问，则该缓存项将被视为过期。 - timeToLiveSeconds属性定义了缓存项从创建到过期的时间间隔，即使在此期间内有访问，超过指定时间后也会被视为过期。 您可以根据自己的需求将这些属性设置为不同的值，以控制缓存项的过期行为。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值