开源工具（四）适合缓存

已于 2023-12-14 15:39:36 修改
阅读量2.5w 收藏 5
点赞数 5
文章标签： 开源 系统架构 缓存
于 2023-07-21 19:20:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69270256/article/details/131844517
版权

一、引言

        github地址：https://github.com/SongTing0711/fit-cache

        目前业内对于本地缓存、Redis、Es、Ck等缓存的使用处于比较随意的状态，一方面是资源的浪费，另外一方面如果是本地缓存可能是导致oom的最后一根稻草。

        作者创作的fit-cache提供key是否适合缓存，适合缓存的时间，解决缓存滥用、缓存同时失效等问题。

二、架构

1、工具定位

        fit-cahe要实现两个功能：key是否适合缓存、如果适合缓存，应该缓存多久。

        作者参考了Mysql的Innodb存储引擎（innodb用有百分比的LRU进行mysql的缓冲池，避免频繁的磁盘读写）和京东的HotKey（京东用于商城的热点数据及时缓存，防止大促下打爆redis）。       

        作者认为可以使用滑动窗口+LRU列表的方式进行计算，也就是频率和最近访问时间。

5fd46ff9604e42429bc68dbe57863d44.png

2、实现 

        实现的话，作者认为频率的权重在最近访问之上因此是否适合缓存应该是先判断key对应的滑动窗口是否达到设定的热度规则，如果达不到再看LRU列表，但是LRU的长度是需要限定的，不然就不是非常有可能被很快被再次访问。

3ed866f94e37406d97ddddd7dd836184.png

        适合缓存的时间就需要通过频率和最近访问时间分配权重，进行加权计算，最近访问时间还需要进行指数衰减，因为访问时间离现在越久，很明显优先级越低。 

c0902d460dbf47ad87bd36c8a7dfef93.png

3、封装 

        对于开源工具的封装无非两种方式，一种是封装成独立的Client放到maven给服务引用，这种是针对单体服务纬度的，优点是使用的时候引入简单，不用像很多中间件工具一样划分客户端服务端，导致引入成本巨大。

        另外一种是封装成客户端服务端的模式，这样的话就可以计算到集群纬度，从而从整体上判断是否适合缓存，以及相应的缓存时间。

        作者目前封装了第一种，第二种还在封装中。

三、源代码

        这里讲一下fit-cache的核心代码

1、core        

        FitCacheStore对外暴露的核心api：是否适合缓存和适合缓存时间

        可以把适合缓存的key的值通过set存入，作者底层是用的caffeine

         DispatcherConfig是一个阻塞队列，key的访问事件被存储到这里，然后被异步线程取出进行计算频率和最近访问

public class FitCacheStore {

    /**
     * 判断是否适合缓存
     */
    public static boolean isFitCache(String key) {
        try {
            // 先看滑动窗口的热度，判断适不适合缓存
            boolean fit = CaffeineCacheHolder.getFitCache().getIfPresent(key) != null;
            if (!fit) {
                fit = CaffeineCacheHolder.getLruCache().get(key) != null;
            }
            DispatcherConfig.QUEUE.put(key);
            return fit;
        } catch (Exception e) {
            return false;
        }
    }


    public static int fitCacheTime(String key) {
        try {
            SlidingWindow window = (SlidingWindow) CaffeineCacheHolder.getWindowCache().getIfPresent(key);
            long lastTime = (long) CaffeineCacheHolder.getLruCache().get(key);
            if (window == null && lastTime == 0) {
                return 0;
            }
            if (window == null && lastTime != 0) {
                return FitCacheTime.calculateStorageTime(0, lastTime);
            }
            if (window != null && lastTime == 0) {
                return FitCacheTime.calculateStorageTime(window.getCount(), 0);
            }
            int res = FitCacheTime.calculateStorageTime(window.getCount(), lastTime);
            DispatcherConfig.QUEUE.put(key);
            return res;
        } catch (Exception e) {
            return 0;
        }
    }

