.NET 云原生架构师训练营（基于 OP Storming 和 Actor 的大型分布式架构二）--学习笔记...

于 2022-12-26 08:59:32 发布
阅读量206 收藏
点赞数
文章标签： 架构 学习 面试 职场和发展
原文链接：https://mp.weixin.qq.com/s?__biz=MzAwNTMxMzg1MA==&mid=2654095088&idx=3&sn=367760de7a5a7394a1f300fb553d498b&chksm=80d862a5b7afebb31d034cfe97daa98bf6ea9dc501ca679ecb6879603ea30bd1205ac548cc60&scene=126&sessionid=0
版权

▲ 点击上方“DotNet NB”关注公众号

回复“1”获取开发者路线图

0933a2d08af07d17496e7fd29ead07f0.gif

学习分享 丨作者 / 郑 子 铭    

这是DotNet NB 公众号的第202篇原创文章

目录

  • 为什么我们用 Orleans

  • Dapr VS Orleans

  • Actor 模型

  • Orleans 的核心概念

  • 结合 OP Storming 的实践

结合 OP Storming 的实践

  • 业务模型

  • 设计模型

  • 代码实现

业务模型

28b37d56e30cdc8690f2aefee06feb8e.png

我们可以把关键对象（职位、客户行为记录、线索）参考为 actor

猎头顾问一边寻找职位，一边寻找候选人，撮合之后匹配成线索，然后推荐候选人到客户公司，进行面试，发放 offer，候选人入职

设计模型

d93d353ea16a9b621646fe0c38170e68.png

我们新建职位的时候需要一个参数对象 CreateJobArgument，相当于录入数据

创建了 Job 之后，它有三个行为：浏览、点赞、投递

投递之后会直接产生一个意向的 Thread，可以继续去推进它的状态：推荐 -> 面试 -> offer -> 入职

针对浏览和点赞会产生两种不同的活动记录：ViewActivity 和 StarActivity

代码实现

  • HelloOrleans.Host

HelloOrleans.Host

新建一个空白解决方案 HelloOrleans

创建一个 ASP .NET Core 空项目 HelloOrleans.Host

分别创建 BaseEntity、Job、Thread、Activity 实体

namespace HelloOrleans.Host.Contract.Entity
{
    public class BaseEntity
    {
        public string Identity { get; set; }
    }
}


namespace HelloOrleans.Host.Contract.Entity
{
    public class Job : BaseEntity
    {
        public string Title { get; set; }
        public string Description { get; set; }
        public string Location { get; set; }
    }
}

namespace HelloOrleans.Host.Contract.Entity
{
    public class Thread : BaseEntity
    {
        public string JobId { get; set; }
        public string ContactId { get; set; }
        public EnumThreadStatus Status { get; set; }
    }
}

namespace HelloOrleans.Host.Contract
{
    public enum EnumThreadStatus : int
    {
        Recommend,
        Interview,
        Offer,
        Onboard,
    }
}

namespace HelloOrleans.Host.Contract.Entity
{
    public class Activity : BaseEntity
    {
        public string JobId { get; set; }
        public string ContactId { get; set; }
        public EnumActivityType Type { get; set; }
    }
}

namespace HelloOrleans.Host.Contract
{
    public enum EnumActivityType : int
    {
        View = 1,
        Star = 2,
    }
}

给 Job 添加 View 和 Star 的行为

public async Task View(string contactId)
{

}

public async Task Star(string contactId)
{

}

这里就只差 Grain 的 identity，我们添加 Orleans 的 nuget 包

<PackageReference Include="Microsoft.Orleans.Core" Version="3.6.5" />
<PackageReference Include="Microsoft.Orleans.Server" Version="3.6.5" />
<PackageReference Include="Microsoft.Orleans.CodeGenerator.MSBuild" Version="3.6.5" />
<PackageReference Include="Microsoft.Orleans.OrleansTelemetryConsumers.Linux" Version="3.6.5" />

  • Microsoft.Orleans.Core 是核心

  • Microsoft.Orleans.Server 做 Host 就需要用到它

  • Microsoft.Orleans.CodeGenerator.MSBuild 会在编译的时候帮我们生成客户端或者访问代码

  • Microsoft.Orleans.OrleansTelemetryConsumers.Linux 是监控

