工具模块及项目整体模块框架

于 2024-10-03 21:13:08 发布
阅读量868 收藏 14
点赞数 12
分类专栏： 仿RabbitMQ实现消息队列 文章标签： jvm java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74461263/article/details/142695934
版权

文章目录

工具模块

这个模块没有什么好说的，就是一些工具的编写，方便进行使用

logger.hpp

#ifndef M_LOG_H__
#define M_LOG_H__
#include <iostream>
#include <ctime>

//封装一个日志宏，通过日志宏进行日志的打印，在打印的信息前带有系统时间以及文件名和行号
//     [17:26:24] [log.cpp:12] 打开文件失败！ 

#define DBG_LEVEL 0
#define INF_LEVEL 1
#define ERR_LEVEL 2
#define DEFAULT_LEVEL DBG_LEVEL
#define LOG(lev_str, level, format, ...) {\
    if (level >= DEFAULT_LEVEL) {\
        time_t t = time(nullptr);\
        struct tm* ptm = localtime(&t);\
        char time_str[32];\
        strftime(time_str, 31, "%H:%M:%S", ptm);\
        printf("[%s][%s][%s:%d]\t" format "\n", lev_str, time_str, __FILE__, __LINE__, ##__VA_ARGS__);\
    }\
}

#define DLOG(format, ...) LOG("DBG", DBG_LEVEL, format, ##__VA_ARGS__)
#define ILOG(format, ...) LOG("INF", INF_LEVEL, format, ##__VA_ARGS__)
#define ELOG(format, ...) LOG("ERR", ERR_LEVEL, format, ##__VA_ARGS__)

#endif

helper.hpp

sqlite3

class SqliteHelper {
    public:
        typedef int(*SqliteCallback)(void*,int,char**,char**);
        SqliteHelper(const std::string &dbfile) : _dbfile(dbfile), _handler(nullptr){}
        
        bool open(int safe_leve = SQLITE_OPEN_FULLMUTEX) {
            //int sqlite3_open_v2(const char *filename, sqlite3 **ppDb, int flags, const char *zVfs );
            int ret = sqlite3_open_v2(_dbfile.c_str(), &_handler, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | safe_leve, nullptr);
            if (ret != SQLITE_OK) {
                ELOG("创建/打开sqlite数据库失败: %s", sqlite3_errmsg(_handler));
                return false;
            }
            return true;
        }
        bool exec(const std::string &sql, SqliteCallback cb, void *arg) {
            //int sqlite3_exec(sqlite3*, char *sql, int (*callback)(void*,int,char**,char**), void* arg, char **err)
            int ret = sqlite3_exec(_handler, sql.c_str(), cb, arg, nullptr);
            if (ret != SQLITE_OK) {
                ELOG("%s \n语句执行失败: %s", sql.c_str(), sqlite3_errmsg(_handler));
                return false;
            }
            return true;
        }
        void close() {
            if (_handler) sqlite3_close_v2(_handler);
        }
    private:
        std::string _dbfile;
        sqlite3 *_handler;
};

字符串分割

class StrHelper{
    public:
        static size_t split(const std::string &str, const std::string &sep, std::vector<std::string> &result) {
            size_t pos, idx = 0;
            while(idx < str.size()) {
                pos = str.find(sep, idx);
                if (pos == std::string::npos) {
                    result.push_back(str.substr(idx));
                    return result.size();
                }
                if (pos == idx) {
                    idx = pos + sep.size();
                    continue;
                }
                result.push_back(str.substr(idx, pos - idx));
                idx = pos + sep.size();
            }
            return result.size();
        }
};

生成随机数

class UUIDHelper {
    public:
        static std::string uuid() {
            std::random_device rd;
            std::mt19937_64 gernator(rd());
            std::uniform_int_distribution<int> distribution(0, 255);
            std::stringstream ss;
            for (int i = 0; i < 8; i++) {
                ss << std::setw(2) << std::setfill('0') << std::hex << distribution(gernator) ;
                if (i == 3 || i == 5 || i == 7) {
                    ss << "-";
                }
            }
            static std::atomic<size_t> seq(1);
            size_t num = seq.fetch_add(1);
            for (int i = 7; i >= 0; i--) {
                ss << std::setw(2) << std::setfill('0') << std::hex << ((num>>(i*8)) & 0xff);
                if (i == 6) ss << "-";
            }
            return ss.str();
        }
};