    /**
     * 从本地caffeine取值
     */
    public static Object get(String key) {
        return CaffeineCacheHolder.getFitCache().getIfPresent(key);
    }

    /**
     * 设置缓存
     */
    public static boolean set(String key, Object value) {
        Object object = CaffeineCacheHolder.getFitCache().getIfPresent(key);
        Object lru = CaffeineCacheHolder.getLruCache().get(key);
        if (object == null && lru == null) {
            return false;
        }
        CaffeineCacheHolder.getFitCache().put(key, value);
        return true;
    }
//
//    private static ExecutorService threadPoolExecutor = new ThreadPoolExecutor(1,
//            2,
//            5,
//            TimeUnit.SECONDS,
//            new ArrayBlockingQueue<>(100),
//            new ThreadPoolExecutor.DiscardOldestPolicy());
//    public static void main (String[] args) throws InterruptedException {
//        KeyRule rule = new KeyRule("test", true, 2,5);
//        KeyRuleHolder.KEY_RULES.add(rule);
//        IKeyListener iKeyListener = new KeyListener();
//        KeyConsumer keyConsumer = new KeyConsumer();
//        keyConsumer.setKeyListener(iKeyListener);
//
//        threadPoolExecutor.submit(keyConsumer::beginConsume);
//        boolean fit = isFitCache("test");
//        System.out.println("第一次访问test是否适合" + fit);
//        Thread.sleep(1000);
//        fit = isFitCache("test");
//        System.out.println("第2次访问test是否适合" + fit);
//        Thread.sleep(1000);
//        fit = isFitCache("test666");
//        System.out.println("第一次访问test666是否适合" + fit);
//        Thread.sleep(1000);
//        fit = isFitCache("test");
//        System.out.println("第3次访问test是否适合" + fit);
//        Thread.sleep(1000);
//        int time = fitCacheTime("test");
//        System.out.println("第1次访问test适合时间" + time);
//    }

}

2、config

        这里主要是做了一个分发的作用，将消费事件的线程放入线程池启动

@Configuration
public class DispatcherConfig {

    private ExecutorService threadPoolExecutor = new ThreadPoolExecutor(1,
            2,
            5,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(100),
            new ThreadPoolExecutor.DiscardOldestPolicy());

    /**
     * 队列
     */
    public static BlockingQueue<String> QUEUE = new LinkedBlockingQueue<>(200);

    @Bean
    public Consumer consumer() {
        List<KeyConsumer> consumerList = new ArrayList<>();
        KeyConsumer keyConsumer = new KeyConsumer();
        consumerList.add(keyConsumer);

        threadPoolExecutor.submit(keyConsumer::beginConsume);
        return new Consumer(consumerList);
    }
}

public class KeyConsumer {

    @Resource
    private IKeyListener iKeyListener;

    public void setKeyListener(IKeyListener iKeyListener) {
        this.iKeyListener = iKeyListener;
    }

