C++微服务架构下的好友管理子服务设计与实现

2. 关键接口字段解析（以好友申请为例）

（1）FriendAdd：发送好友申请

message FriendAddReq {
  string request_id = 1;      // 链路追踪ID（分布式调用唯一标识）
  string user_id = 2;         // 申请人ID（当前登录用户）
  string respondent_id = 3;   // 被申请人ID（目标用户）
}

message FriendAddRsp {
  string request_id = 1;      // 对应请求ID
  bool success = 2;           // 申请是否成功
  string errmsg = 3;          // 错误信息（失败时填充）
  string notify_event_id = 4; // 申请事件ID（用于后续处理）
}

业务逻辑： 用户 A 申请加 B 为好友时，网关会先鉴权并填充 user_id（A 的 ID），服务端需校验：

1. A 和 B 是否已为好友（查 relation 表）；
2. A 是否已向 B 发送过申请（查 friend_apply 表）；
3. 校验通过后生成 notify_event_id（UUID），存入 friend_apply 表。

（2）FriendAddProcess：处理好友申请

message FriendAddProcessReq {
  string request_id = 1;      // 链路追踪ID
  string user_id = 2;         // 被申请人ID（当前登录用户）
  string apply_user_id = 3;   // 申请人ID（A的ID）
  bool agree = 4;             // 是否同意（true=同意，false=拒绝）
  string notify_event_id = 5; // 申请事件ID（对应FriendAdd返回的ID）
}

message FriendAddProcessRsp {
  string request_id = 1;      // 对应请求ID
  bool success = 2;           // 处理是否成功
  string errmsg = 3;          // 错误信息
  string new_session_id = 4;  // 同意时生成的单聊会话ID（网关推送用）
}

业务逻辑： 用户 B 处理 A 的申请时，服务端需：

1. 校验 notify_event_id 对应的申请是否存在；
2. 无论同意/拒绝，先删除申请事件（避免重复处理）；
3. 同意则创建双向好友关系（relation 表插两条记录）、单聊会话（chat_session 表）、会话成员（chat_session_member 表插 A 和 B 的记录）。

三、ODB 数据模型：映射业务对象与数据库表

好友服务的核心数据存储在 MySQL 中，通过 ODB（Object-Relational Mapping） 框架将 C++ 对象与数据库表关联，避免直接编写 SQL 语句，提升代码可维护性。

1. 核心表结构与 ODB 映射

2. ODB 映射类实现（以好友关系表为例）

// mysql_relation.hpp（ODB 映射类）
#pragma once
#include <odb/core.hxx>
#include <string>

namespace zrt {
// 好友关系实体类（对应 relation 表）
#pragma db object table("relation")
class Relation {
public:
    Relation() {}
    Relation(const std::string& user_id, const std::string& peer_id)
        : _user_id(user_id), _peer_id(peer_id) {}

    std::string user_id() const { return _user_id; }
    void user_id(const std::string& v) { _user_id = v; }
    std::string peer_id() const { return _peer_id; }
    void peer_id(const std::string& v) { _peer_id = v; }

private:
    friend class odb::access;
    #pragma db id auto // 自增主键
    unsigned long _id;
    #pragma db type("varchar(64)") index // 加索引，加速查询
    std::string _user_id; // 主动方用户ID
    #pragma db type("varchar(64)")
    std::string _peer_id; // 被动方用户ID
};

// ODB 表操作类（封装 CRUD）
class RelationTable {
public:
    using ptr = std::shared_ptr<RelationTable>;
    RelationTable(const std::shared_ptr<odb::core::database>& db) : _db(db) {}

    // 插入双向好友关系（A→B 和 B→A）
    bool insert(const std::string& user_id, const std::string& peer_id) {
        try {
            odb::transaction t(_db->begin());
            _db->persist(Relation(user_id, peer_id));
            _db->persist(Relation(peer_id, user_id));
            t.commit();
            return true;
        } catch (const odb::exception& e) {
            LOG_ERROR("Insert relation failed: {}", e.what());
            return false;
        }
    }