文件常用操作

class FileHelper {
    public:
        FileHelper(const std::string &filename):_filename(filename){}
        bool exists() //判断文件是否存在
        {
            struct stat st;
            return (stat(_filename.c_str(), &st) == 0);
        }
        size_t size() {  //文件大小
            struct stat st;
            int ret = stat(_filename.c_str(), &st);
            if (ret < 0) {
                return 0;
            }
            return st.st_size;
        }
        bool read(char *body, size_t offset, size_t len) //读取文件，从offset位置读取len长度
        {
            //1. 打开文件
            std::ifstream ifs(_filename, std::ios::binary | std::ios::in); 
            if (ifs.is_open() == false) {
                ELOG("%s 文件打开失败！", _filename.c_str());
                return false;
            }
            //2. 跳转文件读写位置
            ifs.seekg(offset, std::ios::beg);
            //3. 读取文件数据
            ifs.read(body, len);
            if (ifs.good() == false) {
                ELOG("%s 文件读取数据失败！！", _filename.c_str());
                ifs.close();
                return false;
            }
            //4. 关闭文件
            ifs.close();
            return true;
        }
        bool read(std::string &body) {
            //获取文件大小，根据文件大小调整body的空间
            size_t fsize = this->size();
            body.resize(fsize);
            return read(&body[0], 0, fsize);
        }
        bool write(const char *body, size_t offset, size_t len) {//向文件写入
            //1. 打开文件
            std::fstream fs(_filename, std::ios::binary | std::ios::in | std::ios::out); 
            if (fs.is_open() == false) {
                ELOG("%s 文件打开失败！", _filename.c_str());
                return false;
            }
            //2. 跳转到文件指定位置
            fs.seekp(offset, std::ios::beg);
            //3. 写入数据
            fs.write(body, len);
            if (fs.good() == false) {
                ELOG("%s 文件写入数据失败！！", _filename.c_str());
                fs.close();
                return false;
            }
            //4. 关闭文件
            fs.close();
            return true;
        }
        bool write(const std::string &body) {
            return write(body.c_str(), 0, body.size());
        }
        bool rename(const std::string &nname) {//重命名
            return (::rename(_filename.c_str(), nname.c_str()) == 0);
        }
        static std::string parentDirectory(const std::string &filename) {//获取父文件目录
            // /aaa/bb/ccc/ddd/test.txt
            size_t pos = filename.find_last_of("/");
            if (pos == std::string::npos) {
                // test.txt
                return "./";
            }
            std::string path = filename.substr(0, pos);
            return path;
        }
        static bool createFile(const std::string &filename) {//创建文件
            std::fstream ofs(filename, std::ios::binary | std::ios::out); 
            if (ofs.is_open() == false) {
                ELOG("%s 文件打开失败！", filename.c_str());
                return false;
            }
            ofs.close();
            return true;
        }
        static bool removeFile(const std::string &filename) {//删除文件
            return (::remove(filename.c_str()) == 0);
        }
        static bool createDirectory(const std::string &path) {//创建父文件目录
            //  aaa/bbb/ccc    cccc
            // 在多级路径创建中，我们需要从第一个父级目录开始创建
            size_t pos, idx = 0;
            while(idx < path.size()) {
                pos = path.find("/", idx);
                if (pos == std::string::npos) {
                    return (mkdir(path.c_str(), 0775) == 0);
                }
                std::string subpath = path.substr(0, pos);
                int ret = mkdir(subpath.c_str(), 0775);
                if (ret != 0 && errno != EEXIST) {
                    ELOG("创建目录 %s 失败: %s", subpath.c_str(), strerror(errno));
                    return false;
                }
                idx = pos + 1;
            }
            return true;
        }
        static bool removeDirectory(const std::string &path) {//删除父文件目录
            // rm -rf path
            // system()
            std::string cmd = "rm -rf " + path;
            return (system(cmd.c_str()) != -1);
        }
    private:
        std::string _filename;
};

