IM项目：进阶版即时通讯项目---文件存储和消息转发

于 2024-08-25 18:48:44 发布
阅读量551 收藏 12
点赞数 22
分类专栏： 实战项目 文章标签： 项目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73899585/article/details/141532508
版权

文章目录

文件传输服务

基本功能

  1. 文件的上传
  2. 文件的下载

模块划分

  1. 基于gflags进行参数和配置文件的解析
  2. 基于spdlog进行日志输出
  3. 基于etcd进行服务注册
  4. 基于brpc进行RPC服务器远程调用
  5. 基于文件流操作进行读写的封装

流程图

在这里插入图片描述

实现逻辑

  1. 单个文件上传
  • 获取文件的元数据
  • 分配文件的ID
  • 以文件ID为文件名打开文件，写入数据
  • 组织响应返回
  1. 单个文件下载
  • 从请求中获取文件ID
  • 打开文件，获取大小，读取数据
  • 组织响应返回
  1. 多个文件上传

这个就是循环一下

  1. 多个文件下载

这个就是循环一下

代码实现

/**
 * @file file_server.hpp
 * @brief 文件传输服务，和语音传输服务基本相同
 * @author zhaobohan (zhaobohan_free@163.com)
 */
#include <brpc/server.h>
#include <butil/logging.h>

#include "../../common/etcd.hpp"     // 服务注册模块封装
#include "../../common/logger.hpp"   // 日志模块封装
#include "../../common/utils.hpp"
// #include "base.pb.h"
// #include "file.pb.h"

#include "../build/base.pb.h"
#include "../build/file.pb.h"

namespace im 
{

// 对于文件服务的封装
class FileServiceImpl : public im::FileService 
{
public:
    FileServiceImpl(const std::string &storage_path)
        : _storage_path(storage_path)
    {
        umask(0);
        mkdir(storage_path.c_str(), 0775);
        if (_storage_path.back() != '/') 
            _storage_path.push_back('/');
    }

    ~FileServiceImpl()
    {}

    void GetSingleFile(google::protobuf::RpcController* controller,
                const ::im::GetSingleFileReq* request,
                ::im::GetSingleFileRsp* response,
                ::google::protobuf::Closure* done) 
    {
        brpc::ClosureGuard rpc_guard(done);
        response->set_request_id(request->request_id());
        // 1. 取出请求中的文件ID（起始就是文件名）
        std::string fid = request->file_id();
        std::string filename = _storage_path + fid;
        // 2. 将文件ID作为文件名，读取文件数据
        std::string body;
        bool ret = readFile(filename, body);
        if (ret == false) 
        {
            response->set_success(false);
            response->set_errmsg("读取文件数据失败！");
            LOG_ERROR("{} 读取文件数据失败！", request->request_id());
            return;
        }

        // 3. 组织响应
        response->set_success(true);
        response->mutable_file_data()->set_file_id(fid);
        response->mutable_file_data()->set_file_content(body);
    }

    void GetMultiFile(google::protobuf::RpcController* controller,
                const ::im::GetMultiFileReq* request,
                ::im::GetMultiFileRsp* response,
                ::google::protobuf::Closure* done) 
    {
        brpc::ClosureGuard rpc_guard(done);
        response->set_request_id(request->request_id());
        // 循环取出请求中的文件ID，读取文件数据进行填充
        for (int i = 0; i < request->file_id_list_size(); i++) 
        {
            std::string fid = request->file_id_list(i);
            std::string filename = _storage_path + fid;
            std::string body;
            bool ret = readFile(filename, body);
            if (ret == false) 
            {
                response->set_success(false);
                response->set_errmsg("读取文件数据失败！");
                LOG_ERROR("{} 读取文件数据失败！", request->request_id());
                return;
            }

            FileDownloadData data;
            data.set_file_id(fid);
            data.set_file_content(body);
            response->mutable_file_data()->insert({fid, data});
        }
        response->set_success(true);
    }