    // 检查好友关系是否存在
    bool exists(const std::string& user_id, const std::string& peer_id) {
        try {
            odb::transaction t(_db->begin());
            auto count = _db->query_value<Relation>(
                odb::query<Relation>::_user_id == user_id &&
                odb::query<Relation>::_peer_id == peer_id
            ).count();
            t.commit();
            return count > 0;
        } catch (const odb::exception& e) {
            LOG_ERROR("Check relation exists failed: {}", e.what());
            return false;
        }
    }
    // 其他方法：删除关系、查询用户的所有好友ID（省略）
private:
    std::shared_ptr<odb::core::database> _db;
};
} // namespace zrt

关键设计：

• 双向关系：插入好友时必须存两条记录（A→B 和 B→A），确保双方查询好友列表时都能找到对方；
• 事务保障：通过 ODB 的 transaction 确保'插入两条记录'要么全成功，要么全失败，避免数据不一致；
• 索引优化：_user_id 加索引，查询'用户的所有好友'时性能显著提升。

四、核心服务实现：从接口逻辑到服务协作

好友服务的核心逻辑封装在 FriendServiceImpl 类中，通过'接口实现+私有方法'的方式实现业务解耦与代码复用。

1. 服务初始化：依赖注入与解耦设计

FriendServiceImpl 的构造函数通过依赖注入（DI）传入所有外部依赖，避免硬编码，便于测试与扩展：

FriendServiceImpl(
    const std::shared_ptr<elasticlient::Client>& es_client,      // ES 客户端
    const std::shared_ptr<odb::core::database>& mysql_client,    // MySQL 客户端
    const ServiceManager::ptr& channel_manager,                  // RPC 信道管理器
    const std::string& user_service_name,                        // 用户服务名称
    const std::string& message_service_name                      // 消息服务名称
) : _es_user(std::make_shared<ESUser>(es_client)),
    _mysql_apply(std::make_shared<FriendApplyTable>(mysql_client)),
    _mysql_chat_session(std::make_shared<ChatSessionTable>(mysql_client)),
    _mysql_chat_session_member(std::make_shared<ChatSessionMemberTable>(mysql_client)),
    _mysql_relation(std::make_shared<RelationTable>(mysql_client)),
    _user_service_name(user_service_name),
    _message_service_name(message_service_name),
    _mm_channels(channel_manager) {}

解耦设计：

• 数据层解耦：通过 RelationTable/FriendApplyTable 封装 MySQL 操作，业务逻辑不直接依赖 ODB；
• 服务间解耦：通过 ServiceManager 管理其他服务的 RPC 信道，避免直接硬编码服务地址（服务地址变化时，只需更新 Etcd，无需改代码）。

2. 关键接口实现：以'处理好友申请'为例

FriendAddProcess 涉及'申请事件删除、好友关系创建、会话创建'三个关键步骤，需确保数据一致性：

void FriendServiceImpl::FriendAddProcess(
    ::google::protobuf::RpcController* controller,
    const ::zrt::FriendAddProcessReq* request,
    ::zrt::FriendAddProcessRsp* response,
    ::google::protobuf::Closure* done) {
    brpc::ClosureGuard rpc_guard(done); // 自动释放 Closure

    // 1. 定义错误回调
    auto err_response = [this, response](const std::string& rid, const std::string& errmsg) {
        response->set_request_id(rid);
        response->set_success(false);
        response->set_errmsg(errmsg);
    };

    // 2. 提取请求关键参数
    std::string rid = request->request_id();
    std::string eid = request->notify_event_id();
    std::string uid = request->user_id();         // 被申请人（B）
    std::string pid = request->apply_user_id();   // 申请人（A）
    bool agree = request->agree();

    // 3. 校验申请事件是否存在
    if (!_mysql_apply->exists(pid, uid)) {
        LOG_ERROR("{}-未找到{}-{}的好友申请事件", rid, pid, uid);
        return err_response(rid, "申请事件不存在");
    }

    // 4. 删除申请事件（无论同意/拒绝，事件都需清理）
    if (!_mysql_apply->remove(pid, uid)) {
        LOG_ERROR("{}-删除申请事件{}-{}失败", rid, pid, uid);
        return err_response(rid, "处理申请失败");
    }

    // 5. 同意：创建好友关系、单聊会话、会话成员
    std::string session_id;
    if (agree) {
        if (!_mysql_relation->insert(uid, pid)) {
            LOG_ERROR("{}-创建好友关系{}-{}失败", rid, uid, pid);
            return err_response(rid, "添加好友失败");
        }
        session_id = uuid(); // 生成全局唯一会话ID
        ChatSession session(session_id, "", ChatSessionType::SINGLE);
        if (!_mysql_chat_session->insert(session)) {
            LOG_ERROR("{}-创建单聊会话{}失败", rid, session_id);
            return err_response(rid, "创建会话失败");
        }
        std::vector<ChatSessionMember> members = {
            ChatSessionMember(session_id, uid),
            ChatSessionMember(session_id, pid)
        };
        if (!_mysql_chat_session_member->append(members)) {
            LOG_ERROR("{}-添加会话成员{}-{}失败", rid, uid, pid);
            return err_response(rid, "添加会话成员失败");
        }
    }

    // 6. 组织响应
    response->set_request_id(rid);
    response->set_success(true);
    response->set_new_session_id(session_id);
    LOG_INFO("{}-处理好友申请成功：{}→{}，agree={}", rid, pid, uid, agree);
}

