Rust生态系统构建：Cargo工具链与包管理

最新推荐文章于 2025-10-29 20:59:35 发布
原创 最新推荐文章于 2025-10-29 20:59:35 发布 · 1.2k 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Rust生态系统构建：Cargo工具链与包管理

【免费下载链接】book The Rust Programming Language 【免费下载链接】book 项目地址: https://gitcode.com/gh_mirrors/bo/book

本文深入探讨了Rust生态系统中的Cargo工具链与包管理机制，涵盖了Cargo工作区与多crate项目的组织管理、Crates.io发布流程与版本控制策略、自定义Cargo命令扩展与插件开发，以及依赖管理与构建优化的最佳实践。通过系统性的介绍，帮助开发者掌握高效管理复杂Rust项目的技术和方法。

Cargo工作区与多crate项目的组织管理

在Rust生态系统中，随着项目规模的不断扩大，单一包结构往往难以满足复杂应用的需求。Cargo工作区（Workspace）功能为开发者提供了一种优雅的方式来管理多个相关的包，这些包共享依赖关系和构建输出，同时保持各自的独立性。

工作区的基本概念与优势

Cargo工作区是一组共享相同Cargo.lock文件和输出目录的包集合。这种设计带来了多重优势：

共享依赖管理：工作区内所有包使用统一的依赖版本，确保兼容性 统一构建输出：所有编译产物存放在共享的target目录中，避免重复构建 独立开发维护：每个包可以独立开发、测试和发布，同时保持紧密协作

mermaid

创建工作区结构

创建一个新的工作区需要从顶层目录开始，首先建立工作区配置文件：

mkdir my_workspace
cd my_workspace

在工作区根目录创建Cargo.toml文件，配置工作区成员：

[workspace]
members = ["crate_a", "crate_b", "crate_c"]
resolver = "2"

添加工作区成员包

使用cargo new命令在工作区内创建新的包：

# 创建二进制crate
cargo new crate_a

# 创建库crate  
cargo new crate_b --lib

# 创建另一个库crate
cargo new crate_c --lib

Cargo会自动将这些新创建的包添加到工作区的members列表中。

包间依赖关系管理

在工作区内，包之间的依赖需要通过路径依赖明确指定。例如，如果crate_a需要依赖crate_b：

# crate_a/Cargo.toml
[dependencies]
crate_b = { path = "../crate_b" }

统一依赖版本管理

工作区的核心优势之一是统一的依赖管理。所有包共享同一个Cargo.lock文件：

特性传统多包项目Cargo工作区
依赖版本每个包独立统一管理
构建输出分散在各包目录集中管理
磁盘空间可能重复占用优化使用
构建时间可能重复编译避免重复

工作区命令操作

Cargo提供了专门的工作区操作命令：

# 构建整个工作区
cargo build

# 构建特定包
cargo build -p crate_a

# 运行特定二进制包
cargo run -p crate_a

# 测试特定包
cargo test -p crate_b

# 发布特定包到crates.io
cargo publish -p crate_b

复杂工作区配置示例

对于大型项目，工作区配置可以更加精细化：

[workspace]
members = [
    "binaries/main_app",
    "libraries/core",
    "libraries/utils", 
    "libraries/database",
    "tests/integration"
]

resolver = "2"
exclude = ["experimental", "deprecated"]

