[微服务即时通讯系统]消息转发子服务的实现与测试

小小unicorn2026-03-13 21:21

本专栏内容为：项目专栏
💓博主csdn个人主页：小小unicorn

⏩专栏分类：微服务即时通讯系统

🚚代码仓库：小小unicorn的代码仓库🚚

🌹🌹🌹关注我带你学习编程知识

消息转发子服务

功能设计

转发子服务，主要用于针对一条消息内容，组织消息的 ID 以及各项所需要素，然后告诉网关服务器一条消息应该发给谁。

通常消息都是以聊天会话为基础进行发送的，根据会话找到它的所有成员，这就是转发的目标。

除此之外，转发子服务将收到的消息，放入消息队列中，由消息存储管理子服务进行消费存储

  • 获取消息转发目标：针对消息内容，组织消息，并告知网关转发目标。

模块划分

  1. 参数/配置文件解析模块：基于 gflags 框架直接使用进行参数/配置文件解析。
  2. 日志模块：基于 spdlog 框架封装的模块直接使用进行日志输出。
  3. 服务注册模块：基于 etcd 框架封装的注册模块直接使用进行消息转发服务的服务注册。
  4. 数据库数据操作模块：基于 odb-mysql 数据管理封装的模块，从数据库获取会话成员。
  5. 服务发现与调用模块：基于etcd框架与 brpc 框架封装的服务发现与调用模块，从用户子服务获取消息发送者的用户信息。
  6. rpc 服务模块：基于 brpc 框架搭建 rpc 服务器。
  7. MQ 发布模块：基于rabbitmq-client封装的模块将消息发布到消息队列，让消息存储子服务进行消费，对消息进行存储。

功能模块示意图：

接口实现流程

获取消息转发目标与消息处理

  1. 从请求中取出消息内容，会话 ID， 用户 ID
  2. 根据用户ID从用户子服务获取当前发送者用户信息
  3. 根据消息内容构造完成的消息结构（分配消息 ID，填充发送者信息，填充消息产生时间）
  4. 将消息序列化后发布到 MQ 消息队列中，让消息存储子服务对消息进行持久化存储
  5. 从数据库获取目标会话所有成员 ID
  6. 组织响应（完整消息+目标用户 ID），发送给网关，告知网关该将消息发送谁。

映射文件:

chat_session_member.hxx

cpp 复制代码 
// 聊天会话成员表映射对象
#pragma once
#include <string>
#include <cstddef>
#include <odb/core.hxx>

namespace bite_im
{
#pragma db object table("chat_session_member")
    class ChatSessionMember
    {
    public:
        ChatSessionMember() {}
        ChatSessionMember(const std::string &ssid, const std::string &uid) : _session_id(ssid), _user_id(uid) {}
        ~ChatSessionMember() {}

        std::string session_id() const { return _session_id; }
        void session_id(std::string &ssid) { _session_id = ssid; }

        std::string user_id() const { return _user_id; }
        void user_id(std::string &uid) { _user_id = uid; }

    private:
        friend class odb::access;
#pragma db id auto
        unsigned long _id;
#pragma db type("varchar(64)") index
        std::string _session_id;
#pragma db type("varchar(64)")
        std::string _user_id;
    };
}

进入到mysql_test目录里面，将我们的odb映射文件先生成出来，并且导入到mysql的表里面。


data_mysql.hpp

cpp 复制代码 
#pragma once

#include "user.hxx"
#include "user-odb.hxx"
#include "logger.hpp"

#include "chat_session_member.hxx"
#include "chat_session_member-odb.hxx"

#include <string>
#include <memory>  // std::auto_ptr
#include <cstdlib> // std::exit
#include <iostream>
#include <odb/database.hxx>
#include <odb/mysql/database.hxx>

// 用户注册， 用户登录， 验证码获取， 手机号注册，手机号登录， 获取用户信息， 用户信息修改
// 用信息新增， 通过昵称获取用户信息，通过手机号获取用户信息， 通过用户ID获取用户信息， 通过多个用户ID获取多个用户信息，信息修改
namespace bite_im
{
    class ODBFactory
    {
    public:
        static std::shared_ptr<odb::core::database> create(
            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)
        {
            std::unique_ptr<odb::mysql::connection_pool_factory> cpf(
                new odb::mysql::connection_pool_factory(conn_pool_count, 0));
            auto res = std::make_shared<odb::mysql::database>(user, pswd,
                                                              db, host, port, "", cset, 0, std::move(cpf));
            return res;
        }
    };