关键逻辑亮点：

• 错误统一处理：通过 err_response 回调函数，确保所有错误场景的响应格式一致；
• 数据一致性：删除申请事件后再创建关系，避免'申请事件残留'；若创建会话失败，直接返回错误，后续可通过重试机制补全；
• 会话 ID 生成：使用 UUID 确保全局唯一，避免分布式环境下的 ID 冲突。

3. 服务间协作：调用用户服务与消息服务

好友服务本身不存储用户信息和消息数据，需通过 RPC 调用其他服务获取。

（1）调用用户服务批量获取用户信息

bool FriendServiceImpl::GetUserInfo(
    const std::string& rid,
    const std::unordered_set<std::string>& uid_list,
    std::unordered_map<std::string, UserInfo>& user_list) {
    auto channel = _mm_channels->choose(_user_service_name);
    if (!channel) {
        LOG_ERROR("{}-获取用户服务信道失败", rid);
        return false;
    }
    GetMultiUserInfoReq req;
    GetMultiUserInfoRsp rsp;
    req.set_request_id(rid);
    for (const auto& uid : uid_list) {
        req.add_users_id(uid); // 批量添加用户ID
    }
    brpc::Controller cntl;
    zrt::UserService_Stub stub(channel.get());
    stub.GetMultiUserInfo(&cntl, &req, &rsp, nullptr);
    if (cntl.Failed() || !rsp.success()) {
        LOG_ERROR("{}-批量获取用户信息失败", rid);
        return false;
    }
    for (const auto& item : rsp.users_info()) {
        user_list.emplace(item.first, item.second);
    }
    return true;
}

优化点：批量调用减少网络开销；ServiceManager 自动管理用户服务地址（从 Etcd 发现），服务扩缩容时无需重启。

（2）调用消息服务获取会话最新消息

bool FriendServiceImpl::GetRecentMsg(
    const std::string& rid,
    const std::string& session_id,
    MessageInfo& msg) {
    auto channel = _mm_channels->choose(_message_service_name);
    if (!channel) {
        LOG_ERROR("{}-获取消息服务信道失败", rid);
        return false;
    }
    GetRecentMsgReq req;
    GetRecentMsgRsp rsp;
    req.set_request_id(rid);
    req.set_chat_session_id(session_id);
    req.set_msg_count(1);
    brpc::Controller cntl;
    zrt::MsgStorageService_Stub stub(channel.get());
    stub.GetRecentMsg(&cntl, &req, &rsp, nullptr);
    if (cntl.Failed() || !rsp.success()) {
        LOG_WARN("{}-获取会话{}最新消息失败", rid, session_id);
        return false;
    }
    if (rsp.msg_list_size() > 0) {
        msg.CopyFrom(rsp.msg_list(0));
        return true;
    }
    return false;
}

业务价值：查询会话列表时显示'每条会话的最新消息'，符合微服务'数据私有'原则。

五、服务搭建与高可用部署

好友服务通过 FriendServerBuilder 模式封装初始化流程，支持'配置解析→依赖构建→服务启动'的一站式部署。

1. Builder 模式：简化服务初始化

