redis异步实现订阅和发布（C++）

最新推荐文章于 2024-05-15 07:50:31 发布
最新推荐文章于 2024-05-15 07:50:31 发布
阅读量2.9k 收藏 24
点赞数 4
分类专栏： cpp 文章标签： cpp资料参考
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenmeng729970897/article/details/115068630
版权
发布订阅模式

订阅、取消订阅和发布实现了发布/订阅消息范式，发布者不是计划发送消息给特定的订阅者。而是发布的消息分到不同的频道，不需要知道什么样的订阅者订阅。
订阅者对一个或多个频道感兴趣，只需接收感兴趣的消息，不需要知道什么样的发布者发布的。
示例使用libevent库、boost库、 hiredis库等，因为是基于异步的发送和接收，需要回调函数来返回确认相关的信息。

  1. 发布者模块
// redis_publisher.h封装了hiredis,实现消息发布给redis的功能。
#ifndef REDIS_PUBLISHER_H
#define REDIS_PUBLISHER_H

#include <stdlib.h>
#include <hiredis/async.h>
#include <hiredis/adapters/libevent.h>
#include <string>
#include <vector>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <boost/tr1/functional.hpp>

class CRedisPublisher
{
public:    
    CRedisPublisher();
    ~CRedisPublisher();
 // 初识化
    bool init();
// 反初始化
    bool uninit();
// 连接
    bool connect();
// 断开连接
    bool disconnect();
    
// 推送
    bool publish(const std::string &channel_name, 
        const std::string &message);

private:
     // 下面三个回调函数供redis服务调用
    // 连接回调
    static void connect_callback(const redisAsyncContext *redis_context,
        int status);
// 断开连接的回调
    static void disconnect_callback(const redisAsyncContext *redis_context,
        int status);
// 执行命令回调
    static void command_callback(redisAsyncContext *redis_context,
        void *reply, void *privdata);

    // 事件分发线程函数
    static void *event_thread(void *data);
    void *event_proc();

private:
     // libevent事件对象
    event_base *_event_base;
//  事件线程ID
    pthread_t _event_thread;
//  事件线程的信号量
    sem_t _event_sem;
//  hiredis异步对象
    redisAsyncContext *_redis_context;
};
#endif

#include <stddef.h>
#include <assert.h>
#include <string.h>
#include "redis_publisher.h"

CRedisPublisher::CRedisPublisher():_event_base(0), _event_thread(0),
_redis_context(0)
{
}

CRedisPublisher::~CRedisPublisher()
{
}

bool CRedisPublisher::init()
{
    // initialize the event
    _event_base = event_base_new();    // 创建libevent对象
    if (NULL == _event_base)
    {
        printf(": Create redis event failed.\n");
        return false;
    }

    memset(&_event_sem, 0, sizeof(_event_sem));
    int ret = sem_init(&_event_sem, 0, 0);
    if (ret != 0)
    {
        printf(": Init sem failed.\n");
        return false;
    }

    return true;
}

bool CRedisPublisher::uninit()
{
    _event_base = NULL;

    sem_destroy(&_event_sem);   
    return true;
}

bool CRedisPublisher::connect()
{
    // connect redis
    _redis_context = redisAsyncConnect("127.0.0.1", 6379);    // 异步连接到redis服务器上，使用默认端口
    if (NULL == _redis_context)
    {
        printf(": Connect redis failed.\n");
        return false;
    }

    if (_redis_context->err)
    {
        printf(": Connect redis error: %d, %s\n", 
            _redis_context->err, _redis_context->errstr);    // 输出错误信息
        return false;
    }

    // attach the event
    redisLibeventAttach(_redis_context, _event_base);    // 将事件绑定到redis context上，使设置给redis的回调跟事件关联
    // 创建事件处理线程
    int ret = pthread_create(&_event_thread, 0, &CRedisPublisher::event_thread, this);
    if (ret != 0)
    {
        printf(": create event thread failed.\n");
        disconnect();
        return false;
    }
    // 设置连接回调，当异步调用连接后，服务器处理连接请求结束后调用，通知调用者连接的状态
    redisAsyncSetConnectCallback(_redis_context, 
        &CRedisPublisher::connect_callback);
    // 设置断开连接回调，当服务器断开连接后，通知调用者连接断开，调用者可以利用这个函数实现重连
    redisAsyncSetDisconnectCallback(_redis_context,
        &CRedisPublisher::disconnect_callback);

    // 启动事件线程
    sem_post(&_event_sem);
    return true;
}
bool CRedisPublisher::disconnect()
{
    if (_redis_context)
    {
        redisAsyncDisconnect(_redis_context);
        redisAsyncFree(_redis_context);
        _redis_context = NULL;
    }

    return true;
}