threadpool.hpp

class threadpool {
    public:
        using ptr = std::shared_ptr<threadpool>;
        using Functor = std::function<void(void)>;
        threadpool(int thr_count = 1) : _stop(false){
            for (int i = 0; i < thr_count; i++) {
                _threads.emplace_back(&threadpool::entry, this);
            }
        }
        ~threadpool() {
            stop();
        }
        void stop() {
            if (_stop == true) return;
            _stop = true;
            _cv.notify_all();
            for (auto &thread : _threads) {
                thread.join();
            }
        }
        //push传入的是首先有一个函数--用户要执行的函数， 接下来是不定参，表示要处理的数据也就是要传入到函数中的参数
        //push函数内部，会将这个传入的函数封装成一个异步任务（packaged_task），
        //使用lambda生成一个可调用对象（内部执行异步任务），抛入到任务池中，由工作线程取出进行执行
        template<typename F, typename ...Args>
        auto push(F &&func, Args&& ...args) -> std::future<decltype(func(args...))> {
            //1. 将传入的函数封装成一个packaged_task任务
            using return_type = decltype(func(args...));
            auto tmp_func = std::bind(std::forward<F>(func), std::forward<Args>(args)...);
            auto task = std::make_shared<std::packaged_task<return_type()>>(tmp_func);
            std::future<return_type> fu = task->get_future();
            //2. 构造一个lambda匿名函数（捕获任务对象），函数内执行任务对象
            {
                std::unique_lock<std::mutex> lock(_mutex);
                //3. 将构造出来的匿名函数对象，抛入到任务池中
                _taskpool.push_back(   [task](){ (*task)(); }  );
                _cv.notify_one();
            }
            return fu;
        }

    private:
        //线程入口函数---内部不断的从任务池中取出任务进行执行。
        void entry() {
            while(!_stop){
                std::vector<Functor> tmp_taskpool;
                {
                    //加锁
                    std::unique_lock<std::mutex> lock(_mutex);
                    //等待任务池不为空，或者_stop被置位返回，
                    _cv.wait(lock, [this](){ return _stop || !_taskpool.empty(); });
                    //取出任务进行执行
                    tmp_taskpool.swap(_taskpool);
                }
                for (auto &task : tmp_taskpool) {
                    task();
                }
            }
        }
    private:
        std::atomic<bool> _stop;
        std::vector<Functor> _taskpool;//任务池
        std::mutex _mutex;
        std::condition_variable _cv;
        std::vector<std::thread> _threads;
};

核心概念

  • ⽣产者(Producer)
  • 消费者(Consumer)
  • 中间⼈(Broker)
  • 发布(Publish)
  • 订阅Subscribe)
  • ⼀个⽣产者，一个消费者
    在这里插入图片描述
  • N个⽣产者，N个消费者
    在这里插入图片描述
    其中，Broker Server是最核⼼的部分, 负责消息的存储和转发。

在这里插入图片描述
在这里插入图片描述
上述数据结构，既需要在内存中存储，也需要在硬盘中存储

  • 内存存储: ⽅便使⽤
  • 硬盘存储：重启数据不丢失

核心API

对于Broker来说,要实现以下核⼼API，通过这些API来实现消息队列的基本功能

在这里插入图片描述

另⼀⽅⾯,Producer和Consumer则通过⽹络的⽅式,远程调⽤这些API,实现⽣产者消费者模型

交换机类型

对于RabbitMQ来说,主要⽀持三种交换机类型：

  • Direct ： ⽣产者发送消息时,直接指定被该交换机绑定的队列
  • Fanout ： ⽣产者发送的消息会被复制到该交换机的所有队列中
  • Topic ： 绑定队列到交换机上时,指定⼀个字符串为bindingKey。发送消息指定⼀个字符串为routingKey。当routingKey和bindingKey满⾜⼀定的匹配条件的时候,则把消息投递到指定队列。

持久化

Exchange,Queue,Binding,Message等数据都有持久化需求
当程序重启/主机重启保证 ， 上述内容不丢失。

⽹络通信

⽣产者和消费者都是客⼾端程序,Broker则是作为服务器，通过⽹络进⾏通信。
在⽹络通信的过程中,客⼾端部分要提供对应的api,来实现对服务器的操作。

