.NET 实现ActiveMQ的消息发布及订阅

最新推荐文章于 2024-01-28 14:33:49 发布
最新推荐文章于 2024-01-28 14:33:49 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： .Net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liwan09/article/details/106055271
版权

一、项目创建

VS2017创建.Net项目，项目创建完成后，从Nuget搜索并安装Apache.NMS.ActiveMQ

 

二、消息发布及订阅方法实现

 消息发布

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using Apache.NMS;
using Apache.NMS.ActiveMQ;
using Apache.NMS.ActiveMQ.Commands;

namespace ActiveMqDemo
{
    /// <summary>
    /// ActiveMq消息发布
    /// </summary>
    public class ProduceWarpper
    {
        private IConnectionFactory _factory = null;
        private IConnection _connection = null;
        private ISession _session = null;
        private readonly ConcurrentDictionary<string, IMessageProducer> _dic = null;
        const string queuePrefix = "My.Quee.";//queue消息队列名称默认前缀 My.Quee.
        const string topicPrefix = "My.Topic.";//topic消息队列名称默认前缀 My.Topic.
        /// <summary>
        /// 构造函数
        /// </summary>
        public ProduceWarpper()
        {
            _dic = new ConcurrentDictionary<string, IMessageProducer>();
        }

        /// <summary>
        /// 打开连接
        /// </summary>
        public void Open()
        {
            Open("failover:(tcp://127.0.0.1:61616)?wireFormat.maxInactivityDuration=0&transport.timeout=3000&transport.startupMaxReconnectAttempts=2", "admin", "mypassword");
        }

        /// <summary>
        /// 打开连接
        /// </summary>
        /// <param name="brokerUri">ip地址</param>
        public void Open(string brokerUri)
        {
            Open(brokerUri, null, null);
        }
        /// <summary>
        /// 打开连接
        /// </summary>
        /// <param name="brokerUri">ip地址</param>
        /// <param name="username">用户名</param>
        /// <param name="pwd">密码</param>
        public void Open(string brokerUri, string username, string pwd)
        {
            bool flag = _factory != null;
            if (!flag)
            {
                _factory = new ConnectionFactory(brokerUri);
                bool flag2 = string.IsNullOrEmpty(username) || string.IsNullOrEmpty(pwd);
                if (flag2)
                {
                    _connection = _factory.CreateConnection();
                }
                else
                {
                    _connection = _factory.CreateConnection(username, pwd);
                }
                _connection.ClientId = Guid.NewGuid().ToString();
                _connection.ExceptionListener += new ExceptionListener(Connection_ExceptionListener);
                _connection.Start();
                _session = _connection.CreateSession();
            }
        }
        /// <summary>
        /// 关闭连接
        /// </summary>
        public void Close()
        {
            bool flag = _dic.Any();
            if (flag)
            {
                foreach (KeyValuePair<string, IMessageProducer> keyValuePair in _dic)
                {
                    bool flag2 = keyValuePair.Value == null;
                    if (!flag2)
                    {
                        IMessageProducer value = keyValuePair.Value;
                        value.Close();
                        value.Dispose();
                    }
                }
            }
            bool flag3 = _session != null;
            if (flag3)
            {
                _session.Close();
                _session.Dispose();
                _session = null;
            }
            bool flag4 = _connection != null;
            if (flag4)
            {
                _connection.Close();
                _connection.Dispose();
                _connection = null;
            }
            _factory = null;
        }

        /// <summary>
        /// 发布Topic消息
        /// </summary>
        /// <param name="topicName">Topic名称</param>
        /// <param name="msg">Topic内容</param>
        public void ProduceTopicMsg(string topicName, string msg)
        {
            string finalKey = topicPrefix + topicName;
            IDestination destination = new ActiveMQTopic(finalKey);
            ProduceMsg(finalKey, msg, destination, TimeSpan.MinValue);
        }