bool CRedisPublisher::publish(const std::string &channel_name,
    const std::string &message)
{
    int ret = redisAsyncCommand(_redis_context, 
        &CRedisPublisher::command_callback, this, "PUBLISH %s %s", 
        channel_name.c_str(), message.c_str());
    if (REDIS_ERR == ret)
    {
        printf("Publish command failed: %d\n", ret);
        return false;
    }

    return true;
}

void CRedisPublisher::connect_callback(const redisAsyncContext *redis_context,
    int status)
{
    if (status != REDIS_OK)
    {
        printf(": Error: %s\n", redis_context->errstr);
    }
    else
    {
        printf(": Redis connected!\n");
    }
}

void CRedisPublisher::disconnect_callback(
    const redisAsyncContext *redis_context, int status)
{
    if (status != REDIS_OK)
    {
        // 这里异常退出，可以尝试重连
        printf(": Error: %s\n", redis_context->errstr);
    }
}
// 消息接收回调函数
void CRedisPublisher::command_callback(redisAsyncContext *redis_context,
    void *reply, void *privdata)
{
    printf("command callback.\n");
    // 这里不执行任何操作
}

void *CRedisPublisher::event_thread(void *data)
{
    if (NULL == data)
    {
        printf(": Error!\n");
        assert(false);
        return NULL;
    }

    CRedisPublisher *self_this = reinterpret_cast<CRedisPublisher *>(data);
    return self_this->event_proc();
}

void *CRedisPublisher::event_proc()
{
   	sem_wait(&_event_sem);
    //  开启事件分发，event_base_dispatch会阻塞
    event_base_dispatch(_event_base);
    
    return NULL;
}
  1. 接受者模块
#ifndef REDIS_SUBSCRIBER_H
#define REDIS_SUBSCRIBER_H

#include <stdlib.h>
#include <hiredis/async.h>
#include <hiredis/adapters/libevent.h>
#include <string>
#include <vector>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <boost/tr1/functional.hpp>

class CRedisSubscriber
{
public:
    typedef std::tr1::function<void (const char*,const char *, int)>NotifyMessageFn;// 回调函数对象类型，当接收到消息后调用回调把消息发送出去

    CRedisSubscriber();
    ~CRedisSubscriber();

    bool init(const NotifyMessageFn &fn);    // 传入回调对象
    bool uninit();
    bool connect();
    bool disconnect();

    // 可以多次调用，订阅多个频道
    bool subscribe(const std::string &channel_name);

private:
    // 下面三个回调函数供redis服务调用
    // 连接回调
    static void connect_callback(const redisAsyncContext *redis_context,
        int status);

    // 断开连接的回调
    static void disconnect_callback(const redisAsyncContext *redis_context,
        int status);

    // 执行命令回调
    static void command_callback(redisAsyncContext *redis_context,
        void *reply, void *privdata);

    // 事件分发线程函数
    static void *event_thread(void *data);
    void *event_proc();

private:
    // libevent事件对象
    event_base *_event_base;
    // 事件线程ID
    pthread_t _event_thread;
    // 事件线程的信号量
    sem_t _event_sem;
    // hiredis异步对象
    redisAsyncContext *_redis_context;

    // 通知外层的回调函数对象
    NotifyMessageFn _notify_message_fn;
};
#endif


#include <stddef.h>
#include <assert.h>
#include <string.h>
#include "redis_subscriber.h"

CRedisSubscriber::CRedisSubscriber():_event_base(0), _event_thread(0),
_redis_context(0)
{
}