    class UserTable
    {
    public:
        using ptr = std::shared_ptr<UserTable>;
        UserTable(const std::shared_ptr<odb::core::database> &db) : _db(db) {}
        bool insert(const std::shared_ptr<User> &user)
        {
            try
            {
                odb::transaction trans(_db->begin());
                _db->persist(*user);
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("新增用户失败 {}:{}！", user->nickname(), e.what());
                return false;
            }
            return true;
        }
        bool update(const std::shared_ptr<User> &user)
        {
            try
            {
                odb::transaction trans(_db->begin());
                _db->update(*user);
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("更新用户失败 {}:{}！", user->nickname(), e.what());
                return false;
            }
            return true;
        }
        // 通过昵称查询用户信息
        std::shared_ptr<User> select_by_nickname(const std::string &nickname) // 通过昵称查询
        {
            std::shared_ptr<User> res;
            try
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<User> query;
                typedef odb::result<User> result;
                res.reset(_db->query_one<User>(query::nickname == nickname));
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("通过昵称查询用户失败 {}:{}！", nickname, e.what());
            }
            return res;
        }
        std::shared_ptr<User> select_by_phone(const std::string &phone) // 通过手机号查询
        {
            std::shared_ptr<User> res;
            try
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<User> query;
                typedef odb::result<User> result;
                res.reset(_db->query_one<User>(query::phone == phone));
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("通过手机号查询用户失败 {}:{}！", phone, e.what());
            }
            return res;
        }
        std::shared_ptr<User> select_by_id(const std::string &user_id) // 通过用户id查询
        {
            std::shared_ptr<User> res;
            try
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<User> query;
                typedef odb::result<User> result;
                res.reset(_db->query_one<User>(query::user_id == user_id));
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("通过用户ID查询用户失败 {}:{}！", user_id, e.what());
            }
            return res;
        }
        // 多用户查询
        std::vector<User> select_multi_users(const std::vector<std::string> &id_list)
        {
            // select * from user where id in ('id1', 'id2', ...)
            if (id_list.empty())
            {
                return std::vector<User>();
            }
            std::vector<User> res;
            try
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<User> query;
                typedef odb::result<User> result;
                std::stringstream ss;
                ss << "user_id in (";
                for (const auto &id : id_list)
                {
                    ss << "'" << id << "',";
                }
                std::string condition = ss.str();
                condition.pop_back();
                condition += ")";
                result r(_db->query<User>(condition));
                for (result::iterator i(r.begin()); i != r.end(); ++i)
                {
                    res.push_back(*i);
                }
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("通过用户ID批量查询用户失败:{}！", e.what());
            }
            return res;
        }

    private:
        std::shared_ptr<odb::core::database> _db;
    };

    class ChatSessionMemeberTable
    {
    public:
        using ptr = std::shared_ptr<ChatSessionMemeberTable>;
        ChatSessionMemeberTable(const std::shared_ptr<odb::core::database> &db) : _db(db) {}
        // 单个会话成员的新增 --- ssid & uid
        bool append(ChatSessionMember &csm)
        {
            try
            {
                odb::transaction trans(_db->begin());
                _db->persist(csm);
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("新增单会话成员失败 {}-{}:{}！",
                          csm.session_id(), csm.user_id(), e.what());
                return false;
            }
            return true;
        }
        bool append(std::vector<ChatSessionMember> &csm_lists)
        {
            try
            {
                odb::transaction trans(_db->begin());
                for (auto &csm : csm_lists)
                {
                    _db->persist(csm);
                }
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("新增多会话成员失败 {}-{}:{}！",
                          csm_lists[0].session_id(), csm_lists.size(), e.what());
                return false;
            }
            return true;
        }
        // 删除指定会话中的指定成员 -- ssid & uid
        bool remove(ChatSessionMember &csm)
        {
            try
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<ChatSessionMember> query;
                typedef odb::result<ChatSessionMember> result;
                _db->erase_query<ChatSessionMember>(query::session_id == csm.session_id() &&
                                                    query::user_id == csm.user_id());
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("删除单会话成员失败 {}-{}:{}！",
                          csm.session_id(), csm.user_id(), e.what());
                return false;
            }
            return true;
        }
        // 删除会话的所有成员信息
        bool remove(const std::string &ssid)
        {
            try
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<ChatSessionMember> query;
                typedef odb::result<ChatSessionMember> result;
                _db->erase_query<ChatSessionMember>(query::session_id == ssid);
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("删除会话所有成员失败 {}:{}！", ssid, e.what());
                return false;
            }
            return true;
        }
        std::vector<std::string> members(const std::string &ssid)
        {
            std::vector<std::string> res;
            try
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<ChatSessionMember> query;
                typedef odb::result<ChatSessionMember> result;
                result r(_db->query<ChatSessionMember>(query::session_id == ssid));
                for (result::iterator i(r.begin()); i != r.end(); ++i)
                {
                    res.push_back(i->user_id());
                }
                trans.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("获取会话成员失败:{}-{}！", ssid, e.what());
            }
            return res;
        }

    private:
        std::shared_ptr<odb::core::database> _db;
    };
}