[workspace.dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.0", features = ["full"] }

测试与文档生成

工作区支持统一的测试和文档生成：

# 运行所有包的测试
cargo test --workspace

# 为所有包生成文档
cargo doc --workspace --no-deps

# 运行特定包的测试
cargo test -p core_lib

# 生成并打开文档
cargo doc --workspace --open

实际项目结构示例

一个典型的工作区项目结构如下：

my_project/
├── Cargo.toml          # 工作区配置
├── Cargo.lock          # 共享依赖锁
├── target/             # 统一构建目录
├── core/               # 核心库crate
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── utils/              # 工具库crate  
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── cli/                # 命令行工具crate
│   ├── Cargo.toml
│   └── src/
│       └── main.rs
└── web/                # Web服务crate
    ├── Cargo.toml
    └── src/
        └── main.rs

依赖解析策略

Cargo工作区使用先进的依赖解析算法确保兼容性：

mermaid

最佳实践与注意事项

  1. 明确的依赖声明：即使在工作区内，也需要显式声明包间依赖
  2. 版本兼容性：确保工作区内包使用的依赖版本相互兼容
  3. 构建优化：利用工作区的共享构建特性减少编译时间
  4. 文档一致性：统一的工作区文档生成确保API文档的一致性
  5. 测试策略：结合单元测试和集成测试，充分利用工作区特性

通过Cargo工作区，Rust开发者可以高效地组织和管理复杂的多crate项目，确保代码的可维护性和扩展性，同时享受统一的依赖管理和构建优化带来的便利。

Crates.io发布流程与版本控制策略

Rust生态系统的核心组件Crates.io为开发者提供了一个强大而可靠的包分发平台。掌握正确的发布流程和版本控制策略对于维护健康的Rust项目至关重要。本文将深入探讨Crates.io的完整发布机制、版本管理最佳实践以及维护策略。

Crates.io账户配置与认证

在发布任何crate之前，必须首先建立Crates.io账户。当前版本要求通过GitHub账户进行身份验证，确保发布者身份的可追溯性。账户创建完成后，需要获取API令牌并通过cargo login命令进行本地配置：

$ cargo login
abcdefghijklmnopqrstuvwxyz012345

此命令将API令牌安全存储在~/.cargo/credentials.toml中。令牌属于敏感信息，一旦泄露应立即在Crates.io上撤销并重新生成。

包元数据配置要求

发布前的关键步骤是完善Cargo.toml文件的元数据配置。Crates.io对包元数据有严格的要求，缺失必要信息将导致发布失败：

[package]
name = "unique_crate_name"
version = "0.1.0"
edition = "2024"
description = "简要描述包的功能和用途"
license = "MIT OR Apache-2.0"

# 可选但推荐的元数据字段
repository = "https://gitcode.com/gh_mirrors/bo/book"
documentation = "https://docs.rs/unique_crate_name"
homepage = "https://project-homepage.com"
keywords = ["web", "async", "performance"]
categories = ["web-programming", "network-programming"]

包名称遵循先到先得原则，一旦被占用就无法再次使用。在选择名称前，务必通过Crates.io搜索确认可用性。

语义化版本控制规范

Rust生态系统严格遵循语义化版本控制（SemVer）规范，这是确保依赖兼容性的基石。版本号格式为MAJOR.MINOR.PATCH：

版本段递增条件说明
MAJOR不兼容的API变更破坏性变更，需要用户修改代码
MINOR向后兼容的功能性新增新增功能但保持兼容性
PATCH向后兼容的问题修复bug修复，无新功能

版本约束运算符示例：

[dependencies]
serde = "1.0"          # 兼容1.0.x系列
tokio = ">=1.0, <2.0"  # 1.x系列但不包括2.0
async-std = "^1.5"     # 至少1.5.0但低于2.0.0

发布流程详解

完整的发布流程包含多个验证步骤，确保代码质量和平台稳定性：

mermaid

发布命令执行过程：

$ cargo publish
    Updating crates.io index
   Packaging my_crate v0.1.0
    Packaged 6 files, 1.2KiB (895.0B compressed)
   Verifying my_crate v0.1.0
   Compiling my_crate v0.1.0
    Finished dev profile [unoptimized + debuginfo] target(s) in 0.19s
   Uploading my_crate v0.1.0
    Uploaded my_crate v0.1.0 to registry `crates-io`
   Published my_crate v0.1.0 at registry `crates-io`

版本撤回机制

Crates.io采用不可变发布策略，已发布的版本无法删除，但可以通过yank机制标记为不推荐使用：

# 撤回特定版本
$ cargo yank --vers 1.0.1

# 撤销撤回操作
$ cargo yank --vers 1.0.1 --undo

yank操作的影响：

  • ✅ 现有项目继续正常工作（Cargo.lock保持不变）
  • ✅ 已依赖的项目不会受到影响
  • ❌ 新项目无法添加该版本为依赖
  • ❌ 不会从服务器删除代码内容

多版本发布策略

对于长期维护的项目，合理的版本发布策略至关重要：

版本类型发布频率维护期适用场景
稳定版每6-12个月长期支持生产环境
功能版每1-3个月中期支持新特性尝鲜
补丁版按需发布短期支持紧急修复

示例版本发布序列：

0.1.0 → 0.1.1 (补丁修复) → 0.2.0 (功能新增) 
→ 1.0.0 (稳定版) → 1.0.1 (安全修复)
→ 1.1.0 (兼容性功能) → 2.0.0 (重大变更)

文档与质量控制

完善的文档是成功发布的关键组成部分。Rust提供了强大的文档工具链：

/// 计算两个数的和
///
/// # Examples
///
/// ```
/// use my_crate::add;
/// let result = add(2, 2);
/// assert_eq!(result, 4);
/// ```
///
/// # Panics
/// 当溢出发生时可能panic
///
/// # Errors
/// 返回Result类型时的错误情况说明
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

文档测试自动验证：

$ cargo test --doc

依赖管理最佳实践

有效的依赖管理可以减少发布过程中的问题：

  1. 版本约束灵活性：使用宽容的版本约束避免不必要的破坏
  2. 可选依赖项：将非核心功能设为可选依赖
  3. 特性标志：通过特性控制功能模块的包含
  4. 工作区管理：对于多crate项目使用Cargo工作区
[features]
default = ["std"]
std = []  # 标准库支持
async = ["tokio"]  # 异步功能

[dependencies]
tokio = { version = "1.0", optional = true }
serde = { version = "1.0", features = ["derive"] }

安全与合规考虑

发布前的安全检查清单：

  •  确认不包含敏感信息（API密钥、密码等）
  •  验证所有依赖项的安全性
  •  检查许可证兼容性
  •  运行安全扫描工具（cargo-audit）
  •  确保代码符合Rust安全最佳实践

通过遵循这些发布流程和版本控制策略，开发者可以建立健壮、可维护的Rust包生态系统，为整个社区贡献高质量的开源组件。

自定义Cargo命令扩展与插件开发

Rust的Cargo工具链提供了强大的扩展机制，允许开发者创建自定义命令来增强开发工作流。这种设计哲学体现了Rust生态系统的开放性和可扩展性，让开发者能够根据特定需求定制自己的开发工具。

Cargo自定义命令的工作原理

Cargo的自定义命令机制基于一个简单的命名约定：任何位于$PATH环境变量中的可执行文件，只要其名称以cargo-为前缀，就可以作为Cargo的子命令使用。例如，一个名为cargo-mycmd的可执行文件可以通过cargo mycmd来调用。

mermaid

这种设计模式的优点在于：

  • 无需修改Cargo源码：扩展功能不会影响Cargo的核心稳定性
  • 易于安装和分发：通过cargo install即可安装自定义命令
  • 自动发现：安装后自动出现在cargo --list的输出中
  • 参数传递：所有传递给cargo mycmd的参数都会转发给cargo-mycmd

创建自定义Cargo命令

创建一个基本的自定义Cargo命令只需要几个简单的步骤。首先，创建一个新的Rust二进制项目：

cargo new cargo-mycommand
cd cargo-mycommand

编辑Cargo.toml文件，确保项目名称以cargo-前缀开头：

[package]
name = "cargo-mycommand"
version = "0.1.0"
edition = "2021"

[dependencies]
clap = { version = "4.0", features = ["derive"] }
anyhow = "1.0"

在src/main.rs中实现命令逻辑：

use clap::{Arg, ArgMatches, Command};
use std::process;

fn main() -> anyhow::Result<()> {
    let matches = cli().get_matches();
    
    if let Some(matches) = matches.subcommand_matches("mycommand") {
        // 处理命令逻辑
        let verbose = matches.get_flag("verbose");
        if verbose {
            println!("详细模式已启用");
        }
        
        println!("执行自定义命令!");
        // 这里可以添加实际的命令逻辑
    }
    
    Ok(())
}

fn cli() -> Command {
    Command::new("cargo-mycommand")
        .about("一个示例自定义Cargo命令")
        .subcommand_required(true)
        .arg_required_else_help(true)
        .subcommand(
            Command::new("mycommand")
                .about("执行自定义操作")
                .arg(Arg::new("verbose")
                    .short('v')
                    .long("verbose")
                    .help("启用详细输出")
                    .action(clap::ArgAction::SetTrue))
        )
}

高级自定义命令开发

对于更复杂的自定义命令，通常需要与Cargo进行交互，获取项目信息或执行构建操作。Cargo提供了cargo_metadata库来帮助解析项目元数据：

[dependencies]
cargo_metadata = "0.15"
clap = { version = "4.0", features = ["derive"] }
serde = { version = "1.0", features = ["derive"] }
anyhow = "1.0"

use cargo_metadata::MetadataCommand;
use clap::{Arg, Command};
use std::process;

fn main() -> anyhow::Result<()> {
    let matches = Command::new("cargo-mycommand")
        .bin_name("cargo-mycommand")
        .subcommand_required(true)
        .subcommand(
            Command::new("analyze")
                .about("分析项目依赖")
                .arg(Arg::new("verbose").short('v').long("verbose"))
        )
        .get_matches();

    if let Some(("analyze", sub_matches)) = matches.subcommand() {
        let verbose = sub_matches.get_flag("verbose");
        
        // 获取项目元数据
        let metadata = MetadataCommand::new()
            .no_deps()
            .exec()?;
            
        println!("项目名称: {}", metadata.workspace_root);
        println!("包数量: {}", metadata.packages.len());
        
        if verbose {
            for package in &metadata.packages {
                println!("- {} v{}", package.name, package.version);
            }
        }
    }
    
    Ok(())
}

实用的自定义命令模式

在实际开发中，自定义命令通常用于以下场景：

1. 项目脚手架生成
use std::fs;
use std::path::Path;

fn generate_project_template(project_name: &str) -> anyhow::Result<()> {
    let project_dir = Path::new(project_name);
    fs::create_dir_all(project_dir)?;
    
    // 创建Cargo.toml
    let cargo_toml = format!(
        r#"[package]
name = "{}"
version = "0.1.0"
edition = "2021"

[dependencies]
"#, project_name
    );
    
    fs::write(project_dir.join("Cargo.toml"), cargo_toml)?;
    
    // 创建src目录和main.rs
    let src_dir = project_dir.join("src");
    fs::create_dir_all(&src_dir)?;
    
    let main_rs = r#"fn main() {
    println!("Hello, world!");
}
"#;
    
    fs::write(src_dir.join("main.rs"), main_rs)?;
    
    println!("项目 '{}' 已创建成功!", project_name);
    Ok(())
}
2. 依赖分析工具
use cargo_metadata::{Dependency, Metadata, Package};