CRedisSubscriber::~CRedisSubscriber()
{
}

bool CRedisSubscriber::init(const NotifyMessageFn &fn)
{
    // initialize the event
    _notify_message_fn = fn;
    _event_base = event_base_new();    // 创建libevent对象
    if (NULL == _event_base)
    {
        printf(": Create redis event failed.\n");
        return false;
    }

    memset(&_event_sem, 0, sizeof(_event_sem));
    int ret = sem_init(&_event_sem, 0, 0);
    if (ret != 0)
    {
        printf(": Init sem failed.\n");
        return false;
    }

    return true;
}

bool CRedisSubscriber::uninit()
{
    _event_base = NULL;

    sem_destroy(&_event_sem);   
    return true;
}

bool CRedisSubscriber::connect()
{
    // connect redis
    _redis_context = redisAsyncConnect("127.0.0.1", 6379);    // 异步连接到redis服务器上，使用默认端口
    if (NULL == _redis_context)
    {
        printf(": Connect redis failed.\n");
        return false;
    }

    if (_redis_context->err)
    {
        printf(": Connect redis error: %d, %s\n", 
            _redis_context->err, _redis_context->errstr);    // 输出错误信息
        return false;
    }

    // attach the event
    redisLibeventAttach(_redis_context, _event_base);    // 将事件绑定到redis context上，使设置给redis的回调跟事件关联

    // 创建事件处理线程
    int ret = pthread_create(&_event_thread, 0, &CRedisSubscriber::event_thread, this);
    if (ret != 0)
    {
        printf(": create event thread failed.\n");
        disconnect();
        return false;
    }

    // 设置连接回调，当异步调用连接后，服务器处理连接请求结束后调用，通知调用者连接的状态
    redisAsyncSetConnectCallback(_redis_context, 
        &CRedisSubscriber::connect_callback);

    // 设置断开连接回调，当服务器断开连接后，通知调用者连接断开，调用者可以利用这个函数实现重连
    redisAsyncSetDisconnectCallback(_redis_context,
        &CRedisSubscriber::disconnect_callback);

    // 启动事件线程
    sem_post(&_event_sem);
    return true;
}

bool CRedisSubscriber::disconnect()
{
    if (_redis_context)
    {
        redisAsyncDisconnect(_redis_context);
        redisAsyncFree(_redis_context);
        _redis_context = NULL;
    }

    return true;
}

bool CRedisSubscriber::subscribe(const std::string &channel_name)
{
    int ret = redisAsyncCommand(_redis_context, 
        &CRedisSubscriber::command_callback, this, "SUBSCRIBE %s", 
        channel_name.c_str());
    if (REDIS_ERR == ret)
    {
        printf("Subscribe command failed: %d\n", ret);
        return false;
    }

    printf(": Subscribe success: %s\n", channel_name.c_str());
    return true;
}

void CRedisSubscriber::connect_callback(const redisAsyncContext *redis_context,
    int status)
{
    if (status != REDIS_OK)
    {
        printf(": Error: %s\n", redis_context->errstr);
    }
    else
    {
        printf(": Redis connected!");
    }
}

void CRedisSubscriber::disconnect_callback(
    const redisAsyncContext *redis_context, int status)
{
    if (status != REDIS_OK)
    {
        // 这里异常退出，可以尝试重连
        printf(": Error: %s\n", redis_context->errstr);
    }
}

// 消息接收回调函数
void CRedisSubscriber::command_callback(redisAsyncContext *redis_context,
    void *reply, void *privdata)
{
    if (NULL == reply || NULL == privdata) {
        return ;
    }

    // 静态函数中，要使用类的成员变量，把当前的this指针传进来，用this指针间接访问
    CRedisSubscriber *self_this = reinterpret_cast<CRedisSubscriber *>(privdata);
    redisReply *redis_reply = reinterpret_cast<redisReply *>(reply);

    // 订阅接收到的消息是一个带三元素的数组
    if (redis_reply->type == REDIS_REPLY_ARRAY &&
    redis_reply->elements == 3)
    {
        printf(": Recieve message:%s:%d:%s:%d:%s:%d\n",
        redis_reply->element[0]->str, redis_reply->element[0]->len,
        redis_reply->element[1]->str, redis_reply->element[1]->len,
        redis_reply->element[2]->str, redis_reply->element[2]->len);

        // 调用函数对象把消息通知给外层
        self_this->_notify_message_fn(redis_reply->element[1]->str,
            redis_reply->element[2]->str, redis_reply->element[2]->len);
    }
}