    void PutSingleFile(google::protobuf::RpcController* controller,
                const ::im::PutSingleFileReq* request,
                ::im::PutSingleFileRsp* response,
                ::google::protobuf::Closure* done) 
    {
        brpc::ClosureGuard rpc_guard(done);
        response->set_request_id(request->request_id());
        // 1. 为文件生成一个唯一uudi作为文件名 以及 文件ID
        std::string fid = uuid();
        std::string filename = _storage_path + fid;
        // 2. 取出请求中的文件数据，进行文件数据写入
        bool ret = writeFile(filename, request->file_data().file_content());
        if (ret == false) 
        {
            response->set_success(false);
            response->set_errmsg("读取文件数据失败！");
            LOG_ERROR("{} 写入文件数据失败！", request->request_id());
            return;
        }
        // 3. 组织响应
        response->set_success(true);
        response->mutable_file_info()->set_file_id(fid);
        response->mutable_file_info()->set_file_size(request->file_data().file_size());
        response->mutable_file_info()->set_file_name(request->file_data().file_name());
    }

    void PutMultiFile(google::protobuf::RpcController* controller,
                const ::im::PutMultiFileReq* request,
                ::im::PutMultiFileRsp* response,
                ::google::protobuf::Closure* done) 
    {
        brpc::ClosureGuard rpc_guard(done);
        response->set_request_id(request->request_id());
        for (int i = 0; i < request->file_data_size(); i++) 
        {
            std::string fid = uuid();
            std::string filename = _storage_path + fid;
            bool ret = writeFile(filename, request->file_data(i).file_content());
            if (ret == false) 
            {
                response->set_success(false);
                response->set_errmsg("读取文件数据失败！");
                LOG_ERROR("{} 写入文件数据失败！", request->request_id());
                return;
            }
            im::FileMessageInfo *info  = response->add_file_info();
            info->set_file_id(fid);
            info->set_file_size(request->file_data(i).file_size());
            info->set_file_name(request->file_data(i).file_name());
        }
        response->set_success(true);
    }

private:
    std::string _storage_path;
};

class FileServer 
{
public:
    using ptr = std::shared_ptr<FileServer>;

    FileServer(const Registry::ptr &reg_client,
        const std::shared_ptr<brpc::Server> &server):
        _reg_client(reg_client),
        _rpc_server(server)
    {}

    ~FileServer()
    {}

    // 搭建RPC服务器，并启动服务器
    void start() 
    {
        _rpc_server->RunUntilAskedToQuit();
    }

private:
    Registry::ptr _reg_client;
    std::shared_ptr<brpc::Server> _rpc_server;
};

class FileServerBuilder 
{
public:
    // 用于构造服务注册客户端对象
    void make_reg_object(const std::string &reg_host,
        const std::string &service_name,
        const std::string &access_host) 
    {
        _reg_client = std::make_shared<Registry>(reg_host);
        _reg_client->registry(service_name, access_host);
    }

    // 构造RPC服务器对象
    void make_rpc_server(uint16_t port, int32_t timeout, 
        uint8_t num_threads, const std::string &path = "./data/") 
    {
        _rpc_server = std::make_shared<brpc::Server>();
        FileServiceImpl *file_service = new FileServiceImpl(path);
        int ret = _rpc_server->AddService(file_service, 
            brpc::ServiceOwnership::SERVER_OWNS_SERVICE);
        if (ret == -1) 
        {
            LOG_ERROR("添加Rpc服务失败！");
            abort();
        }
        brpc::ServerOptions options;
        options.idle_timeout_sec = timeout;
        options.num_threads = num_threads;
        ret = _rpc_server->Start(port, &options);
        if (ret == -1) 
        {
            LOG_ERROR("服务启动失败！");
            abort();
        }
    }

    FileServer::ptr build() 
    {
        if (!_reg_client) 
        {
            LOG_ERROR("还未初始化服务注册模块！");
            abort();
        }

        if (!_rpc_server) 
        {
            LOG_ERROR("还未初始化RPC服务器模块！");
            abort();
        }

        FileServer::ptr server = std::make_shared<FileServer>(_reg_client, _rpc_server);
        return server;
    }

private:
    Registry::ptr _reg_client;
    std::shared_ptr<brpc::Server> _rpc_server;
};
}