        /// <summary>
        /// 发布Queue消息
        /// </summary>
        /// <param name="queueName">Queue名称</param>
        /// <param name="msg">Queue内容</param>
        public void ProduceQueueMsg(string queueName, string msg)
        {
            string finalKey =queuePrefix+queueName;
            IDestination destination = new ActiveMQQueue(finalKey);
            ProduceMsg(finalKey, msg, destination, TimeSpan.MinValue);
        }
        /// <summary>
        /// 发布消息
        /// </summary>
        /// <param name="key">Queue/Topic名称</param>
        /// <param name="msg">消息内容</param>
        /// <param name="destination"></param>
        /// <param name="timeToLive"></param>
        private void ProduceMsg(string key, string msg, IDestination destination, TimeSpan timeToLive)
        {
            bool flag = _factory == null;
            if (flag)
            {
                throw new Exception("未调用open()方法");
            }
            IMessageProducer messageProducer = null;
            bool flag2 = !_dic.TryGetValue(key, out messageProducer);
            if (flag2)
            {
                messageProducer = _session.CreateProducer(destination);
                _dic.TryAdd(key, messageProducer);
            }
            bool flag3 = messageProducer != null;
            if (flag3)
            {
                messageProducer.Send(messageProducer.CreateTextMessage(msg), 0, MsgPriority.Normal, timeToLive);
            }
        }
        /// <summary>
        /// 连接错误信息
        /// </summary>
        /// <param name="exception"></param>
        private void Connection_ExceptionListener(Exception exception)
        {
            string errMsg = string.Format("connection_ExceptionListener Error:{0}\r\n{1}", new object[]
            {
                exception.Message,
                exception.StackTrace
            });
            LogHelper.WriteTextLog("Error", errMsg);
            bool flag = exception.InnerException != null;
            if (flag)
            {
                WriteException(exception.InnerException);
            }
        }

        /// <summary>
        /// 错误日志
        /// </summary>
        /// <param name="exception"></param>
        private void WriteException(Exception exception)
        {
            string errMsg = string.Format("{0}\r\n{1}", new object[]
            {
                exception.Message,
                exception.StackTrace
            });
            LogHelper.WriteTextLog("Error", errMsg);
            bool flag = exception.InnerException != null;
            if (flag)
            {
                WriteException(exception.InnerException);
            }
        }       
    }
}

 消息订阅

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using Apache.NMS;
using Apache.NMS.ActiveMQ;
using Apache.NMS.ActiveMQ.Commands;

namespace ActiveMqDemo
{
    /// <summary>
    /// ActiveMq 消息订阅
    /// </summary>
    public class ConsumeWarpper
    {
        private IConnectionFactory _factory = null;
        private IConnection _connection = null;
        private ISession _session = null;
        private readonly ConcurrentDictionary<string, DataModel> _dic = null;
        const string queuePrefix = "My.Quee.";//queue消息队列名称默认前缀
        const string topicPrefix = "My.Topic.";//topic消息队列名称默认前缀
        /// <summary>
        /// 
        /// </summary>
        private class DataModel
        {
            public IMessageConsumer Consumer { get; set; }
            public List<Action<string>> Listeners { get; set; }
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        public ConsumeWarpper()
        {
            _dic = new ConcurrentDictionary<string, DataModel>();
        }

        /// <summary>
        /// 打开连接
        /// </summary>
        public void Open()
        {
            Open("failover:(tcp://127.0.0.1:61616)?wireFormat.maxInactivityDuration=0&transport.timeout=3000&transport.startupMaxReconnectAttempts=2", "admin", "mypassword");
        }