void *CRedisSubscriber::event_thread(void *data)
{
    if (NULL == data)
    {
        printf(": Error!\n");
        assert(false);
        return NULL;
    }

    CRedisSubscriber *self_this = reinterpret_cast<CRedisSubscriber *>(data);
    return self_this->event_proc();
}

void *CRedisSubscriber::event_proc()
{
    sem_wait(&_event_sem);

    // 开启事件分发，event_base_dispatch会阻塞
    event_base_dispatch(_event_base);

    return NULL;
}
  1. 发布者主程序
#include "redis_publisher.h"

int main(int argc, char *argv[])
{
    CRedisPublisher publisher;

    bool ret = publisher.init();
    if (!ret) 
    {
        printf("Init failed.\n");
        return 0;
    }

    ret = publisher.connect();
    if (!ret)
    {
        printf("connect failed.");
        return 0;
    }

    while (true)
    {
        publisher.publish("test-channel", "Hello redis test1!");
publisher.publish("test-channe2", "test2")
        sleep(1);
    }

    publisher.disconnect();
    publisher.uninit();
    return 0;
}
  1. 订阅者主程序
#include "redis_subscriber.h"

void recieve_message(const char *channel_name,
    const char *message, int len)
{
    printf("Recieve message:\n    channel name: %s\n    message: %s\n",
        channel_name, message);
}