fn analyze_dependencies(metadata: &Metadata) {
    let mut dependency_table = Vec::new();
    
    for package in &metadata.packages {
        for dep in &package.dependencies {
            dependency_table.push((
                package.name.clone(),
                dep.name.clone(),
                dep.req.to_string(),
                if dep.optional { "可选" } else { "必需" }.to_string(),
            ));
        }
    }
    
    println!("{:<20} {:<20} {:<10} {:<8}", "包", "依赖", "版本", "类型");
    println!("{}", "-".repeat(60));
    
    for (pkg, dep, version, dep_type) in dependency_table {
        println!("{:<20} {:<20} {:<10} {:<8}", pkg, dep, version, dep_type);
    }
}
3. 构建后处理命令

mermaid

测试和调试自定义命令

为确保自定义命令的可靠性，需要编写适当的测试：

#[cfg(test)]
mod tests {
    use super::*;
    use assert_cmd::Command;
    use predicates::prelude::*;

    #[test]
    fn test_basic_functionality() -> anyhow::Result<()> {
        let mut cmd = Command::cargo_bin("cargo-mycommand")?;
        cmd.arg("analyze");
        cmd.assert()
            .success()
            .stdout(predicate::str::contains("项目名称"));
        
        Ok(())
    }

    #[test]
    fn test_verbose_mode() -> anyhow::Result<()> {
        let mut cmd = Command::cargo_bin("cargo-mycommand")?;
        cmd.arg("analyze").arg("--verbose");
        cmd.assert()
            .success()
            .stdout(predicate::str::contains("包数量"));
        
        Ok(())
    }
}