在mysql_test目录下新建main.cc
main.cc

cpp 复制代码 
#include "../../../common/data_mysql.hpp"
#include "../../../odb/chat_session_member.hxx"
#include "chat_session_member-odb.hxx"
#include <gflags/gflags.h>

DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");

void append_test(bite_im::ChatSessionMemeberTable &tb)
{
    bite_im::ChatSessionMember csm1("会话ID1", "用户ID1");
    tb.append(csm1);
    bite_im::ChatSessionMember csm2("会话ID1", "用户ID2");
    tb.append(csm2);
    bite_im::ChatSessionMember csm3("会话ID2", "用户ID3");
    tb.append(csm3);
}

void multi_append_test(bite_im::ChatSessionMemeberTable &tb)
{
    bite_im::ChatSessionMember csm1("会话ID3", "用户ID1");
    bite_im::ChatSessionMember csm2("会话ID3", "用户ID2");
    bite_im::ChatSessionMember csm3("会话ID3", "用户ID3");
    std::vector<bite_im::ChatSessionMember> list = {csm1, csm2, csm3};
    tb.append(list);
}

void remove_test(bite_im::ChatSessionMemeberTable &tb)
{
    bite_im::ChatSessionMember csm3("会话ID2", "用户ID3");
    tb.remove(csm3);
}

void ss_members(bite_im::ChatSessionMemeberTable &tb)
{
    auto res = tb.members("会话ID1");
    for (auto &id : res)
    {
        std::cout << id << std::endl;
    }
}
void remove_all(bite_im::ChatSessionMemeberTable &tb)
{
    tb.remove("会话ID3");
}

int main(int argc, char *argv[])
{
    google::ParseCommandLineFlags(&argc, &argv, true);
    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);

    auto db = bite_im::ODBFactory::create("root", "123456", "127.0.0.1", "bite_im", "utf8", 0, 1);

    bite_im::ChatSessionMemeberTable csmt(db);
    // append_test(csmt);
    //  multi_append_test(csmt);
    //  remove_test(csmt);
    //  ss_members(csmt);
    // remove_all(csmt);
    return 0;
}

编译运行:

添加用户:


删除指定会话成员

获取指定用户:

删除:

服务器的实现

transmite_server.cc

cpp 复制代码 
// 主要实现语音识别子服务的服务器的搭建
#include "transmite_server.hpp"

DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");

DEFINE_string(registry_host, "http://127.0.0.1:2379", "服务注册中心地址");
DEFINE_string(instance_name, "/transmite_service/instance", "当前实例名称");
DEFINE_string(access_host, "127.0.0.1:10004", "当前实例的外部访问地址");

DEFINE_int32(listen_port, 10004, "Rpc服务器监听端口");
DEFINE_int32(rpc_timeout, -1, "Rpc调用超时时间");
DEFINE_int32(rpc_threads, 1, "Rpc的IO线程数量");

DEFINE_string(base_service, "/service", "服务监控根目录");
DEFINE_string(user_service, "/service/user_service", "用户管理子服务名称");

DEFINE_string(mysql_host, "127.0.0.1", "Mysql服务器访问地址");
DEFINE_string(mysql_user, "root", "Mysql服务器访问用户名");
DEFINE_string(mysql_pswd, "123456", "Mysql服务器访问密码");
DEFINE_string(mysql_db, "bite_im", "Mysql默认库名称");
DEFINE_string(mysql_cset, "utf8", "Mysql客户端字符集");
DEFINE_int32(mysql_port, 0, "Mysql服务器访问端口");
DEFINE_int32(mysql_pool_count, 4, "Mysql连接池最大连接数量");