class FriendServerBuilder {
public:
    void make_es_object(const std::vector<std::string>& host_list) {
        _es_client = ESClientFactory::create(host_list);
    }
    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,
                               const std::string& user_service_name, const std::string& message_service_name) {
        _mm_channels = std::make_shared<ServiceManager>();
        _mm_channels->declared(user_service_name);
        _mm_channels->declared(message_service_name);
        auto on_service_online = std::bind(&ServiceManager::onServiceOnline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
        auto on_service_offline = std::bind(&ServiceManager::onServiceOffline, _mm_channels.get(), std::placeholders::_1, std::placeholders::_2);
        _service_discoverer = std::make_shared<Discovery>(reg_host, base_service, on_service_online, on_service_offline);
    }
    void make_rpc_server(uint16_t port, int32_t timeout, uint8_t num_threads) {
        _rpc_server = std::make_shared<brpc::Server>();
        FriendServiceImpl* service = new FriendServiceImpl(_es_client, _mysql_client, _mm_channels, _user_service_name, _message_service_name);
        if (_rpc_server->AddService(service, brpc::ServiceOwnership::SERVER_OWNS_SERVICE) != 0) {
            LOG_ERROR("添加好友服务到 RPC 服务器失败");
            abort();
        }
        brpc::ServerOptions options;
        options.idle_timeout_sec = timeout;
        options.num_threads = num_threads;
        if (_rpc_server->Start(port, &options) != 0) {
            LOG_ERROR("RPC 服务器启动失败（端口：{}）", port);
            abort();
        }
    }
    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);
    }
    FriendServer::ptr build() {
        if (!_es_client || !_mysql_client || !_rpc_server) {
            LOG_ERROR("服务依赖未初始化完成");
            abort();
        }
        return std::make_shared<FriendServer>(_service_discoverer, _registry_client, _es_client, _mysql_client, _rpc_server);
    }
private:
    Registry::ptr _registry_client;
    std::shared_ptr<elasticlient::Client> _es_client;
    std::shared_ptr<odb::core::database> _mysql_client;
    ServiceManager::ptr _mm_channels;
    Discovery::ptr _service_discoverer;
    std::shared_ptr<brpc::Server> _rpc_server;
};

2. 部署入口：main 函数解析配置与启动

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

    zrt::FriendServerBuilder fsb;
    fsb.make_es_object({FLAGS_es_host});
    fsb.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);
    fsb.make_discovery_object(FLAGS_registry_host, FLAGS_base_service, FLAGS_user_service, FLAGS_message_service);
    fsb.make_rpc_server(FLAGS_listen_port, FLAGS_rpc_timeout, FLAGS_rpc_threads);
    fsb.make_registry_object(FLAGS_registry_host, FLAGS_base_service + FLAGS_instance_name, FLAGS_access_host);

    auto server = fsb.build();
    server->start();
    return 0;
}

部署关键参数：

• FLAGS_mysql_pool_count：MySQL 连接池大小（建议设为 CPU 核心数的 2~4 倍）；
• FLAGS_rpc_threads：brpc IO 线程数（通常设为 CPU 核心数）；
• FLAGS_access_host：服务对外访问地址（需与网关在同一网络）。

六、技术亮点与扩展方向

1. 核心技术亮点

• 解耦设计：通过 ServiceManager 管理 RPC 信道，服务地址变化只需更新 Etcd；数据层通过 ODB 封装，更换数据库不影响业务逻辑。
• 数据一致性保障：ODB 事务确保关键操作的原子性；UUID 确保分布式环境下的 ID 唯一性。
• 性能优化：批量 RPC 调用减少网络开销；ES 搜索过滤无效结果；MySQL 索引优化查询性能。
• 高可用设计：MySQL 连接池避免频繁连接；Etcd 实现服务动态发现与故障切换；spdlog 提供详细日志监控。

2. 后续扩展方向

• 好友备注功能：在 relation 表中添加 remark 字段；
• 黑名单功能：新增 blacklist 表，支持屏蔽非好友消息；
• 会话权限管理：群聊添加'管理员''禁言'功能，在 chat_session_member 表中添加 role 字段；
• 数据分片：用户量增大时，按 user_id 对 MySQL 表进行分片，避免单表数据量过大。

七、总结

好友管理子服务作为 IM 系统的核心组件，通过'Proto 接口定义规范通信、ODB 映射隔离数据层、ServiceManager 解耦服务协作、Builder 模式简化部署'，实现了一个高可用、可扩展的微服务。其设计思路不仅适用于 IM 系统，也可复用在社交、电商等需要'关系管理'的业务场景中。该服务在满足业务需求的同时，通过解耦与高可用设计确保了系统的稳定性与可维护性，为后续扩容与迭代奠定了坚实基础。