发布和分发自定义命令

自定义命令可以通过crates.io进行分发，让其他开发者也能使用：

  1. 准备发布：确保代码质量，编写完整的文档
  2. 添加文档：在README中说明命令的使用方法和示例
  3. 设置分类：在Cargo.toml中添加适当的分类标签
[package]
name = "cargo-mycommand"
version = "0.1.0"
description = "一个实用的Cargo自定义命令示例"
edition = "2021"
categories = ["development-tools::cargo-plugins"]
keywords = ["cargo", "plugin", "development"]
license = "MIT OR Apache-2.0"

[dependencies]
# ... 依赖项
  1. 发布到crates.io：
cargo publish

最佳实践和注意事项

开发自定义Cargo命令时，应遵循以下最佳实践：

实践要点说明示例
清晰的错误处理使用anyhow或thiserror提供有意义的错误信息anyhow::Result<T>
适当的日志记录使用env_logger或tracing记录执行过程tracing::info!("Processing...")
配置管理支持配置文件和环境变量dotenvy::dotenv().ok()
向后兼容保持命令行接口的稳定性使用CLAP的版本控制功能
性能优化避免不必要的操作，缓存结果使用once_cell或lazy_static
// 示例：使用环境变量配置
use std::env;

fn get_config() -> anyhow::Result<Config> {
    let timeout = env::var("MYCMD_TIMEOUT")
        .unwrap_or_else(|_| "30".to_string())
        .parse()?;
    
    Ok(Config { timeout })
}