DEFINE_string(mq_user, "root", "消息队列服务器访问用户名");
DEFINE_string(mq_pswd, "123456", "消息队列服务器访问密码");
DEFINE_string(mq_host, "127.0.0.1:5672", "消息队列服务器访问地址");
DEFINE_string(mq_msg_exchange, "msg_exchange", "持久化消息的发布交换机名称");
DEFINE_string(mq_msg_queue, "msg_queue", "持久化消息的发布队列名称");
DEFINE_string(mq_msg_binding_key, "msg_queue", "持久化消息的发布队列名称");

int main(int argc, char *argv[])
{
    google::ParseCommandLineFlags(&argc, &argv, true);
    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);

    bite_im::TransmiteServerBuilder tsb;
    tsb.make_mq_object(FLAGS_mq_user, FLAGS_mq_pswd, FLAGS_mq_host,
                       FLAGS_mq_msg_exchange, FLAGS_mq_msg_queue, FLAGS_mq_msg_binding_key);
    tsb.make_mysql_object(FLAGS_mysql_user, FLAGS_mysql_pswd, FLAGS_mysql_host,
                          FLAGS_mysql_db, FLAGS_mysql_cset, FLAGS_mysql_port, FLAGS_mysql_pool_count);
    tsb.make_discovery_object(FLAGS_registry_host, FLAGS_base_service, FLAGS_user_service);
    tsb.make_rpc_server(FLAGS_listen_port, FLAGS_rpc_timeout, FLAGS_rpc_threads);
    tsb.make_registry_object(FLAGS_registry_host, FLAGS_base_service + FLAGS_instance_name, FLAGS_access_host);
    auto server = tsb.build();
    server->start();
    return 0;
}

transmite_server.hpp

cpp 复制代码 
// 实现语音识别子服务
#include <brpc/server.h>
#include <butil/logging.h>

#include "etcd.hpp"   // 服务注册模块封装
#include "logger.hpp" // 日志模块封装
#include "rabbitmq.hpp"
#include "channel.hpp"
#include "utils.hpp"
// #include "mysql_chat_session_member.hpp"
#include "data_mysql.hpp"

#include "base.pb.h"      // protobuf框架代码
#include "user.pb.h"      // protobuf框架代码
#include "transmite.pb.h" // protobuf框架代码

namespace bite_im
{
    class TransmiteServiceImpl : public bite_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 ::bite_im::NewMessageReq *request,
                               ::bite_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; // mq
    };

    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;                     // 服务注册客户端           // 服务注册客户端
        std::shared_ptr<odb::core::database> _mysql_client; // mysql数据库客户端
        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;                     // 服务注册客户端
        std::shared_ptr<odb::core::database> _mysql_client; // mysql数据库客户端
        std::shared_ptr<brpc::Server> _rpc_server;
    };
}

CMakeList.txt

cpp 复制代码 
# 1. 添加cmake版本说明
cmake_minimum_required(VERSION 3.1.3)
# 2. 声明工程名称
project(transmite_server)

set(target "transmite_server")

#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")

# 3. 检测并生成ODB框架代码
#   1. 添加所需的proto映射代码文件名称
set(proto_path ${CMAKE_CURRENT_SOURCE_DIR}/../proto)
set(proto_files base.proto user.proto transmite.proto)
#   2. 检测框架代码文件是否已经生成
set(proto_hxx "")
set(proto_cxx "")
set(proto_srcs "")
foreach(proto_file ${proto_files})
#   3. 如果没有生成，则预定义生成指令 -- 用于在构建项目之间先生成框架代码
    string(REPLACE ".proto" ".pb.cc" proto_cc ${proto_file})
    string(REPLACE ".proto" ".pb.h" proto_hh  ${proto_file})
    if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}${proto_cc})
        add_custom_command(
            PRE_BUILD
            COMMAND protoc
            ARGS --cpp_out=${CMAKE_CURRENT_BINARY_DIR} -I ${proto_path} --experimental_allow_proto3_optional ${proto_path}/${proto_file}
            DEPENDS ${proto_path}/${proto_file}
            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${proto_cc}
            COMMENT "生成Protobuf框架代码文件:" ${CMAKE_CURRENT_BINARY_DIR}/${proto_cc}
        )
    endif()
    list(APPEND proto_srcs ${CMAKE_CURRENT_BINARY_DIR}/${proto_cc})
endforeach()