在这里插入图片描述
可以看到,在Broker的基础上,客⼾端还要增加Connection操作和Channel操作

  • Connection对应⼀个TCP连接
  • Channel则是Connection中的逻辑通道

⼀个Connection中可以包含多个Channel。Channel和Channel之间的数据是独⽴的，不会相互⼲扰。这样做主要是为了能够更好的复⽤TCP连接,达到⻓连接的效果,避免频繁的创建关闭TCP连接。

消息应答

被消费的消息,需要进⾏应答。应答模式分成两种：

在这里插入图片描述

持久化数据管理中心模块

在这里插入图片描述

虚拟机管理模块

因为交换机/队列/绑定都是基于虚拟机为单元整体进⾏操作的，因此虚拟机是对以上数据管理模块的整合模块。

在这里插入图片描述

交换路由模块

当客⼾端发布⼀条消息到交换机后，这条消息，应该被⼊队到该交换机绑定的哪些队列中？交换路由模块就是决定这件事情的。

在这里插入图片描述
在这里插入图片描述

消费者管理模块

消费者管理是以队列为单元的，因为每个消费者都会在开始的时候订阅⼀个队列的消息，当队列中有消息后，会将队列消息轮询推送给订阅了该队列的消费者。

因此操作流程通常是，从队列关联的消息管理中取出消息，从队列关联的消费者中取出⼀个消费者，然后将消息推送给消费者（这就是发布订阅中负载均衡的⽤法）

在这里插入图片描述

信道管理模块

本质上，在AMQP模型中，除了通信连接Connection概念外，还有⼀个Channel的概念，Channel是针对Connection连接的⼀个更细粒度的通信信道，多个Channel可以使⽤同⼀个通信连接Connection进⾏通信，但是同⼀个Connection的Channel之间相互独⽴。

在这里插入图片描述

连接管理模块

本质上，咱们仿照实现的服务器是通过muduo库来实现底层通信的，⽽这⾥的连接管理，更多的是对muduo库中的Connection进⾏⼆次封装管理，并额外提供项⽬所需操作。

在这里插入图片描述

Broker服务器模块

整合以上所有模块，并搭建⽹络通信服务器，实现与客⼾端⽹络通信，能够识别客⼾端请求，并提供客⼾端请求的处理服务。
在这里插入图片描述

消费者管理

消费者在客⼾端的存在感⽐较低，因为在⽤⼾的使⽤⻆度中，只要创建⼀个信道后，就可以通过信道完成所有的操作，因此对于消费者的感官更多是在订阅的时候传⼊了⼀个消费者标识，且当前的简单实现也仅仅是⼀个信道只能创建订阅⼀个队列，也就是只能创建⼀个消费者，它们⼀⼀对应，因此更是弱化了消费者的存在。

在这里插入图片描述

信道请求模块

与服务端的信道类似，客⼾端这边在AMQP模型中，也是除了通信连接Connection概念外，还有⼀个Channel的概念，Channel是针对Connection连接的⼀个更细粒度的通信信道，多个Channel可以使⽤同⼀个通信连接Connection进⾏通信，但是同⼀个Connection的Channel之间相互独⽴。

在这里插入图片描述

通信连接模块

向⽤⼾提供⼀个⽤于实现⽹络通信的Connection对象，从其内部可创建出粒度更轻的Channel对象，⽤于与服务端进⾏⽹络通信。

在这里插入图片描述

项⽬模块关系图

在这里插入图片描述