struct Config {
    timeout: u64,
}

通过遵循这些模式和最佳实践，开发者可以创建出强大、可靠且易于使用的自定义Cargo命令，极大地提升Rust开发体验和工作效率。

依赖管理与构建优化的最佳实践

在Rust生态系统中，Cargo作为强大的构建工具和包管理器，提供了丰富的依赖管理和构建优化功能。掌握这些最佳实践能够显著提升开发效率和项目性能。

依赖声明与版本管理

Rust的依赖管理通过Cargo.toml文件进行配置，支持灵活的版本约束策略：

[dependencies]
# 精确版本约束
serde = "1.0.136"

# 兼容性版本约束（允许1.x.x的任何版本）
tokio = "1"

# 版本范围约束
reqwest = ">=0.11, <0.12"

# Git依赖
async-std = { git = "https://github.com/async-rs/async-std" }

# 路径依赖（用于本地开发）
my_crate = { path = "../my_crate" }

# 可选依赖
json = { version = "1.0", optional = true }

# 平台特定依赖
[target.'cfg(unix)'.dependencies]
libc = "0.2"

[target.'cfg(windows)'.dependencies]
winapi = "0.3"

版本管理的最佳实践包括：

  • 使用语义化版本控制（SemVer）
  • 在生产环境中使用精确版本锁定
  • 在开发阶段使用兼容性版本约束
  • 定期更新依赖以获取安全补丁和新特性

Cargo.lock文件的作用与管理

Cargo.lock文件是Cargo自动生成的依赖版本锁定文件，确保构建的可重现性：

[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
 "libc",
 "rand_chacha",
 "rand_core",
]

最佳实践：

  • 库项目通常不提交Cargo.lock到版本控制
  • 二进制项目应该提交Cargo.lock以确保构建一致性
  • 使用cargo update更新依赖版本
  • 定期运行cargo audit检查安全漏洞

构建配置与优化

Cargo提供了多种构建配置选项来优化编译过程和输出结果：

[package]
name = "my_app"
version = "0.1.0"
edition = "2024"

# 发布配置文件
[profile.dev]
opt-level = 0      # 开发模式：无优化，快速编译
debug = true       # 包含调试信息

[profile.release]
opt-level = 3      # 发布模式：最大优化
lto = true         # 链接时优化
codegen-units = 1  # 减少代码生成单元以提高优化
panic = "abort"    # 发生panic时直接终止程序

构建优化策略：