# 3. 检测并生成ODB框架代码
#   1. 添加所需的odb映射代码文件名称
set(odb_path ${CMAKE_CURRENT_SOURCE_DIR}/../odb)
set(odb_files chat_session_member.hxx user.hxx)
#   2. 检测框架代码文件是否已经生成
set(odb_hxx "")
set(odb_cxx "")
set(odb_srcs "")
foreach(odb_file ${odb_files})
#   3. 如果没有生成，则预定义生成指令 -- 用于在构建项目之间先生成框架代码
    string(REPLACE ".hxx" "-odb.hxx" odb_hxx ${odb_file})
    string(REPLACE ".hxx" "-odb.cxx" odb_cxx ${odb_file})
    if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}${odb_cxx})
        add_custom_command(
            PRE_BUILD
            COMMAND odb
            ARGS -d mysql --std c++11 --generate-query --generate-schema --profile boost/date-time ${odb_path}/${odb_file}
            DEPENDS ${odb_path}/${odb_file}
            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${odb_cxx}
            COMMENT "生成ODB框架代码文件:" ${CMAKE_CURRENT_BINARY_DIR}/${odb_cxx}
        )
    endif()
#   4. 将所有生成的框架源码文件名称保存起来 student-odb.cxx classes-odb.cxx
    list(APPEND odb_srcs ${CMAKE_CURRENT_BINARY_DIR}/${odb_cxx})
endforeach()

# 4. 获取源码目录下的所有源码文件
set(src_files "")
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/source src_files)
# 5. 声明目标及依赖
add_executable(${target} ${src_files} ${proto_srcs} ${odb_srcs})
# 7. 设置需要连接的库
target_link_libraries(${target} -lgflags 
    -lspdlog -lfmt -lbrpc -lssl -lcrypto 
    -lprotobuf -lleveldb -letcd-cpp-api 
    -lcpprest -lcurl -lodb-mysql -lodb -lodb-boost
    -lamqpcpp -lev)


#set(trans_user_client "trans_user_client")
#set(trans_user_files ${CMAKE_CURRENT_SOURCE_DIR}/test/user_client.cc)
#add_executable(${trans_user_client} ${trans_user_files} ${proto_srcs})
#target_link_libraries(${trans_user_client} -pthread -lgtest -lgflags -lspdlog -lfmt -lbrpc -lssl -lcrypto -lprotobuf -lleveldb -letcd-cpp-api -lcpprest -lcurl /usr/lib/x86_64-linux-gnu/libjsoncpp.so.19)

#set(transmite_client "transmite_client")
#set(transmite_files ${CMAKE_CURRENT_SOURCE_DIR}/test/transmite_client.cc)
#add_executable(${transmite_client} ${transmite_files} ${proto_srcs})
#target_link_libraries(${transmite_client} -pthread -lgtest -lgflags -lspdlog -lfmt -lbrpc -lssl -lcrypto -lprotobuf -lleveldb -letcd-cpp-api -lcpprest -lcurl /usr/lib/x86_64-linux-gnu/libjsoncpp.so.19)


# 6. 设置头文件默认搜索路径
include_directories(${CMAKE_CURRENT_BINARY_DIR})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../common)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../odb)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../third/include)

#8. 设置安装路径
INSTALL(TARGETS ${target} ${trans_user_client} ${transmite_client} RUNTIME DESTINATION bin)

编译：

服务器测试

transmite_client.hpp

cpp 复制代码 
#include "etcd.hpp"
#include "channel.hpp"
#include "utils.hpp"
#include <gflags/gflags.h>
#include <gtest/gtest.h>
#include <thread>
#include "transmite.pb.h"

DEFINE_bool(run_mode, false, "程序的运行模式，false-调试； true-发布；");
DEFINE_string(log_file, "", "发布模式下，用于指定日志的输出文件");
DEFINE_int32(log_level, 0, "发布模式下，用于指定日志输出等级");

DEFINE_string(etcd_host, "http://127.0.0.1:2379", "服务注册中心地址");
DEFINE_string(base_service, "/service", "服务监控根目录");
DEFINE_string(transmite_service, "/service/transmite_service", "服务监控根目录");

bite_im::ServiceManager::ptr sm;