安装完后我们就可以继承 Grain 的基类了

using Orleans;

namespace HelloOrleans.Host.Contract.Entity
{
    public class Job : Grain
    {
        public string Title { get; set; }
        public string Description { get; set; }
        public string Location { get; set; }

        public async Task View(string contactId)
        {

        }

        public async Task Star(string contactId)
        {

        }
    }
}

如果我们需要用它来做持久化是有问题的，因为持久化的时候它会序列化我们所有的公有属性，然而在 Grain 里面会有一些公有属性你没有办法给它序列化，所以持久化的时候会遇到一些问题，除非我们把持久化的东西重新写一遍

public abstract class Grain : IAddressable, ILifecycleParticipant<IGrainLifecycle>
{
    public GrainReference GrainReference { get { return Data.GrainReference; } }
    
    /// <summary>
    /// String representation of grain's SiloIdentity including type and primary key.
    /// </summary>
    public string IdentityString
    {
        get { return Identity?.IdentityString ?? string.Empty; }
    }
    
    ...
}

理论上你的状态和行为是可以封装在一起的，这样更符合 OO 的逻辑

我们现在需要分开状态和行为

定义一个 IJobGrain 接口，继承 IGrainWithStringKey，用 string 作为它的 identity 的类型

using Orleans;

namespace HelloOrleans.Host.Contract.Grain
{
    public interface IJobGrain : IGrainWithStringKey
    {
        Task View(string contactId);
    }
}

定义 JobGrain 继承 Grain，实现 IJobGrain 接口

using HelloOrleans.Host.Contract.Entity;
using HelloOrleans.Host.Contract.Grain;
using Orleans;

namespace HelloOrleans.Host.Grain
{
    public class JobGrain : Grain<Job>, IJobGrain
    {
        public Task View(string contactId)
        {
            throw new NotImplementedException();
        }
    }
}

这是使用 DDD 来做的区分开状态和行为，变成贫血模型，是不得已而为之，因为持久化的问题

在 Orleans 的角度而言，它的 Actor 绑定了一个外部的状态，但是实际上我们更希望它们两在一起

它的实体就变成这样

namespace HelloOrleans.Host.Contract.Entity
{
    public class Job
    {
        public string Title { get; set; }
        public string Description { get; set; }
        public string Location { get; set; }
    }
}

Job 不是 Actor 实例，JobGrain 才是 Actor 实例

接下来我们需要做一个 Host 让它跑起来

添加 nuget 包

<PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="6.0.0" />

在 Program 中需要通过 WebApplication 的 Builder 配置 Orleans

builder.Host.UseOrleans(silo =>
{
    silo.UseLocalhostClustering();
    silo.AddMemoryGrainStorage("hello-orleans");
});

在 JobGrain 中使用 hello-orleans 这个 Storage 标识一下

[StorageProvider(ProviderName = "hello-orleans")]
public class JobGrain : Grain<Job>, IJobGrain

添加 JobController，这属于前面讲的 silo 内模式，可以直接使用 IGrainFactory，因为这是在同一个项目里

using Microsoft.AspNetCore.Mvc;
using Orleans;

namespace HelloOrleans.Host.Controllers
{
    [Route("job")]
    public class JobController : Controller
    {
        private IGrainFactory _factory;

        public JobController(IGrainFactory grainFactory)
        {
            _factory = grainFactory;
        }
    }
}

添加一个创建方法 CreateAsync，它的入参叫做 CreateJobViewModel，包含我们需要的 Job 的数据

[Route("")]
[HttpPost]
public async Task<IActionResult> CreateAsync([FromBody] CreateJobViewModel model)
{
    var jobId = Guid.NewGuid().ToString();
    var jobGrain = _factory.GetGrain<IJobGrain>(jobId);
}

创建的时候 Grain 是不存在的，必须有 identity，不然 Actor 获取不到，所以需要先 new 一个 identity，就是 jobId