    public void beginConsume() {
        while (true) {
            try {
                String key = DispatcherConfig.QUEUE.take();
                iKeyListener.newKey(key);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3、listen

        消费事件，在滑动窗口和LRU列表走一遍

@Component
public class KeyListener implements IKeyListener {

    @Override
    public void newKey(String key) {
        SlidingWindow slidingWindow = checkWindow(key);
        // 被访问，进入最近访问列表
        CaffeineCacheHolder.getLruCache().put(key, System.currentTimeMillis());
        //看看达到匹配规则没有
        boolean fit = slidingWindow.addCount(1);

        CaffeineCacheHolder.getWindowCache().put(key, slidingWindow);
        if (fit && CaffeineCacheHolder.getFitCache().getIfPresent(key) == null) {
            //数据变热，适合缓存
            CaffeineCacheHolder.getFitCache().put(key, System.currentTimeMillis());
        }
    }

    /**
     * 生成或返回该key的滑窗
     */
    private SlidingWindow checkWindow(String key) {
        // 取该key的滑窗
        return (SlidingWindow) CaffeineCacheHolder.getWindowCache().get(key, (Function<String, SlidingWindow>) s -> {
            // 是个新key，获取它的规则
            KeyRule keyRule = KeyRuleHolder.findRule(key);
            return new SlidingWindow(keyRule.getInterval(), keyRule.getThreshold());
        });
    }

}

4、工具类

        首先就是LRU列表，这里使用双向链表存储key的访问时间，列表容量可设置，mysql的innodb的lru特殊一点，它设置了一个比例，第一次访问的时候不会放到头部，而是放在30%左右的if，因为它的数据访问很大量，不是key维度。如果全表扫描很容易把lru列表原有内容全部顶掉。

        作者这里不需要像他这样，因为是key维度的。

public class LruCache {
    class Node {
        String key;
        Object value;
        Node prev;
        Node next;

        public Node(String key, Object value) {
            this.key = key;
            this.value = value;
        }
    }
    private final int capacity;
    private final Map<String, Node> cache;
    private Node head;
    private Node tail;

    public LruCache(int capacity) {
        this.capacity = capacity;
        this.cache = new HashMap<>();
        this.head = new Node("head", 0);
        this.tail = new Node("tail", 0);
        head.next = tail;
        tail.prev = head;
    }

    public Object get(String key) {
        Node node = cache.get(key);
        if (node != null) {
            // l列表里面有就转到头部
            moveToHead(node);
            return node.value;
        }
        return null;
    }

    public synchronized void put(String key, Object value) {
        Node node = cache.get(key);
        if (node != null) {
            node.value = value;
            moveToHead(node);
        } else {
            node = new Node(key, value);
            cache.put(key, node);
            addToHead(node);
            if (cache.size() > capacity) {
                // 超过容量就删除尾部节点
                Node removedNode = removeTail();
                cache.remove(removedNode.key);
            }
        }
    }

    private synchronized void moveToHead(Node node) {
        removeNode(node);
        addToHead(node);
    }

    private synchronized void addToHead(Node node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private synchronized void removeNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private synchronized Node removeTail() {
        Node removedNode = tail.prev;
        removeNode(removedNode);
        return removedNode;
    }

}

        然后是滑动窗口，管理的是频率

public class SlidingWindow {
    /**
     * 循环队列，就是装多个窗口用，该数量是windowSize的2倍
     */
    private AtomicLong[] timeSlices;
    /**
     * 队列的总长度
     */
    private int timeSliceSize;
    /**
     * 每个时间片的时长，以毫秒为单位
     */
    private int timeMillisPerSlice;
    /**
     * 共有多少个时间片（即窗口长度）
     */
    private int windowSize;
    /**
     * 在一个完整窗口期内允许通过的最大阈值
     */
    private int threshold;
    /**
     * 该滑窗的起始创建时间，也就是第一个数据
     */
    private long beginTimestamp;
    /**
     * 最后一个数据的时间戳
     */
    private long lastAddTimestamp;


    public SlidingWindow(int duration, int threshold) {
        //超过10分钟的按10分钟
        if (duration > 600) {
            duration = 600;
        }
        //要求5秒内探测出来的，
        if (duration <= 5) {
            this.windowSize = 5;
            this.timeMillisPerSlice = duration * 200;
        } else {
            this.windowSize = 10;
            this.timeMillisPerSlice = duration * 100;
        }
        this.threshold = threshold;
        // 保证存储在至少两个window
        this.timeSliceSize = windowSize * 2;

        reset();
    }

    public SlidingWindow(int timeMillisPerSlice, int windowSize, int threshold) {
        this.timeMillisPerSlice = timeMillisPerSlice;
        this.windowSize = windowSize;
        this.threshold = threshold;
        // 保证存储在至少两个window
        this.timeSliceSize = windowSize * 2;

        reset();
    }

    /**
     * 初始化
     */
    private void reset() {
        beginTimestamp = System.currentTimeMillis();
        //窗口个数
        AtomicLong[] localTimeSlices = new AtomicLong[timeSliceSize];
        for (int i = 0; i < timeSliceSize; i++) {
            localTimeSlices[i] = new AtomicLong(0);
        }
        timeSlices = localTimeSlices;
    }

    /**
     * 计算当前所在的时间片的位置
     */
    private int locationIndex() {
        long now = System.currentTimeMillis();
        //如果当前的key已经超出一整个时间片了，那么就直接初始化就行了，不用去计算了
        if (now - lastAddTimestamp > timeMillisPerSlice * windowSize) {
            reset();
        }

        int index = (int) (((now - beginTimestamp) / timeMillisPerSlice) % timeSliceSize);
        if (index < 0) {
            return 0;
        }
        return index;
    }

    /**
     * 增加count个数量
     */
    public synchronized boolean addCount(int count) {
        //当前自己所在的位置，是哪个小时间窗
        int index = locationIndex();
        clearFromIndex(index);

        int sum = 0;
        // 在当前时间片里继续+1
        sum += timeSlices[index].addAndGet(count);
        for (int i = 1; i < windowSize; i++) {
            sum += timeSlices[(index - i + timeSliceSize) % timeSliceSize].get();
        }

        lastAddTimestamp = System.currentTimeMillis();
        return sum >= threshold;
    }


    public int getCount() {
        int sum = 0;
        //加上前面几个时间片
        for (int i = 1; i < windowSize; i++) {
            sum += timeSlices[i].get();
        }
        return sum;
    }

    private void clearFromIndex(int index) {
        for (int i = 1; i <= windowSize; i++) {
            int j = index + i;
            if (j >= windowSize * 2) {
                j -= windowSize * 2;
            }
            timeSlices[j].set(0);
        }
    }

}

        然后是适合缓存时间的计算，根据频率和最近访问时间进行计算

public class FitCacheTime {

    /**
     * 加权递减求和算法，计算数据的评分
     *
     * @param frequency
     * @param lastTime
     * @return
     */
    private static double calculateScore(double frequency, long lastTime) {
        // 根据业务需求和数据的重要性，给访问频率和最近访问时间分配不同的权重
        // 这里可以从配置中心拿
        double frequencyWeight = 0.7;
        double timeWeight = 0.3;
        // 计算访问频率和最近访问时间的值
        double time = (System.currentTimeMillis() - lastTime) / 1000.0;
        // 使用递减函数计算时间权重，越近访问的时间权重越高
        double timeDecay = Math.exp(-time);
        // 加权求和，得到评分
        double score = frequencyWeight * frequency + timeWeight * timeDecay;
        return score;
    }

    /**
     * 计算数据适合被存储的时间
     *
     * @param frequency
     * @param lastTime
     * @return
     */
    public static int calculateStorageTime(double frequency, long lastTime) {
        // 根据评分确定数据适合被存储的时间
        double score = calculateScore(frequency, lastTime);
        int storageTime = (int) Math.ceil(score);
        return storageTime;
    }

}

5、缓存

public class CaffeineCacheHolder {
    /**
     * key是appName，value是caffeine
     */
    private static final ConcurrentHashMap<String, Object> CACHE_MAP = new ConcurrentHashMap<>();

    private static final String FIT = "fit";
    private static final String WINDOW = "window";

    private static final String LRU = "lru";
    public static Cache<String, Object> getFitCache() {
        if (CACHE_MAP.get(FIT) == null) {
            // todo 这里要从配置中心拿
            CACHE_MAP.put(FIT, CaffeineBuilder.cache(60, 100, 60));
        }
        return (Cache<String, Object>) CACHE_MAP.get(FIT);
    }

    public static Cache<String, Object> getWindowCache() {
        if (CACHE_MAP.get(WINDOW) == null) {
            // todo 这里要从配置中心拿
            CACHE_MAP.put(WINDOW, CaffeineBuilder.cache(60, 100, 60));
        }
        return (Cache<String, Object>) CACHE_MAP.get(WINDOW);
    }

    public static LruCache getLruCache() {
        if (CACHE_MAP.get(LRU) == null) {
            // todo 这里要从配置中心拿
            CACHE_MAP.put(LRU, new LruCache(1));
        }
        return (LruCache) CACHE_MAP.get(LRU);
    }

}
public class CaffeineBuilder {

    /**
     * 构建所有来的要缓存的key getCache
     */
    public static Cache<String, Object> cache(int minSize, int maxSize, int expireSeconds) {
        return Caffeine.newBuilder()
                .initialCapacity(minSize)
                .maximumSize(maxSize)
                .expireAfterWrite(expireSeconds, TimeUnit.SECONDS)
                .build();
    }

}

四、总结

        fit-cache目前实现了客户端的是否适合缓存、适合缓存时间，还有很多拓展功能思路，比如缓存的失效，数据被更改的时候展示给用户的还是旧的数据；比如缓存的优先序列，低优先级的缓存侵占高优先级缓存的空间等等。作者有了一些方案，需要实践。

        目前作者还在创作完善中，有兴趣的同学欢迎加入。

胖当当技术
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
千万级数据查询：CK、ES、RediSearch怎么选?
emprere的博客
12-31 284
点击关注公众号：互联网架构师，后台回复2T获取2TB学习资源！上一篇：Alibaba开源内网高并发编程手册.pdf前言在开发中遇到一个业务诉求，需要在千万量级的底池数据中筛选出不超过 10W 的数据，并根据配置的权重规则进行排序、打散（如同一个类目下的商品数据不能连续出现 3 次）。下面对该业务诉求的实现，设计思路和方案优化进行介绍。对“千万量级数据中查询 10W 量级的数据”设计了如下方案：多...
缓存工具类
小白一个
07-20 920
【代码】缓存工具类。
【Redis】封装缓存工具类
liuwanqing233333的博客
12-02 476
Redis封装缓存工具类
Caffeine 本地高速缓存工具类
Troub_cy的博客
05-26 1673
Caffeine 是基于 JAVA 8 的高性能缓存库。并且在 spring5 (springboot 2.x) 后，spring 官方放弃了 Guava，而使用了性能更优秀的 Caffeine 作为默认缓存组件。
SpringBoot 下集成缓存工具类 CacheManager
weixin_42176639的博客
04-07 7214
Java 缓存工具类 Cache 工具类定义 SpringBoot 的 CacheManager 接口测试
redis的使用场景
qq_50896786的博客
08-03 6857
查看的缓存: 前部分代码相同@before通知，后部分代码也相同后置通知。我们可以AOP完成缓存代码和业务代码分离。我们看到同一个库存被使用了n次。以及数据库中库存为负数。数据存储在内存中，数据查询速度快。--使用注解即可完成。注意此处的测压速度不易太快（推荐使用5秒100个线程）查询频率比较高，修改频率比较低。发现又出现: 重复数字以及库存为负数。如果搭建了项目集群，那么该锁无效。对应的service层修改为。（1）使用idea开集群项目。service对应代码修改。（1）把缓存的配置类加入。...
hcache缓存cache查看工具
05-26
#直接下载hcache文件到linux,并使用该文件即可 ...#ps： 一般进程缓存的文件并不会太大, 最大的可能性是读写了大文件导致文件被缓存,建议检查下是否存在无用的超大日志,查找大于1G的文件 find / -type f
开源缓存包 EHCache 全接触
05-24
**开源缓存包 EHCache 全接触** EHCache 是一个广泛使用的开源 Java 缓存解决方案，它被设计用于提高应用程序的性能和响应速度，通过存储数据到内存中，避免了频繁的数据库访问。EHCache 适用于多种场景，包括 Web ...
CacheCleaner:练习缓存文件清除工具。-开源
05-08
这就是CacheCleaner发挥作用的地方——它是一个专门设计用于清理浏览器、缩略图和其他图像缓存的开源工具。 **一、什么是CacheCleaner** CacheCleaner是一款高效且易于使用的软件，它的主要任务是帮助用户清理...
Microsoft Office文件缓存清理工具
05-19
关于“源码软件”，这可能意味着该清理工具是开源的，用户可以查看并修改其内部代码。这样的工具对于开发者或有技术背景的用户来说更具透明度和可定制性，他们可以根据自己的需求调整工具的功能。 至于标签中的...
三大缓存比较
12-05
ehcache、memcache、redis三大缓存比较 来源：http://www.cnblogs.com/qlqwjy/p/7788912.html
Java+redis缓存工具类（SSM）
04-28
直接下载可以运行 就是自己需要创建数据库 很简单 参考实体就行 里面有redis的工具类 可以进行参考
JCS1.3开源的缓存架构
03-19
总结，JCS 1.3 是一款适合 Java 开发者的缓存工具，尤其适用于需要缓存管理和持久化的场景。通过深入理解和应用 JCS，开发者可以有效提升应用的性能和响应速度，减轻数据库的压力。不过，在选择缓存框架时，应根据...
真实场景9：4大本地缓存(Map、Guava、Ehcache、Caffeine)，选对了用好了，能让查询性能提升100倍
最新发布
竹林幽深
08-28 1840
Ehcache 是用来管理缓存的一个工具，其缓存的数据可以是存放在内存里面的，也可以是存放在硬盘上的。优点是简单粗暴，不需要引入第三方包，比较适合一些比较简单的场景。然后呢，用户每天都会对我们的系统发起很多次复杂报表查询语句，但是这个 SQL 多表关联的一些逻辑，以及附加的一些查询条件几乎都是有规律的是差不多的，就是每天选择的当天日期是不太一样的。对于一些数据报表的复杂查询，其实每天的查询条件都是差不多的，只不过是当天的日期会有变化而已，另外就是对于一些数据报表的数据，往往是通过大数据平台进行离线计算的。
常见的几种缓存软件以及使用缓存需要考虑的问题
程序员路同学
05-05 2085
几种缓存 EnCache: ● 优点： 基于Java开发的，被Apache认证 基于JVM缓存的（Ehcache的缓存占用的存储空间，和JAVA虚拟机是在一块儿的，也就是说随着缓存的增多，java虚拟机所消耗的内存也会变大） 简单轻巧，方便，广泛应用于hibernate MyBatis ● 缺点： 不支持集群 单点 不支持分布式 存储容量不支持扩展 Memcache ● 优点： 简单的Key-value存储 内存使用率比较高 支持多核多线程 ● 缺点： 无法容灾 无法持久化 Redis
封装redis工具类——缓存工具类
PnJgHT的博客
06-27 394
基于StringRedisTemplate封装一个缓存工具类，满足下列要求：方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL时间 方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题 方法3：根据指定的key查询缓存，并反序列化为指定类型。利用缓存空值解决缓存穿透问题 方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期时间解决缓存击穿问题...
千万级数据查询中CK、ES、RediSearch方案的优化
q66562636的博客
06-01 3527
在开发中遇到一个业务诉求，需要在千万量级的底池数据中筛选出不超过 10W 的数据，并根据配置的权重规则进行排序、打散（如同一个类目下的商品数据不能连续出现 3 次）。下面对该业务诉求的实现，设计思路和方案优化进行介绍，对「千万量级数据中查询 10W 量级的数据」设计了如下方案整体方案设计为技术方案如下 对目标数据 result 进行排序，得到最终的「结果数据」。 CK分页查询 在「初版设计方案」章节的第 3 步提到了「从 CK 底池表取目标数据时，开启多线程，进行分页筛选」。此处对 CK 分页
springboot 缓存工具
04-24
3. Guava：Google开源的Java工具包，其中有一些缓存相关的工具。比如LoadingCache，提供了自动加载缓存的能力，还可以设定缓存过期时间等。 4. Caffeine：仿照Guava中的缓存提供了高速的内存缓存，可以零加锁地提供...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

胖当当技术

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

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

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

打赏作者

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

抵扣说明：

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

余额充值