niu_sama
关注
专栏目录
spring cloud多模块项目框架搭建-搭架子
百块富翁的博客
11-19 2225
第三章 spring cloud多模块项目框架搭建-maven多模块项目框架搭建 经过前面两章的废话，从本章开始进入正式的搭建过程，我们采用先动手后动口，不然很多小伙伴嫌弃总说些废话，迟迟get不到干货。动手过程固然重要，后面的为什么这么操作也不可忽略啊。 本章将使用idea 利用maven搭建spring cloud多模块框架，开发你的多模块Spring cloud Hello Word.我们搭建一个电商的架构，分为四个模块，一个activity(活动)模块，一个order（订单）模块，一个comm.
spring cloud多模块项目框架搭建-目录
百块富翁的博客
11-20 1398
spring cloud多模块项目框架搭建-目录 为了让各位看官老爷更好的阅读，明白各篇博客中所集成的组件的先后顺序；甚至是跟着我的步伐，通过这一系列博客亲手搭建出自己的spring cloud多模块项目框架，所以写了几章后，才回来写这个目录。我也是在上班忙里偷闲写的，一边要小心老大突然出现在身后，发现不务正业扣我的钱钱，所以更新有些慢，但是尽我所能持续更新。欢迎留言或私聊指正批评。如果需要转载，也是欢迎，不甚荣幸，但请把《spring cloud多模块项目框架搭建》这一系列博客全部一起转载，这一系列
基于SpringBoot构建分模块项目
L_Wierpuller的博客
05-20 4112
基于SpringBoot构建分模块项目前言~~步骤过于详细，多图慎入！！！~~构建创建父模块创建 erp-common创建 erp-service创建erp-service-impl创建erp-web-repertory创建其余web模块依赖运行扩展占位符 前言 步骤过于详细，多图慎入！！！ 假设一个场景，要开发一个4s店维修部的办公系统，其功能有：前台接待，维修抢单，财务结算，库存管理。于是...
构建Maven多模块项目+SSM框架整合(一)
vili_sky的博客
11-15 1万+
构建Maven多模块项目+SSM框架整合
Android应用架构的一些思考-框架模块化
u011734444的专栏
02-04 6794
在Android开发的路上，会经常经历到如下的问题：每建一个新项目，都要编写基类，从老项目中把工具类复制过来，编写空页面最后把整个工程搭建起来；然后建立一个任务美其名曰：框架搭建:) 这样折腾一下基本一天两天时间就没有了，而且有的时候有些以前写过的比较少用的代码，如果新项目中用到，还要打开老项目找，适配到新项目上，贼浪费时间。有了分层架构之后，我就有了这样的想法：既然编写的基类和工具类都已经是跟具体业务无关了，那么为什么不将其抽出来做成一个Module，变成项目无关呢？
Android模块化与ARouter框架
一杯清泉
07-14 4465
    在APP开发的初期，代码了不大，业务量比较下，一个APP作为一个单独的模块进行开发，往往问题不大，而且还能加快开发效率但是随着APP的用户量越来越多，也越来越复杂，这种开发方式显得结构特别的臃肿，特别是多个开发人员进行开发维护一个项目的时候每个人的代码质量也不相同，容易会产生代码冲突的问题。同时随着业务的增多，代码变的越来越复杂，每个模块之间的代码耦合变得越来越严重，导致代码混乱，没法进行...