通过 IGrainFactory 获取到 jobGrain 之后我们是无法获取到它的 state，只能看到它的行为，所以我们需要在 Grain 里面添加一个 Create 的方法方便我们调用

using HelloOrleans.Host.Contract.Entity;
using Orleans;

namespace HelloOrleans.Host.Contract.Grain
{
    public interface IJobGrain : IGrainWithStringKey
    {
        Task<Job> Create(Job job);
        Task View(string contactId);
    }
}

所以这个 Create 方法并不是真正的 Create，只是用来设置 state 的对象，再通过 WriteStateAsync 方法保存

using HelloOrleans.Host.Contract.Entity;
using HelloOrleans.Host.Contract.Grain;
using Orleans;
using Orleans.Providers;

namespace HelloOrleans.Host.Grain
{
    [StorageProvider(ProviderName = "hello-orleans")]
    public class JobGrain : Grain<Job>, IJobGrain
    {
        public async Task<Job> Create(Job job)
        {
            job.Identity = this.GetPrimaryKeyString();
            this.State = job;
            await this.WriteStateAsync();
            return this.State;
        }

        public Task View(string contactId)
        {
            throw new NotImplementedException();
        }
    }
}

new 一个 job，调用 Create 方法设置 State，得到一个带 identity 的 job，然后返回 OK

[Route("")]
[HttpPost]
public async Task<IActionResult> CreateAsync([FromBody] CreateJobViewModel model)
{
    var jobId = Guid.NewGuid().ToString();
    var jobGrain = _factory.GetGrain<IJobGrain>(jobId);

    var job = new Job()
    {
        Title = model.Title,
        Description = model.Description,
        Location = model.Location,
    };
    job = await jobGrain.Create(job);
    return Ok(job);
}

因为我们现在采用的是内存级别的 GrainStorage，所以我们没有办法去查看它

我们再加一个 Get 的方法去查询它

[Route("{jobId}")]
[HttpGet]
public async Task<IActionResult> GetAsync(string jobId)
{
    var jobGrain = _factory.GetGrain<IJobGrain>(jobId);
}

这个时候我们需要去 Grain 的接口里面加一个 Get 方法

using HelloOrleans.Host.Contract.Entity;
using Orleans;

namespace HelloOrleans.Host.Contract.Grain
{
    public interface IJobGrain : IGrainWithStringKey
    {
        Task Create(Job job);
        Task<Job> Get();
        Task View(string contactId);
    }
}

Get 方法是不需要传 id 的，因为这个 id 就是 Grain 的 id，你激活的时候就已经有了，直接返回 this.State

using HelloOrleans.Host.Contract.Entity;
using HelloOrleans.Host.Contract.Grain;
using Orleans;
using Orleans.Providers;

namespace HelloOrleans.Host.Grain
{
    [StorageProvider(ProviderName = "hello-orleans")]
    public class JobGrain : Grain<Job>, IJobGrain
    {
        public async Task Create(Job job)
        {
            this.State = job;
            await this.WriteStateAsync();
        }

        public Task<Job> Get()
        {
            return Task.FromResult(this.State);
        }

        public Task View(string contactId)
        {
            throw new NotImplementedException();
        }
    }
}

这个地方所有你的行为都不是直接去查数据库，而是利用这个 State，它不需要你自己去读取，跟 DDD 的 repository 不同

直接通过 Grain 的 Get 方法获取 Job 返回 OK

[Route("{jobId}")]
[HttpGet]
public async Task<IActionResult> GetAsync(string jobId)
{
    var jobGrain = _factory.GetGrain<IJobGrain>(jobId);
    return Ok(await jobGrain.Get());
}

这里我们可以再加点校验逻辑

[Route("{jobId}")]
[HttpGet]
public async Task<IActionResult> GetAsync(string jobId)
{
    if (string.IsNullOrEmpty(jobId))
    {
        throw new ArgumentNullException(nameof(jobId));
    }

    var jobGrain = _factory.GetGrain<IJobGrain>(jobId);
    return Ok(await jobGrain.Get());
}