        /// <summary>
        /// 打开连接
        /// </summary>
        /// <param name="brokerUri">ip</param>
        public void Open(string brokerUri)
        {
            Open(brokerUri, null, null);
        }
        /// <summary>
        /// 打开连接
        /// </summary>
        /// <param name="brokerUri">ip</param>
        /// <param name="username">用户名</param>
        /// <param name="pwd">密码</param>
        public void Open(string brokerUri, string username, string pwd)
        {
            bool flag = _factory != null;
            if (!flag)
            {
                _factory = new ConnectionFactory(brokerUri);
                bool flag2 = string.IsNullOrEmpty(username) || string.IsNullOrEmpty(pwd);
                if (flag2)
                {
                    _connection = _factory.CreateConnection();
                }
                else
                {
                    _connection = _factory.CreateConnection(username, pwd);
                }
                _connection.ClientId = Guid.NewGuid().ToString();
                _connection.ExceptionListener += new ExceptionListener(Connection_ExceptionListener);
                _connection.Start();
                _session = _connection.CreateSession();
            }
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        public void Close()
        {
            bool flag = _dic.Any();
            if (flag)
            {
                foreach (KeyValuePair<string, DataModel> keyValuePair in _dic)
                {
                    bool flag2 = keyValuePair.Value == null;
                    if (!flag2)
                    {
                        IMessageConsumer consumer = keyValuePair.Value.Consumer;
                        consumer.Listener -= new MessageListener(consumer_Listener);
                        consumer.Close();
                        consumer.Dispose();
                    }
                }
            }
            bool flag3 = _session != null;
            if (flag3)
            {
                _session.Close();
                _session.Dispose();
                _session = null;
            }
            bool flag4 = _connection != null;
            if (flag4)
            {
                _connection.Close();
                _connection.Dispose();
                _connection = null;
            }
            _factory = null;
        }

        /// <summary>
        /// 订阅Topic消息
        /// </summary>
        /// <param name="topicName">Topic名称</param>
        /// <param name="listener">订阅事件</param>
        public void ConsumeTopicMsg(string topicName, Action<string> listener)
        {
            string finalKey = topicPrefix + topicName;
            IDestination destination = new ActiveMQTopic(finalKey);
            ConsumeMsg(finalKey, destination, listener);
        }

        /// <summary>
        /// 订阅Queue消息
        /// </summary>
        /// <param name="queueName">Queue名称</param>
        /// <param name="listener">订阅事件</param>
        public void ConsumeQueueMsg(string queueName, Action<string> listener)
        {
            string finalKey = queuePrefix + queueName;
            IDestination destination = new ActiveMQQueue(finalKey);
            ConsumeMsg(finalKey, destination, listener);
        }
        /// <summary>
        /// 消息订阅
        /// </summary>
        /// <param name="key"></param>
        /// <param name="destination"></param>
        /// <param name="listener"></param>
        private void ConsumeMsg(string key, IDestination destination, Action<string> listener)
        {
            DataModel dataModel = null;
            bool flag = _dic.TryGetValue(key, out dataModel);
            if (flag)
            {
                dataModel.Listeners.Add(listener);
            }
            else
            {
                bool flag2 = _factory == null;
                if (flag2)
                {
                    throw new Exception("未调用open()方法");
                }
                IMessageConsumer messageConsumer = _session.CreateConsumer(destination);
                messageConsumer.Listener += new MessageListener(consumer_Listener);
                dataModel = new DataModel
                {
                    Consumer = messageConsumer,
                    Listeners = new List<Action<string>>
                    {
                        listener
                    }
                };
                _dic.TryAdd(key, dataModel);
            }
        }
        /// <summary>
        /// 消息订阅监听事件
        /// </summary>
        /// <param name="message"></param>
        private void consumer_Listener(IMessage message)
        {
            try
            {
                ITextMessage textMessage = message as ITextMessage;
                bool flag = textMessage == null;
                if (flag)
                {
                    LogHelper.WriteTextLog("Error", "consumer_Listener: textMessage == null");
                }
                else
                {
                    string key = "";
                    IDestination nmsdestination = message.NMSDestination;
                    bool isTopic = nmsdestination.IsTopic;
                    if (isTopic)
                    {
                        key = ((ActiveMQTopic)nmsdestination).TopicName;
                    }
                    else
                    {
                        bool isQueue = nmsdestination.IsQueue;
                        if (isQueue)
                        {
                            key = ((ActiveMQQueue)nmsdestination).QueueName;
                        }
                    }
                    DataModel dataModel = null;
                    bool flag2 = _dic.TryGetValue(key, out dataModel)&&dataModel.Listeners.Any();
                    if (flag2)
                    {
                        dataModel.Listeners.ForEach(delegate (Action<string> listener)
                        {
                            try
                            {
                                listener(textMessage.Text);
                            }
                            catch (Exception ex2)
                            {
                                string errMsg = string.Format("consumer_Listener Action Error:{0}\r\n{1}", new object[]
                                {
                                    ex2.Message,
                                    ex2.StackTrace
                                });
                                LogHelper.WriteTextLog("Error", errMsg);
                                bool flag4 = ex2.InnerException != null;
                                if (flag4)
                                {
                                    WriteException(ex2.InnerException);
                                }
                            }
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                string errMsg = string.Format("consumer_Listener Error:{0}\r\n{1}", new object[]
                               {
                                    ex.Message,
                                    ex.StackTrace
                               });
                LogHelper.WriteTextLog("Error", errMsg);
                bool flag3 = ex.InnerException != null;
                if (flag3)
                {
                    WriteException(ex.InnerException);
                }
            }
        }
        /// <summary>
        /// 连接错误日志
        /// </summary>
        /// <param name="exception"></param>
        private void Connection_ExceptionListener(Exception exception)
        {
            string errMsg = string.Format("connection_ExceptionListener  Error:{0}\r\n{1}", new object[]
                               {
                                    exception.Message,
                                    exception.StackTrace
                               });
            LogHelper.WriteTextLog("Error", errMsg);
            bool flag = exception.InnerException != null;
            if (flag)
            {
                WriteException(exception.InnerException);
            }
        }

        /// <summary>
        /// 错误日志
        /// </summary>
        /// <param name="exception"></param>
        private void WriteException(Exception exception)
        {
            string errMsg = string.Format("{0}\r\n{1}", new object[]
                              {
                                    exception.Message,
                                    exception.StackTrace
                              });
            LogHelper.WriteTextLog("Error", errMsg);
            bool flag = exception.InnerException != null;
            if (flag)
            {
                WriteException(exception.InnerException);
            }
        }
    }
}

三、使用示例

 消息发布示例

            MQMsgTemp temp = new MQMsgTemp();
            temp.ID = Guid.NewGuid().ToString();
            temp.TempName = "测试消息";
            temp.TempType = "测试";
            temp.CreateUser = "我";
            string jsonContentmq = Newtonsoft.Json.JsonConvert.SerializeObject(temp);
            var produce = new ProduceWarpper();
            produce.Open();
            LogHelper.WriteTextLog("ActiveMq消息发布", jsonContentmq);
            produce.ProduceQueueMsg("Test", jsonContentmq);
            produce.Close();

发布后

 消息订阅示例

            //监听消息队列
            var consumeProduce = new ConsumeWarpper();
            consumeProduce.Open();
            consumeProduce.ConsumeQueueMsg("Test", (msg) =>
            {
                LogHelper.WriteTextLog("ActiveMq消息订阅", msg);
                MQMsgTemp temp = Newtonsoft.Json.JsonConvert.DeserializeObject<MQMsgTemp>(msg);
            });

消息订阅后

 附：日志等相关代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ActiveMqDemo
{
    /// <summary>
    /// 消息发送模板
    /// </summary>
    public class MQMsgTemp
    {
        /// <summary>
        /// 主键
        /// </summary>
        public string ID { get; set; }
        /// <summary>
        /// 名称
        /// </summary>
        public string TempName { get; set; }
        /// <summary>
        /// 类别
        /// </summary>
        public string TempType { get; set; }
        /// <summary>
        /// 创建人
        /// </summary>
        public string CreateUser { get; set; }       
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ActiveMqDemo
{
    public class LogHelper
    {
        /// <summary>  
        /// 写入日志到文本文件  
        /// </summary>  
        /// <param name="action">动作</param>  
        /// <param name="strMessage">日志内容</param>  
        public static void WriteTextLog(string action, string strMessage)
        {
            var time = DateTime.Now;
            string path = AppDomain.CurrentDomain.BaseDirectory + @"Logs\";
            if (!System.IO.Directory.Exists(path))
            {
                System.IO.Directory.CreateDirectory(path);
            }
            string fileFullPath = path + time.ToString("yyyy-MM-dd") + ".txt";
            StringBuilder str = new StringBuilder();
            str.Append("Time:    " + time.ToString() + "\r\n");
            str.Append("Action:  " + action + "\r\n");
            str.Append("Message: " + strMessage + "\r\n");
            str.Append("-----------------------------------------------------------\r\n\r\n");
            System.IO.StreamWriter sw;
            if (!System.IO.File.Exists(fileFullPath))
            {
                sw = System.IO.File.CreateText(fileFullPath);
            }
            else
            {
                sw = System.IO.File.AppendText(fileFullPath);
            }
            sw.WriteLine(str.ToString());
            sw.Close();
        }
    }
}

 

 

蓝晶之心
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ActiveMQ之发布- 订阅消息模式实现
ywl470812087的博客
12-04 12万+
一、概念 发布者/订阅者模型支持向一个特定的消息主题发布消息。0或多个订阅者可能对接收来自特定消息主题的消息感兴趣。在这种模型下，发布者和订阅者彼此不知道对方。这种模式好比是匿名公告板。这种模式被概括为：多个消费者可以获得消息 在发布者和订阅者之间存在时间依赖性。发布者需要建立一个订阅（subscription），以便客户能够订阅。订阅者必须保持持续的活动状态以接收消息，除非订阅者建立了持久的订...
【ActiveMQ】- 发布/订阅模式
li123128的博客
02-24 194
　　publish/subscribe 　　 　　特点：A发送的消息可以被所有监听A的对象的接收，就好比学校的广播，所有的学生都可以收听校园广播信息。 　　 　　消息生产者： 　　 　　package com.zhiwei.advanced.mq.activemq.sp; 　　 　　import javax.jms.Connection; 　　 　　import javax.jms.Connect...
用C#实现的ActiveMQ发布/订阅消息传送
12-09
用C#实现的ActiveMQ发布/订阅消息传送源程序
.Net下对ActiveMQ的使用
zequan_liu1988的博客
09-26 646
文章出处：http://www.cnblogs.com/chengxc/p/ActiveMQ.html 刚来到一个新公司，因为项目需要，要使用ActiveMQ，于是就研究了一下，写下此篇笔记，借鉴了博客园和CSDN的相关资料　　 ActiveMQ简介      ActiveMQ是一个开放源码，基于Apache2.0 licenced的，实现了JMS1.1的消息中间件 一开始不知道什
.Net平台下ActiveMQ
03-07 194
Net下对ActiveMQ的使用 作者及来源： 多线程的奥秘 - 博客园 收藏到→_→： 摘要: .Net下对ActiveMQ的使用 ".Net下对ActiveMQ的使用"：关键词：net 下 activemq 使用 　　刚来到一个新公司，因为项目需要，要使用activemq，于是就研究了一下，写下此篇笔记，借鉴...
11、Spring Cloud Stream消息驱动组件
JoyceYoung的博客
01-05 143
目录一、解决的问题二、重要的概念三、消息通信⽅式及编程模型1、消息通信⽅式2、编程模型四、应用实例（一）⽣产者端1、pom2、application.yml3、service①IMessageProducer②MessageProducerImpl4、test测试（二）消费者端接收消息1、pom2、application.yml3、service（三）测试（四）consumer集群 一、解决的问题 二、重要的概念 Spring Cloud Stream 是⼀个构建消息驱动微服务的框架。应⽤程序通过input
.NET 组件连接 activemq
elef的博客
09-22 519
组件安装。
Apache ActiveMQ实战(1)-基本安装配置与消息类型
技术何
12-11 855
Apache ActiveMQ实战(1)-基本安装配置与消息类型
[转][ActiveMQ]Apache.NMS.ActiveMQ 用法
weixin_30883311的博客
01-27 975
下载 C# 组件：http://archive.apache.org/dist/activemq/apache-nms/1.7.0/ 使用说明：https://www.cnblogs.com/cjm123/p/8521148.html 转载于:https://www.cnblogs.com/z5337/p/10325950.html
.net 封装的ActiveMq消息列队
05-17
这些库允许.NET开发者与ActiveMQ服务器通信，实现发布/订阅、点对点消息模式等。在项目中添加引用后，你可以创建连接工厂，设置连接参数，如服务器地址、端口、用户名和密码： ```csharp var cf = new ...
ActiveMQ Demo（C#）
08-14
ActiveMQ Demo程序，包括发送和接收程序，WinForm开发 关于ActiveMQ的介绍，请看我的这篇文章：http://blog.csdn.net/bodybo/article/details/5647968
C#客户端开发ActiveMq请下载Apache.NMS和Apache.NMS.ActiveMQ两个bin包
10-19
C#客户端开发ActiveMq请下载Apache.NMS和Apache.NMS.ActiveMQ两个bin包
ActiveMQ-CPP在vs2017上测试通过
12-30
ActiveMQ-CPP在vs2017上测试通过,测试时间 2018年12月30日
SpringBoot整合ActiveMQ消息队列和双向队列、点对点与发布订阅
10-16
SpringBoot整合ActiveMQ消息队列和双向队列、点对点与发布订阅，可以参考我的博客文章进行学习https://blog.csdn.net/sujin_/article/details/82956386
ActiveMQ消息中间件面试专题.pdf
03-11
- 支持多种消息类型，如点对点（Point-to-Point, P2P）和发布/订阅（Publish/Subscribe, Pub/Sub）模型。 - 提供持久性和非持久性消息支持。 - 具备高可用性和集群支持。 - 支持多种传输协议，包括TCP、SSL、NIO...
C#，activemq，mq
07-05
主题采用发布/订阅模式，多订阅者可以同时接收相同的消息；而队列遵循先进先出（FIFO）原则，每个消息仅被一个消费者接收。此外，ActiveMQ还具备事务管理、持久化、消息优先级、死信队列等功能，这些都是在设计和...
ActiveMQ实战：安装与配置详解
最新发布
禅与计算机程序设计艺术
01-28 1649
1.背景介绍 1. 背景介绍 Apache ActiveMQ 是一个开源的消息中间件，它提供了一种高效、可靠的消息传递机制，使得多个应用程序之间可以轻松地交换信息。ActiveMQ 支持多种消息传递协议，如 JMS、AMQP、MQTT 等，可以满足不同应用程序的需求。 在现代软件架构中，消息中间件是一种常见的设计模式，它可以解耦应用程序之间的通信，提高系统的可扩展性和可靠性。ActiveMQ...
ActiveMQ客户端Apache.NMS从.net 4.0移植到.net standard 2.0
weixin_30917213的博客
07-06 313
1.从官网或GitHub下载Apache.NMS源码 2.新建.net standard 2.0类库 3.将源码复制到新建的类库中，并删除或注释CommonAssemblyInfo.cs文件（程序集版本类） 4.同样的方法创建Apache.NMS.ActiveMQ类库 5.添加Apache.NMS项目引用，并用nuget添加Ionic.Zlib.Core（.net 4.0项目依赖...
C# 连接ActiveMQ（避坑指南）
weixin_39796553的博客
07-12 1586
最近公司的一个项目要使用ActiveMQ，客户端使用C#，.NET Framework4.7.2。 在网上找了教程，引入了两个包分别是：Apache.NMS(v2.0.0) 和Apache.NMS.ActiveMQ(v1.8.0) 连接ActiveMQ的代码片段如下： using System; using Apache.NMS; using Apache.NMS.ActiveMQ; using Apache.NMS.Util; .... Uri connecturi = new Uri("..
C#实战：ActiveMQ与Spring.NET的消息中间件开发实例
5. **发布/订阅模式示例**：演示如何在ActiveMQ中设置发布者和多个订阅者，实现消息的多对多传播。 6. **错误处理与事务性**：探讨如何处理消息传递过程中的错误，以及如何在ActiveMQ中实现事务控制。 7. **性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值