int main(int argc, char *argv[])
{
    CRedisSubscriber subscriber;
    CRedisSubscriber::NotifyMessageFn fn = 
        bind(recieve_message, std::tr1::placeholders::_1,
        std::tr1::placeholders::_2, std::tr1::placeholders::_3);

    bool ret = subscriber.init(fn);
    if (!ret)
    {
        printf("Init failed.\n");
        return 0;
    }

    ret = subscriber.connect();
    if (!ret)
    {
        printf("Connect failed.\n");
        return 0;
    }

    subscriber.subscribe("test-channel");
subscriber.subscribe("test-channe2");

    while (true)
    {
        sleep(1);
    }

    subscriber.disconnect();
    subscriber.uninit();

    return 0;
}
conetwo
关注
  • 4
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php运用redis订阅发布功能实现异步消息任务处理
不知道起什么名字
11-07 915
话不多说直接上代码： 消费者代码：subscribe.php <?php set_time_limit(0); ini_set("default_socket_timeout",-1); $channel1="pubsub1";//频道1 $channel2="pubsub2";//频道2 try{ $redis=new Redis(); $redis->pconnect("127.0.0.1",6379); /** * [$callback 回调函数] * @$redis [当
推荐开源库：cpp_redis - 高效易用的C++ Redis客户端库
gitblog_00100的博客
05-14 413
推荐开源库：cpp_redis - 高效易用的C++ Redis客户端库 项目地址:https://gitcode.com/Cylix/cpp_redis 1、项目介绍 cpp_redis 是一个由C++11编写的轻量级异步多平台Redis客户端库。它不仅支持同步操作和管道（pipelining）功能，还具有哨兵（sentinel）支持和高可用性特性。虽然这个项目目前已经不再维护，但有一个活跃的f...
C++实现redis发布订阅模式
最新发布
weixin_43803780的博客
05-15 551
在C++中实现Redis的发布-订阅模式，通常会使用一个Redis客户端库，如`hiredis`，这是一个广泛使用的、轻量级的C语言库，同样适用于C++项目。下面是一个使用`hiredis`实现发布和订阅功能的基本示例。这段代码展示了如何创建一个订阅线程来监听特定频道的消息，并在主线程中发布消息到该频道。订阅消息通常在一个单独的线程中进行，因为订阅操作会阻塞等待新的消息到来。首先，确保你已经安装了`hiredis`库。// 注意：在实际应用中，你可能需要添加适当的逻辑来控制程序的退出，
C++ 实现 redis 发布订阅 --- 使用 hiredis 同步API（一）
12-19 1381
在集群分布式环境中，经常使用的中间件消息队列有ActiveMQ、RabbitMQ、Kafka等，都是应用场景广泛并且性能很好的消息队列，供集群服务器之间，分布式服务之间进行消息通信。限于我们的项目业务类型并不是非常复杂，对并发请求量也没有太高的要求，因此我们的中间件消息队列选型的是基于发布-订阅模式的redis。这样的设计使得各个服务器之间耦合度太高，不利于系统扩展，并且会占用系统大量的socket资源，各服务器之间的带宽压力很大，不能够节省资源给更多的客户端提供服务，因此绝对不是一个好的设计。
C++ 实现 redis 发布订阅 --- 使用 hiredis 同步API（三）
12-22 721
本文只总结常规会用到的hiRedis使用方法，一般顺序为先用 redisConnect 连接数据库，然后用 redisCommand 执行命令，执行完后用 freeReplyObject 来释放redisReply对象，最后用 redisFree 来释放整个连接。，然后make && make install。
使用Redis发布订阅功能实现动态注册监听及异步获取结果
小飞侠的博客
10-23 515
我们系统夸服务去调用某些请求，但被调用的服务又没办法及时响应，而需要异步返回结果的时候，我们使用同步阻塞的话比较浪费资源拉低系统的吞吐能力，对于一些耗时的操作，因为长时间的等待还容易导致请求超时处理失败（实际可能已经处理成功了）。 我们系统夸服务去调用某些请求，但被调用的服务又没办法及时响应，而需要异步返回结果的时候，我们使用同步阻塞的话比较浪费资源拉低系统的吞吐能力，对于一些耗时的操作，因为长时间的等待还容易导致请求超时处理失败（实际可能已经处理成功了）。
Redis做消息订阅和发布【异步完成操作】
小魏快起床的博客
06-29 4027
一、背景：今天遇到了一个问题，在springboot项目中，想用一个异步的思想完成对数据库的操作，本来想用Mq的方式，但是集成太麻烦了，刚好系统里面已经有了redis，就用了redis做异步的功能。二、需要准备的东西springboot项目，redis能正常用就行【redis集成不会的需要先看其他的文章连接好】三、操作步骤 1、编写一个实体类，其中字段可以根据自己的业务来定 2、编写一个结果常量类ConstantResult 3、编写一个公共返回结果类CommonResult，用自己系统中的也可以
C++ 实现 redis 订阅发布 --- libevent
12-15 1013
订阅、取消订阅和发布实现了发布/订阅消息范式，发布者不是计划发送消息给特定的订阅者。而是发布的消息分到不同的频道，不需要知道什么样的订阅者订阅。libevent库、boost库、 hiredis库等，因为是基于异步的发送和接收，需要回调函数来返回确认相关的信息。订阅者对一个或多个频道感兴趣，只需接收感兴趣的消息，不需要知道什么样的发布者发布的。
redis c++封装.zip
04-28
9. **发布订阅(Pub/Sub)**：C++封装需支持发布与订阅功能，以便实现基于消息的通知或通信。 10. **Lua脚本支持**：Redis支持在服务器端执行Lua脚本，可以在封装中提供接口，让用户能够方便地执行自定义的Lua脚本。 ...
distr-redis-master.zip_C++操作Redis_redis c++_redis c++_redis分布式_
09-20
在C++应用中，需要根据具体需求设计和实现分布式策略，比如使用Sentinel获取主从节点信息，动态调整连接。 7. **Redis Cluster**：更高级的分布式解决方案是Redis Cluster，它提供了数据分区（Sharding）和无中心...
simple-redis_redis_C++_
10-03
Redis 支持多种类型的数据结构，如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等，还支持通过主从复制实现高可用性，以及通过LUA脚本、事务、发布订阅等特性来增强...
redis订阅机制简单的使用方法
07-23
redis订阅机制，一方面推送消息，另一方面同时接收消息。
C++封装Redis访问类
04-26
C++封装Redis访问类，封装set和get操作
cpp_redis：C ++ 11轻量级Redis客户端：异步，线程安全，无依赖项，流水线，多平台
01-28
cpp_redis cpp_redis是C ++ 11异步多平台轻量级Redis客户端，支持同步操作，流水线，标记和高可用性。 需求 cpp_redis没有依赖项。 它唯一的要求是C++11 。 它没有网络模块，因此您可以自由配置自己的模块，也可以使用默认模块（ ） 例 cpp_redis :: client cpp_redis::client client; client.connect(); client.set( " hello " , " 42 " ); client.get( " hello " , [](cpp_redis::reply& reply) { std::cout << reply> get_reply = client.get("hello"); client.sync_commit(); // ! or client.commit(); for asynchronous call c
vs2012 c++ redis
05-18
我们将通过一个名为"RedisTestDemo"的项目实例，详细介绍如何在VS2012中构建和实现C++与Redis的连接。 首先，为了在C++中使用Redis，我们需要一个客户端库。常见的选择有Hiredis和cpp_redis等。这里我们假设你已经...
windows 64位redis2.6 API C++库和头文件
08-02
- **发布/订阅**：hiredis支持Redis的发布/订阅功能，允许程序作为发布者或订阅者参与事件驱动通信。 - **内存管理**：使用完`redisReply`后，需要调用`freeReplyObject`释放内存，避免内存泄漏。 通过以上步骤和...
C++并发编程（四）同步与异步
CSSS_2021的博客
01-05 3504
C++并发编程笔记
C++测试redis中的publish/subscribe
灯火阑珊处
01-17 7700
运用 http://blog.csdn.net/xumaojun/article/details/51558237 中的redis_publisher.h redis_publisher.cpp redis_subscriber.h redis_subscriber.cpp四个文件,做一个操作类进行测试. 头文件 Policy.h #pragma once #include "redi
Redis异步
qq_20853741的博客
12-22 1121
Hiredis 结构图 sds 说明：简单字符类型，typedef char * sds API sds sdsnewlen(const void *init, size_t initlen) sds sdsnew(const char *init) sds sdsempty(void) size_t sdslen(const sds s) sds sdsdup(const sds s) void sdsfree(sds s) size_t sdsavail(const sds .
ssm redis实现发布订阅
04-30
SSM（Spring+Spring MVC+MyBatis）框架和Redis数据库通常可以结合使用以实现发布订阅功能。 发布订阅模式是一种面向消息的通信方式，多个接收者监听同一个主题，当主题发布消息时，所有接收者都会接收到通知并执行相应的操作。Redis的发布订阅功能是Redis提供的一种基于事件驱动的消息通知机制，可以让多个客户端同时接收系统事件的通知。 在SSM框架中，可以使用Spring框架的事件驱动机制来实现发布订阅功能。具体地，可以在Spring框架的配置文件中配置一个事件监听器（Event Listener），该监听器会监听指定的事件。当该事件发生时，监听器会接收到事件通知，并执行相应的业务逻辑。例如，可以将Redis的发布消息事件（PUBLISH）作为Spring事件，然后在事件监听器中实现对该事件的处理逻辑。 在Redis中，可以使用PUBLISH命令向指定的频道（Channel）发布消息。多个客户端可以使用SUBSCRIBE命令来订阅指定的频道，当有消息发布到该频道时，所有订阅该频道的客户端都会接收到该消息。 因此，在SSM和Redis中实现发布订阅功能的步骤大致可以分为以下几步： 1. 配置Redis连接信息，以便SSM框架能够正确连接到Redis数据库。 2. 在Spring框架的配置文件中定义一个事件监听器，该监听器将监听Redis的发布事件。 3. 在监听器中编写事件处理逻辑，例如向所有订阅了该频道的客户端发送指定的消息。 4. 在应用程序中使用PUBLISH命令向指定的频道发布消息，或使用SUBSCRIBE命令订阅指定的频道。 通过以上步骤，便可以在SSM框架和Redis数据库中实现发布订阅功能。该功能可用于实现实时消息推送、事件通知等功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值