int main(int argc, char *argv[])
{
    google::ParseCommandLineFlags(&argc, &argv, true);
    bite_im::init_logger(FLAGS_run_mode, FLAGS_log_file, FLAGS_log_level);

    // 1. 先构造Rpc信道管理对象
    sm = std::make_shared<bite_im::ServiceManager>();
    sm->declared(FLAGS_transmite_service);
    auto put_cb = std::bind(&bite_im::ServiceManager::onServiceOnline, sm.get(), std::placeholders::_1, std::placeholders::_2);
    auto del_cb = std::bind(&bite_im::ServiceManager::onServiceOffline, sm.get(), std::placeholders::_1, std::placeholders::_2);
    // 2. 构造服务发现对象
    bite_im::Discovery::ptr dclient = std::make_shared<bite_im::Discovery>(FLAGS_etcd_host, FLAGS_base_service, put_cb, del_cb);

    // 3. 通过Rpc信道管理对象，获取提供Echo服务的信道
    //  string_message("731f-50086884-0000", "会话ID1", "吃饭了吗？");
    //  string_message("c4dc-68239a9a-0001", "会话ID1", "吃的盖浇饭！！");
    //  image_message("731f-50086884-0000", "会话ID1", "可爱表情图片数据");
    //  speech_message("731f-50086884-0000", "会话ID1", "动听猪叫声数据");
    // file_message("731f-50086884-0000", "0d90-755571d8-0003", "猪爸爸的文件名称", "猪爸爸的文件数据");

    // 3. 通过Rpc信道管理对象，获取提供Echo服务的信道
    auto channel = sm->choose(FLAGS_transmite_service);
    if (!channel)
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return -1;
    }

    // 4. 发起EchoRpc调用
    bite_im::MsgTransmitService_Stub stub(channel.get());
    bite_im::NewMessageReq req;
    bite_im::GetTransmitTargetRsp rsp;
    req.set_request_id("消息转发请求测试ID1");
    req.set_user_id("111111");
    req.set_chat_session_id("会话ID1");
    req.mutable_message()->set_message_type(bite_im::MessageType::STRING);
    req.mutable_message()->mutable_string_message()->set_content("测试消息内容");

    brpc::Controller cntl;
    stub.GetTransmitTarget(&cntl, &req, &rsp, nullptr);
    if (cntl.Failed() == true)
    {
        std::cout << "Rpc调用失败：" << cntl.ErrorText() << std::endl;
        return -1;
    }
    if (rsp.success() == false)
    {
        std::cout << rsp.errmsg() << std::endl;
        return -1;
    }

    std::cout << "msg_id:" << rsp.message().message_id() << std::endl;
    std::cout << "chat_session_id:" << rsp.message().chat_session_id() << std::endl;
    std::cout << "timestamp" << rsp.message().timestamp() << std::endl;
    std::cout << "sender" << rsp.message().sender().user_id() << std::endl;
    std::cout << "message" << rsp.message().message().string_message().content() << std::endl;
    for (int i = 0; i < rsp.target_id_list_size(); i++)
    {
        std::cout << "target:" << rsp.target_id_list(i) << std::endl;
    }
    return 0;
}

先编译:

sql 复制代码 
update chat_session_member set user_id='a83b-2d93ce70-0000' where id=1;
update chat_session_member set user_id='1882-74802db0-0001' where id=2;

注意，这里我们是要启动我们的文件子服务，用户管理子服务，以及消息转发管理子服务都要启动！

这里我们带飞消息转发子服务就实现完毕了！

相关推荐
尘觉1 小时前
OpenClaw 入门：本地 AI 助手架构、功能与使用场景说明（2026-3月最新版）
人工智能·架构·openclaw
前端不太难1 小时前
从小项目到大型鸿蒙 App 的架构变化
架构·状态模式·harmonyos
Nile4 小时前
解密openclaw底层pi-mono架构系列一：5. pi-web-ui
前端·ui·架构
2501_948114245 小时前
星链4SAPI + OpenClaw实战：给GPT-5.4与Claude 4.6装上“职业传送门”
python·gpt·架构
架构师沉默5 小时前
为什么很多大厂 API 不再使用 PUT 和 DELETE？
java·后端·架构
qq_454245035 小时前
AI模块化工作流的基石：三要素双向生成与可信存储机制
人工智能·架构
祥哥的说5 小时前
万字深度解析 OpenClaw 架构：为什么它能成为全球最火的开源 AI Agent？
人工智能·架构·开源·openclaw
cyber_两只龙宝5 小时前
【MySQL】MySQL主从复制架构
linux·运维·数据库·mysql·云原生·架构
切糕师学AI6 小时前
Kubernetes 中的 Informer 机制
云原生·容器·kubernetes·informer
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03本地部署 OpenClaw + DeepSeek-R1 完全指南04Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南05OpenClaw 飞书机器人不回复消息？3 小时踩坑总结06得物前端部门，没了07OpenClaw macOS 完整安装与本地模型配置教程（实战版）08Window 10部署openclaw报错node.exe : npm error code 12809OpenClaw 连接飞书完整指南：插件安装、配置与踩坑记录10OpenClaw 接入 QQ Bot 完整实践指南