要注意如果你传入的 jobId 是不存在的，因为不管你传什么，只要是一个合法的字符串，并且不重复，它都会帮你去激活，只不过在于它是否做持久化而已，如果你随便传了一个 jobId，这个时候不是调了 Get 方法，它可能也会返回给你一个空的 state，所以这个 jobId 没有这种很强的合法性的约束，在调 Get 的时候要特别的注意，不管是 Create 还是 Get，其实都是调用了 GetGrain，传了一个 identity 进去，这样的一个行为

在 Program 中添加 Controller 的配置

using Orleans.Hosting;

var builder = WebApplication.CreateBuilder(args);

builder.Host.UseOrleans(silo =>
{
    silo.UseLocalhostClustering();
    silo.AddMemoryGrainStorage("hello-orleans");
});
builder.Services.AddControllers();

var app = builder.Build();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

app.MapGet("/", () => "Hello World!");

app.Run();

我们启动项目测试一下

Create 方法入参

{
	"title": "第一个职位",
	"description": "第一个职位"
}

7e8b647eb508fb6385d3f8088c6a1a6b.png

可以看到方法调用成功，返回的 job 里面包含了 identity

接着我们使用 Create 方法返回的 identity 作为入参调用 Get 方法

b99c2a078f6dec50b562570b350f403a.png

可以看到方法调用成功，返回同一个 job

这种基于内存的存储就很适合用来做单元测试

推荐阅读：
.NET周报【12月第1期 2022-12-08】

.NET 7 新增的 IParsable 接口介绍

.NET 云原生架构师训练营（基于 OP Storming 和 Actor 的大型分布式架构一）--学习笔记

一个.NetCore前后端分离、模块化、插件式的通用框架

.NET 为什么推荐Kestrel作为网络开发框架

用最少的代码打造一个Mini版的gRPC框架
点击下方卡片关注DotNet NB
一起交流学习


▲ 点击上方卡片关注DotNet NB，一起交流学习

请在公众号后台
回复 【路线图】获取.NET 2021开发者路线图
回复 【原创内容】获取公众号原创内容
回复 【峰会视频】获取.NET Conf开发者大会视频
回复 【个人简介】获取作者个人简介
回复 【年终总结】获取作者年终总结
回复 【加群】加入DotNet NB 交流学习群