消息转发

功能设计

消息转发子服务，主要是涉及到对于一条消息内容，组织消息的ID，以及其他元数据，然后传递给网关服务器，应该给谁进行发送

转发的目标一般是以聊天会话为基础进行传输的，通过会话就可以找到对应的聊天成员，作为一个转发的目标，并且还要把对应的数据存放在消息队列当中，消息队列收到消息后就会进行对应的回调处理，其实回调就是把数据存放在MySQL，elasticsearch，或者是文件存储系统中，这些内容我在后面的内容也都会涉及到，这里考虑到篇幅原因就不多多进行分析了

模块划分

  1. 基于gflags进行参数和配置文件解析
  2. 基于spdlog进行日志输出
  3. 基于etcd框架进行服务注册
  4. 基于ODB进行数据库对象操作
  5. 基于brpc进行RPC服务器搭建和远程调用
  6. 基于MQ将消息发布到消息队列并且进行对应的存储

下面来聊一下在这当中比较重要的接口

获取转发目标和消息处理

基本流程大概为

  1. 从请求中取出消息内容，会话ID，用户ID
  2. 根据用户ID，从用户管理子服务获取用户信息
  3. 根据消息内容进行填充消息结构，比如分配消息ID，填充发送者信息，填充消息产生时间
  4. 把消息传送给消息队列，进行持久化存储
  5. 从数据库获取目标会话的所有成员ID
  6. 组织响应，也就是完整的消息以及所有要被发送的用户ID，然后发送给网关，网关进行发送

代码实现

class TransmiteServiceImpl : public im::MsgTransmitService 
{
public:
    TransmiteServiceImpl(const std::string &user_service_name,
        const ServiceManager::ptr &channels,
        const std::shared_ptr<odb::core::database> &mysql_client,
        const std::string &exchange_name,
        const std::string &routing_key,
        const MQClient::ptr &mq_client)
        : _user_service_name(user_service_name)
        , _mm_channels(channels)
        , _mysql_session_member_table(std::make_shared<ChatSessionMemeberTable>(mysql_client))
        , _exchange_name(exchange_name)
        , _routing_key(routing_key)
        , _mq_client(mq_client)
    {}

    ~TransmiteServiceImpl()
    {}

    // 获取转发对象
    void GetTransmitTarget(google::protobuf::RpcController* controller,
                    const ::im::NewMessageReq* request,
                    ::im::GetTransmitTargetRsp* response,
                    ::google::protobuf::Closure* done) override 
    {
        brpc::ClosureGuard rpc_guard(done);
        auto err_response = [this, response](const std::string &rid, 
            const std::string &errmsg) -> void {
            response->set_request_id(rid);
            response->set_success(false);
            response->set_errmsg(errmsg);
            return;
        };

        // 从请求中获取关键信息：用户ID，所属会话ID，消息内容
        std::string rid = request->request_id();
        std::string uid = request->user_id();
        std::string chat_ssid = request->chat_session_id();
        const MessageContent &content = request->message();

        // 进行消息组织：发送者-用户子服务获取信息，所属会话，消息内容，产生时间，消息ID
        auto channel = _mm_channels->choose(_user_service_name);
        if (!channel) 
        {
            LOG_ERROR("{}-{} 没有可供访问的用户子服务节点！", rid, _user_service_name);
            return err_response(rid, "没有可供访问的用户子服务节点！");
        }

        // 去查找用户的信息
        UserService_Stub stub(channel.get());
        GetUserInfoReq req;
        GetUserInfoRsp rsp;
        req.set_request_id(rid);
        req.set_user_id(uid);
        brpc::Controller cntl;
        stub.GetUserInfo(&cntl, &req, &rsp, nullptr);
        if (cntl.Failed() == true || rsp.success() == false) 
        {
            LOG_ERROR("{} - 用户子服务调用失败：{}！", request->request_id(), cntl.ErrorText());
            return err_response(request->request_id(), "用户子服务调用失败!");
        }

        // 构造消息结构体
        MessageInfo message;
        message.set_message_id(uuid());
        message.set_chat_session_id(chat_ssid);
        message.set_timestamp(time(nullptr));
        message.mutable_sender()->CopyFrom(rsp.user_info());
        message.mutable_message()->CopyFrom(content);

        // 获取消息转发客户端用户列表
        auto target_list = _mysql_session_member_table->members(chat_ssid);

        // 将封装完毕的消息，发布到消息队列，待消息存储子服务进行消息持久化
        bool ret = _mq_client->publish(_exchange_name, message.SerializeAsString(), _routing_key);
        if (ret == false) 
        {
            LOG_ERROR("{} - 持久化消息发布失败：{}！", request->request_id(), cntl.ErrorText());
            return err_response(request->request_id(), "持久化消息发布失败：!");
        }

        // 组织响应，告诉网关要给谁传消息
        response->set_request_id(rid);
        response->set_success(true);
        response->mutable_message()->CopyFrom(message);
        for (const auto &id : target_list) 
        {
            response->add_target_id_list(id);
        }
    }

private:
    // 用户子服务调用相关信息
    std::string _user_service_name;
    ServiceManager::ptr _mm_channels;