Winform开发框架之通用自动更新模块
xfxf996的博客
08-17 2367
在网络化的环境中，特别是基于互联网发布的Winform程序，程序的自动更新功能是比较重要的操作，这样可以避免挨个给使用者打电话、发信息通知或者发送软件等，要求其对应用程序进行升级。实现程序的自动更新，
【gradle】idea+gradle 多模块项目创建教程入门例子
热门推荐
一名普通码农的菜地
01-17 1万+
前言 详情可参考： Gradle构建多模块项目 项目创建配置 新建项目 选择本地的gradle，保证gradle的版本至少为4或以上。 填写group、artifactid、版本号。 根节点项目创建完毕。 然后，创建多个模块，假设背景为需要进行远程调用的提供者服务，这里以 api 和 web 模块为例， api -模块 新建模块： 模块名称存放位置： 创建成功。 web模块 ...
Python中的模块化编程与软件架构设计
一键难忘的博客
04-19 2894
在软件开发中，模块化编程和良好的软件架构设计是确保项目可维护性、可扩展性和可重用性的关键。Python作为一种灵活且功能丰富的编程语言，提供了许多工具和技术来实现模块化编程和优秀的软件架构设计。本文将介绍Python中的模块化编程概念，并结合实例展示如何设计灵活的软件架构。
php项目总体架构怎么写,系统服务化构建-项目整体框架
weixin_33613462的博客
03-23 1280
本篇文章旨在讨论如何组织通用型项目代码结构，以PHP YII2框架为例做说明，设计思想与语言本身无关。以下是本文的大纲业务服务型项目系统定位基础功能组件业务功能组件基础功能组件与业务模块组件异同宿主工程模块之间调用关系业务服务型项目系统定位业务服务型项目，包括业务对外SOA API接口，微服务接口，业务中台服务，业务服务中间件，不包括通用的官网类似的MVC项目，CMS系统。采用自顶而下，分而治之的...
应用WEB框架模块设计
10-05
它对请求安全、框架整体型起到至关作用。关羽安排在荆州这个战略要地的原因就是因为这里的重要性。 路由（Router） 路由是WEB框架的引路人徐庶，负责引导请求到达正确的控制层。路由模块对系统的迁移升级和适应...
以SpringBoot为项目框架搭建的多模块版本，包含系统基础设置账号权限模块、日志模块、监控模块、代码生成模块
03-16
在SpringBoot项目中，我们可以利用Maven或Gradle等构建工具来实现模块化，每个模块作为一个单独的子项目，共同构成整体应用。 接下来，我们逐一分析这些模块： 1. **系统基础设置模块**：这是任何项目的基础，包括...
框架myframe_含数据库_new.rar_9UU_my _frame模块_pb框架_框架
09-23
模块化设计使得代码更易于维护和扩展，每个模块都可以独立工作，同时又可以与其他模块协同，提升了整体项目的灵活性。 "pb框架"则是myframe框架中的一个重要组成部分，可能指的是Protocol Buffers（谷歌的一种数据...
springboot 多模块将dao(mybatis)项目拆分出去
08-27
SpringBoot 多模块项目拆分实践 在软件开发中，随着项目的日益复杂，单模块项目已经不能满足需求。因此，多模块项目的拆分变得非常必要。拆分后的模块可以单独维护、更新和部署，从而提高了项目的灵活性和可维护性...
thinkPHP5.0框架整体架构总览【应用,模块,MVC,驱动,行为,命名空间等】
12-20
本文讲述了thinkPHP5.0框架整体架构。分享给大家供大家参考，具体如下： ThinkPHP5.0应用基于MVC（模型-视图-控制器）的方式来组织。 MVC是一个设计模式，它强制性的使应用程序的输入、处理和输出分开。使用MVC应用...
关于 JVM 个人 NOTE
一个热爱编程的大学僧
09-30 662
堆内存的分配和释放由JVM的垃圾回收器（Garbage Collector, GC）自动管理。栈内存中的局部变量和方法调用信息在不再需要时会自动被释放，不会出现像堆内存中那样的垃圾对象。由于栈内存的分配和释放都是自动的，且与方法的调用和返回紧密相关，因此。堆内存中可能会存在已经不被使用但仍未被回收的垃圾对象。垃圾回收器并不是实时运行的。栈内存的分配和释放是自动的。
python的内存管理机制
最新发布
weixin_71113035的博客
10-01 487
python的内存管理机制
SQLite数据库介绍
ye_yumo的博客
09-30 559
SQLite是一个本地化的数据库,不需要客户端服务端什么的配置,主打就是轻量化方便化。他也不是一个独立的进程,而是可以根据应用程序的需求,可以进行静态或者动态的连接。第三个参数是flag是可以设置文件的打开方式,提供下面的宏可以选择。需要注意的是 在SQLite中一个数据库对应了一个数据库文件。而且他是直接存储在磁盘文件的,提供了简单易用的API接口。第一个参数是文件名,第二个参数是传入一个句柄指针的地址。如果是其他值的话就代表着有问题,需要查找对应的宏来看到。这是一个执行语句的操作函数。
【JVM】垃圾释放方式：标记-清除、复制算法、标记-整理、分代回收
Yeeear的博客
09-26 9061
把标记为垃圾的对象的内存空间进行释放。主要有三种释放方式。
项目管理框架详解：组织形式与关键模块
本课程以"选择合适的项目组织形式-项目管理框架"为核心，深入探讨了项目管理的关键组成部分及其在信息技术领域的应用。课程分为11个章节，共21学时，涵盖了项目管理的各个方面，包括但不限于： 1. **项目管理框架**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值