mermaid

工作区（Workspace）管理

对于大型项目，使用Cargo工作区可以高效管理多个相关crate：

[workspace]
resolver = "2"
members = [
    "crates/core",
    "crates/utils", 
    "crates/web",
    "examples/demo"
]

[workspace.dependencies]
serde = "1.0"
tokio = { version = "1", features = ["full"] }

工作区优势：

  • 共享依赖版本，避免版本冲突
  • 统一构建配置
  • 简化跨crate的开发和测试
  • 支持增量编译

依赖特性（Features）管理

Rust的features系统允许条件编译和模块化依赖：

[features]
default = ["json", "http"]
json = ["serde/json"]
http = ["reqwest"]
async = ["tokio"]

[dependencies]
serde = { version = "1.0", optional = true }
reqwest = { version = "0.11", optional = true }
tokio = { version = "1", optional = true }

特性使用示例：

// 条件编译
#[cfg(feature = "json")]
mod json_parser;

#[cfg(feature = "http")]
async fn fetch_data() -> Result<String, reqwest::Error> {
    // HTTP功能实现
}

构建缓存与增量编译

Cargo的构建缓存机制可以显著提升开发效率：

缓存类型存储位置清理命令
目标文件缓存target/目录cargo clean
注册表索引缓存~/.cargo/registrycargo clean --registry-cache
Git依赖缓存~/.cargo/gitcargo clean --git-cache

增量编译配置：

[build]
incremental = true  # 启用增量编译

[env]
CARGO_INCREMENTAL = "1"  # 环境变量控制

依赖解析策略

Cargo支持不同的依赖解析器，用于处理复杂的依赖关系：

[package]
resolver = "2"  # 使用新的解析器（默认）

# 或者使用传统解析器
# resolver = "1"

解析器比较：

特性解析器v1解析器v2
特性统一化不支持支持
公共依赖处理基础改进
性能良好优秀
错误消息基础改进

构建脚本（build.rs）的最佳实践

构建脚本用于复杂的构建前准备工作：

// build.rs
fn main() {
    // 设置环境变量
    println!("cargo:rustc-env=BUILD_TIMESTAMP={}", timestamp());
    
    // 链接本地库
    println!("cargo:rustc-link-lib=static=mylib");
    println!("cargo:rustc-link-search=native=./lib");
    
    // 重新构建触发条件
    println!("cargo:rerun-if-changed=src/config.toml");
}

构建脚本最佳实践：

  • 尽量减少构建脚本的使用
  • 使用rerun-if-changed精确控制重建条件
  • 避免在构建脚本中执行耗时操作
  • 提供清晰的错误消息和文档

跨平台构建优化

针对不同目标平台进行优化配置：

# Linux特定优化
[target.x86_64-unknown-linux-gnu]
rustflags = ["-C", "target-cpu=native"]

# Windows特定配置  
[target.x86_64-pc-windows-msvc]
rustflags = ["-C", "link-args=/DEBUG:FASTLINK"]

# WebAssembly优化
[target.wasm32-unknown-unknown]
rustflags = ["-C", "opt-level=s"]

监控与分析工具

集成性能监控和分析工具：

[dev-dependencies]
criterion = "0.3"  # 基准测试
flamegraph = "0.4" # 性能分析
cargo-audit = "0.17" # 安全审计

通过这些最佳实践，开发者可以构建出高性能、安全且易于维护的Rust应用程序，充分利用Cargo提供的强大功能来优化开发工作流和运行时性能。

总结

Rust的Cargo工具链提供了强大而灵活的生态系统构建能力，从多crate项目的工作区管理、规范的包发布流程，到可扩展的自定义命令开发和优化的依赖管理策略。掌握这些最佳实践不仅能提升开发效率和代码质量，还能确保项目的可维护性和安全性。通过合理利用Cargo的各项功能，开发者可以构建出高性能、可靠且易于维护的Rust应用程序，充分发挥Rust生态系统的优势。

【免费下载链接】book The Rust Programming Language 【免费下载链接】book 项目地址: https://gitcode.com/gh_mirrors/bo/book

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

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

抵扣说明：

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

余额充值