长按识别下方二维码，或点击阅读原文。和我一起，交流学习，分享心得。
dotNET跨平台
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
.NET 云原生架构师训练营（责任链模式）--学习笔记
MINGSON666的博客
01-05 414
目录 责任链模式 源码 责任链模式 职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无需关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了 何时使用：在处理消息的时候以过滤很多道 使用场景： 有多个对象可以处理同一个请求，具体到哪个对象处理该请求由运行时刻自动确定 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求 可动态指定一组对象处理请求 源码 GitHub - dotnet/aspnetcore: ASP.NET Core
.NET 云原生架构师训练营（ASP .NET Core 整体概念推演）--学习笔记
MINGSON666的博客
12-30 417
演化与完善整体概念 ASP .NET Core 整体概念推演 整体概念推演到具体的形式 ASP .NET Core 整体概念推演 ASP .NET Core 其实就是通过 web framework 处理 HTTP 请求并提供 HTTP 响应 web framework 由程序员使用，它包括 ASP .NET Core，Express，spring 等等组成 这样我们就完成了对 ASP .NET Core 的底层建模，接下来对 HTTP 请求和 HTTP 响应进行细化 对于原始 HTTP
.NET 云原生架构师训练营（RGCA 四步架构法）--学习笔记
MINGSON666的博客
12-29 342
RGCA Requirement：从利益相关者获取需求 Goal：将需求转化为目标（功能意图） Concept：将目标扩展为完整概念 Architecture：将概念扩展为架构 目录 从利益相关者获取需求 将需求转化为目标 将目标扩展为完整概念 从利益相关者获取需求 有哪些类型的利益相关者 利益相关者需求 需求分类与排序 需求的特征 有哪些类型的利益相关者 利益相关方 关注系统的事物和对象 - 投资方 有助于解决问题的利益相关者 投资人微软、微软股东等
.NET 云原生架构师训练营（权限系统 RGCA 架构设计）--学习笔记
MINGSON666的博客
01-19 2263
目录 项目核心内容 实战目标 RGCA 四步架构法 项目核心内容 无代码埋点实现对所有 API Action 访问控制管理 对 EF Core 实体新增、删除、字段级读写控制管理 与 Identity 进行融合集成 实战目标 RGCA 四步架构法的应用 加深对 OPM 和 OPD 的运用 为毕业设计打下基础 RGCA 四步架构法 Requirement：从利益相关者获取需求 Goal：将需求转化为目标（功能意图） Concept：将目标扩展为完整概念 Architecture：将概
.NET 云原生架构师训练营（模板方法 && 建造者）--学习笔记
MINGSON666的博客
01-07 517
目录 模板方法 源码 建造者 模板方法 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤 源码 GitHub - dotnet/aspnetcore: ASP.NET Core is a cross-platform .NET framework for building modern cloud-based web applications on Windows, Mac, or Linux. 在目录 aspnetcore\
awesome-eventstorming:很棒的事件存储
05-28
EventStorming是一种基于研讨会的方法，可以快速找出软件程序领域中正在发生的事情。[1] 与其他方法相比，它非常轻巧，并且不需要计算机的有意支持。 结果以宽墙的粘滞便笺表示。 业务流程被“冲出”为一系列域事件...
生论.pdf --- 看完你会静下心好好敲代码
01-28
迷茫的孩子们，努力奋斗才是你们每一分每一秒最好的选择
introducing_eventstorming.pdf
10-11
残本秘籍在手，可尽破天下武功！ 还在等什么，赶紧来成为风暴战士吧！ 请移步以下位置，以支持正版 https://leanpub.com/introducing_eventstorming
mysql-connector-java-8.0.22.jar
11-28
`mysql-connector-java-8.0.22.jar` 文件包含了MySQL JDBC驱动的所有类和方法，它使得Java开发者能够编写能够连接、查询、更新MySQL数据库的应用程序。 这个驱动的版本号8.0.22表明它是MySQL 8.0系列的一部分，这...
JdonFramework应用案例之一: JdonFrameworkTest CQRS+ES
04-07
JdonFramework应用案例之一: JdonFrameworkTest CQRS+ES
.net 有哪些主流的设计模式_.NET云原生架构师训练营讲什么，怎么讲，讲多久
weixin_35802555的博客
12-29 606
-------请观众看视频介绍 -----------------以下是文字版内容 ---------大家好，我是刘腾飞。前一段时间，我通过朋友圈的一篇文章这样的一种方式启动了我的.net云原生架构师训练营。到现在为止，已经有这个超过15位的同学已经加入了，那么在这些同学当中呢，他们有的是直接就报名加入，有的也有着一些疑问，在经过问答之后报名加入。那么我相信还有很一些同学，对这个训练营是...
.Net 5 Actor 并发模型
蓝创精英团队
09-23 296
是一个利器，用来实现 模型通讯，并发执行。 /// <summary> /// 无锁并行编程模型（暂时用来处理串行任务，任务串行执行） /// </summary> public interface IActor { /// <summary> /// 增加消息 /// </summary> /// <returns></returns&gt
.NET 云原生架构师训练营（模块一 架构师与云原生）--学习笔记
MINGSON666的博客
10-12 826
目录 什么是软件架构 软件架构的基本思路 单体向分布式演进、云原生、技术中台 1.1 什么是软件架构 1.1.1 什么是架构？ Software architecture = {Elements, Forms, Rationale/Constraints} 元素、形式/模式、基本原理和限制 为什么需要软件架构？ 软件架构的终极目标是用最小的人力成本来满足构建和维护系统的需求 一个软件架构的优劣，可以用它满足用户需求的成本来衡量。如果该成本很低，并且在系统的整个生命周期内一直都维持这样的低成本，那么这个系
初探奥尔良(Orleans)
weixin_30873847的博客
03-17 358
由于工作上关系目前经常被各种并发数据问题搞得焦头烂额，要么要性能舍弃数据上得一致性，要么要一致性但是却得到了特别糟糕的响应。难道鱼和熊掌真的无法兼得吗？ 然后找到了类似奥尔良这种基于Actor模型的kuangjia 首先本人因为是C#系的所以暂不考虑Java系那套，那摆在面前的此类型的框架其实就2个。 Akka.Net和Orleans。 什么是Actor？ Actor应...
.NET的Actor模型：Orleans
weixin_34258838的博客
02-17 168
Orleans是微软推出的类似Scala Akka的Actor模型，Orleans是一个建立在.NET之上的，设计的目标是为了方便程序员开发需要大规模扩展的云服务, 可用于实现DDD+EventSourcing/CQRS系统。 传统的三层体系结构包括无状态的前端,无状态的中间层和存储层在可伸缩性方面是有限制的，由于存储层在延迟和吞吐量方面的限制，这对于每个用户请求都有影响。通常办法是在中间层...
应用程序框架实战十六:DDD分层架构之值对象（介绍篇）
weixin_34348805的博客
11-25 454
　　前面介绍了DDD分层架构的实体，并完成了实体层超类型的开发，同时提供了验证方面的支持。本篇将介绍另一个重要的构造块——值对象，它是聚合中的主要成分。 　　如果说你已经在使用DDD分层架构，但你却从来没有使用过值对象，这毫不奇怪，因为多年来养成的数据建模思维已经牢牢把你禁锢，以致于你在使用面向对象方式进行开发时，还是以数据为中心。 　　当我们完成了基本的需求分析以后，如果说需要进行设计，那么...
Orleans 分布式单线程高并发
foreverhot1019的博客
01-08 1536
程序在运行过程中有时会莫名其妙出现代码的某些约束或者执行结果和理想状况不一样，正常逻辑怎么会出现这样的情况？到底发生了什么？好像见了鬼！瞬间好无助。 谁来救救我 大多数出现正常逻辑很难解释的时候，我们可能会想到并发问题，因为好像只有并发才会能说服自己。为了验证和解决这个问题，我们可能会尝试一些方案，在并发的情况下我相信很多人都使用过锁，锁确实也能帮忙我们解决问题，不然它干嘛存在。 但随着业务逻辑的持续复杂，锁的使用可能无处不在。首先大家都知道锁本身的机制很耗性能；然后锁本身不涉及什么编程模式，所.
给出一个cmakelists.txt 并对其解释
最新发布
06-02
好的，以下是一个简单的cmakelists.txt文件示例，其中涵盖了一些基本的语法和命令： ``` cmake_minimum_required(VERSION 3.10) # 指定CMake最低版本要求 project(MyProject VERSION 1.0) # 指定项目名称和版本号 set(CMAKE_CXX_STANDARD 11) # 指定C++标准版本 add_executable(myapp main.cpp) # 添加可执行文件并指定源代码文件 find_package(Boost REQUIRED) # 查找Boost库并指定为依赖项 target_link_libraries(myapp PRIVATE Boost::boost) # 将Boost库链接到应用程序 ``` 上述cmakelists.txt文件中，每个命令都有其特定的作用： - `cmake_minimum_required(VERSION 3.10)`：指定CMake最低版本要求，这里是3.10版本。 - `project(MyProject VERSION 1.0)`：指定项目名称和版本号，这里是MyProject和1.0。 - `set(CMAKE_CXX_STANDARD 11)`：指定C++标准版本，这里是C++11。 - `add_executable(myapp main.cpp)`：添加可执行文件并指定源代码文件，这里是将main.cpp编译成名为myapp的可执行文件。 - `find_package(Boost REQUIRED)`：查找Boost库并指定为依赖项，这里查找名称为Boost的库。 - `target_link_libraries(myapp PRIVATE Boost::boost)`：将Boost库链接到应用程序，并将链接方式指定为私有的，这里将Boost库链接到myapp可执行文件。 通过cmakelists.txt文件，我们可以告诉CMake如何构建我们的项目，包括指定编译器、编译选项、依赖项等。在生成Makefile文件后，我们可以通过运行make命令来编译和构建项目。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值