    // 聊天会话成员表的操作句柄
    ChatSessionMemeberTable::ptr _mysql_session_member_table;

    // 消息队列客户端句柄
    std::string _exchange_name;
    std::string _routing_key;
    MQClient::ptr _mq_client;
};

class TransmiteServer 
{
public:
    using ptr = std::shared_ptr<TransmiteServer>;
    TransmiteServer(
        const std::shared_ptr<odb::core::database> &mysql_client,
        const Discovery::ptr discovery_client,
        const Registry::ptr &registry_client,
        const std::shared_ptr<brpc::Server> &server):
        _service_discoverer(discovery_client),
        _registry_client(registry_client),
        _mysql_client(mysql_client),
        _rpc_server(server)
    {}

    ~TransmiteServer()
    {}

    // 搭建RPC服务器，并启动服务器
    void start() 
    {
        _rpc_server->RunUntilAskedToQuit();
    }

private:
    // 服务发现客户端
    Discovery::ptr _service_discoverer;

    // 服务注册客户端
    Registry::ptr _registry_client;
    
    // mysql数据库客户端
    std::shared_ptr<odb::core::database> _mysql_client;
    std::shared_ptr<brpc::Server> _rpc_server;
};

class TransmiteServerBuilder 
{
public:
    // 构造mysql客户端对象
    void make_mysql_object(
        const std::string &user,
        const std::string &pswd,
        const std::string &host,
        const std::string &db,
        const std::string &cset,
        int port,
        int conn_pool_count) 
    {
        _mysql_client = ODBFactory::create(user, pswd, host, db, cset, port, conn_pool_count);
    }

    // 用于构造服务发现客户端&信道管理对象
    void make_discovery_object(const std::string &reg_host,
        const std::string &base_service_name,
        const std::string &user_service_name) 
    {
        _user_service_name = user_service_name;
        _mm_channels = std::make_shared<ServiceManager>();
        _mm_channels->declared(user_service_name);
        LOG_DEBUG("设置用户子服务为需添加管理的子服务：{}", user_service_name);
        auto put_cb = std::bind(&ServiceManager::onServiceOnline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
        auto del_cb = std::bind(&ServiceManager::onServiceOffline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
        _service_discoverer = std::make_shared<Discovery>(reg_host, base_service_name, put_cb, del_cb);
    }

    // 用于构造服务注册客户端对象
    void make_registry_object(const std::string &reg_host,
        const std::string &service_name,
        const std::string &access_host) 
    {
        _registry_client = std::make_shared<Registry>(reg_host);
        _registry_client->registry(service_name, access_host);
    }

    // 用于构造rabbitmq客户端对象
    void make_mq_object(const std::string &user, 
        const std::string &passwd,
        const std::string &host,
        const std::string &exchange_name,
        const std::string &queue_name,
        const std::string &binding_key) 
    {
        _routing_key = binding_key;
        _exchange_name = exchange_name;
        _mq_client = std::make_shared<MQClient>(user, passwd, host);
        _mq_client->declareComponents(exchange_name, queue_name, binding_key);
    }

    // 构造RPC服务器对象
    void make_rpc_server(uint16_t port, int32_t timeout, uint8_t num_threads) 
    {
        if (!_mq_client) 
        {
            LOG_ERROR("还未初始化消息队列客户端模块！");
            abort();
        }

        if (!_mm_channels) 
        {
            LOG_ERROR("还未初始化信道管理模块！");
            abort();
        }

        if (!_mysql_client) 
        {
            LOG_ERROR("还未初始化Mysql数据库模块！");
            abort();
        }

        _rpc_server = std::make_shared<brpc::Server>();

        TransmiteServiceImpl *transmite_service = new TransmiteServiceImpl(
            _user_service_name, _mm_channels, _mysql_client, _exchange_name, _routing_key, _mq_client);

        int ret = _rpc_server->AddService(transmite_service, 
            brpc::ServiceOwnership::SERVER_OWNS_SERVICE);
        if (ret == -1) 
        {
            LOG_ERROR("添加Rpc服务失败！");
            abort();
        }

        brpc::ServerOptions options;
        options.idle_timeout_sec = timeout;
        options.num_threads = num_threads;
        ret = _rpc_server->Start(port, &options);
        if (ret == -1) 
        {
            LOG_ERROR("服务启动失败！");
            abort();
        }

    }


    TransmiteServer::ptr build() 
    {
        if (!_service_discoverer) 
        {
            LOG_ERROR("还未初始化服务发现模块！");
            abort();
        }

        if (!_registry_client) 
        {
            LOG_ERROR("还未初始化服务注册模块！");
            abort();
        }

        if (!_rpc_server) 
        {
            LOG_ERROR("还未初始化RPC服务器模块！");
            abort();
        }

        TransmiteServer::ptr server = std::make_shared<TransmiteServer>(
            _mysql_client, _service_discoverer, _registry_client, _rpc_server);
        return server;
    }

private:
    std::string _user_service_name;
    ServiceManager::ptr _mm_channels;
    Discovery::ptr _service_discoverer;
    
    std::string _routing_key;
    std::string _exchange_name;
    MQClient::ptr _mq_client;

    // 服务注册客户端
    Registry::ptr _registry_client;
    // mysql数据库客户端
    std::shared_ptr<odb::core::database> _mysql_client;
    std::shared_ptr<brpc::Server> _rpc_server;
};
海绵宝宝de派小星
关注
  • 22
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
风车IM即时通讯聊天系统源码-聊天APP-附APP-带安装教程.zip
10-30
风车IM即时通讯聊天系统源码是一款用于构建聊天应用程序的完整解决方案，包含了客户端应用和服务器端的源代码，以及相关的安装和配置指南。这个系统旨在提供高效、稳定且安全的实时通信功能，使得用户能够在不同设备...
message-forward：连接不同即时消息平台的消息转发程序。
02-14
本项目致力于通过消息转发连接不同的IM（Instant Messageing即时通讯）平台。 初步支持：Ｍinecraft我的世界，腾讯QQ腾讯QQ，Discord等IM平台的互相转发。 安装|部署 在Minecraft-Bukkit端部署 在下载bukkit-source....
IM即时通讯-1-项目需求说明书
潘永强_PandaPan的博客
01-10 1523
即时通讯是现代交流的重要技术，它可以更方便快捷的进行群聊、聊天等功能，以便满足用户之间的沟通要求。即时通讯是一种基于网络的实时通信工具，它能够使各种跨设备的用户在网络中实现实时信息交换，形成紧密的讯息网络，实现系统即时通信。本项目基于这个背景，构建一个多设备即时通讯的轻量级软件，能够实现跨操作系统、跨设备实时交流，依靠移动设备的灵活性，系统可以实现用户间的便捷交流。
IM即时通讯-2-如何做技术方案设计
潘永强_PandaPan的博客
01-28 684
IM的技术方案如何设计, 本文提供了思路, 从功能列表到核心case的方案出发, 最终到整体的方案设计
小盒即时通讯IM-全套开源-开箱即用
蓝缘
09-13 3044
# 小盒即时通讯软件 介绍2021最新4合1即时通讯IM源码 服务端 PC WEB 安卓 IOS完整原生源码xsbox-im 小盒即时通讯软件，客户端全套开源 xsbox-im 小盒即时通讯软件，客户端全套开源,不加任何限制，可个人，可商业，可二次开发，随意使用 2021最新4合1即时通讯IM源码 服务端 PC WEB 安卓 IOS完整原生源码，视频安装教程，文档安装教程等等 注意：视频
收藏-即时通讯(IM)开源项目OpenIM-功能手册
OpenIM的博客
08-03 4841
收藏-即时通讯(IM)开源项目OpenIM-功能手册
IM-java.rar_ICQ/即时通讯_Java_
08-11
标题中的"IM-java.rar"表明这是一个使用Java编程语言开发的即时通讯（Instant Messaging，简称IM）项目。"ICQ/即时通讯"标签暗示了这个项目可能是受到ICQ这个早期流行的即时通讯软件启发，或者实现了类似的功能。...
52im即时通讯源码 带安卓和iso源码
08-17
52im即时通讯源码是一款支持Android和iOS平台的开源解决方案，允许开发者构建自己的聊天应用程序。本文将深入探讨这套源码的核心技术和实现细节。 一、即时通讯系统概述 即时通讯系统通常由客户端、服务端和通信...
2024最新仿默往IM即时通讯系统源码(PC+WEB+IOS+Android)客户端（大小2.4G）网盘链接提取码下载.txt
04-12
2024最新仿默往IM即时通讯系统源码(PC+WEB+IOS+Android)客户端 系统功能配置灵活、海量并发、稳定可靠、数据安全，2小时快速部署、数据安全、单聊群聊、系统通知等通信功能，支持App、PC、Web等多端快速接入。 群...
K210 车牌识别项目单片机代码，所用语言为C语言
08-24
K210 车牌识别项目单片机代码，所用语言为C语言
源代码-博购企业名录搜索软站留言簿.zip
08-24
源代码-博购企业名录搜索软站留言簿.zip
项目使用华为云_ModelArts_AI_开发平台进行训练部署，
08-24
项目使用华为云_ModelArts_AI_开发平台进行训练部署，采用_Mask_R-CNN_算法模型_ma-mask-rcnn
女弓箭手射箭动画动作：Stylish Archer Assets Pack 1.4
08-24
时尚射手行动包 包括与演示视频相同的角色和武器建模文件。 运动状态已与动画控制器对齐。 产品信息 角色联盟被设置为类人配置。包括5根手指骨、肩臂和腿部扭转骨。 所有动画都包含在内。 弓箭手包总计：454 攻击力：97 移动：38 起立和坐下：4 蹲伏移动：11 蹲下-行走：16 蹲下_行走_瞄准：16 重新加载 : 9 蹲下_瞄准_射击：2 道奇：8 慢跑：20 技能 : 46 步行_目标：16 + 18（版本1.2） 步行：16 装备与解除装备：2 跳跃和双跳：28 空袭：8 移动转身：44 伤害：23 模具：3个 可拆卸：29 （这是原地运动和根运动的总和。）
MFCopencv图片浏览器实现源码MFCopencv图片浏览器实现源码
08-24
MFCopencv图片浏览器实现MFCopencv图片浏览器实现提取方式是百度网盘分享地址
基于springboot和vue的 社区医疗服务系统源码 （优秀毕业设计源码）
08-24
1. 社区医疗服务系统代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
vcpkg.exe windows运行程序
最新发布
08-24
vcpkg.exe windows运行程序
5G智慧农业大数据数字乡村乡村振兴整体建设方案.pdf
08-24
5G智慧农业大数据数字乡村乡村振兴整体建设方案.pdf
java源码资源网络蚂蚁Java版java源码资源网络蚂蚁Java版
08-24
java源码资源网络蚂蚁Java版java源码资源网络蚂蚁Java版提取方式是百度网盘分享地址
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海绵宝宝de派小星

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

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

抵扣说明：

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

余额充值