Connection连接管理模块

一.Connection模块介绍

二.Connection的定义

Connection 类的主要功能是管理每个客户端连接对应的信道操作，包括信道的打开、关闭和获取。这一类聚合了 ChannelManager、VirtualHost、ConsumerManager 等对象，通过这些对象来处理客户端的请求。

成员变量

class Connection
{
private:
    ChannelManager::ptr _channels;      // 信道管理器
    VirtualHost::ptr _vhost;            // 虚拟机的句柄
    ConsumerManager::ptr _cmp;          // 消费者管理器
    ProtobufCodecPtr _codec;            // Protobuf协议处理器,对收到的req数据进行协议处理
    muduo::net::TcpConnectionPtr _conn; // tcp连接
    ThreadPool::ptr _pool;              // 线程池

• _channels：ChannelManager 实例的共享指针，用于管理所有信道。
• _vhost：VirtualHost 实例的共享指针，用于处理虚拟主机相关操作。
• _cmp：ConsumerManager 实例的共享指针，用于管理消费者。
• _codec：ProtobufCodecPtr 用于处理消息的序列化与反序列化。
• _conn：muduo::net::TcpConnectionPtr 用于管理当前的 TCP 连接。
• _pool：ThreadPool::ptr 表示线程池的共享指针，用于处理并发任务。

这些成员变量将 Connection 类与消息队列系统中的核心组件绑定在一起，使其能够处理与特定客户端连接相关的所有操作。

构造析构函数

    using ptr = std::shared_ptr<Connection>;
        Connection() {}
        Connection(const ChannelManager::ptr &channels,
                   const VirtualHost::ptr &vhost,
                   const ConsumerManager::ptr &cmp,
                   const muduo::net::TcpConnectionPtr &conn,
                   const ProtobufCodecPtr &codec,
                   const ThreadPool::ptr &pool)
            : _channels(channels),
              _vhost(vhost),
              _cmp(cmp),
              _conn(conn),
              _codec(codec),
              _pool(pool)
        {
        }

信道的增删获取

         void openChannel(const mq::OpenChannelPtr &req)
        {
            bool ret = _channels->openChannel(req->chid(), _vhost, _cmp, _conn, _codec, _pool);
            if (!ret)
            {
                DLOG("openChannel failed %s already exists", req->chid().c_str());
                return basicCommonResponse(req->rid(), req->chid(), false);
            }
            return basicCommonResponse(req->rid(), req->chid(), true);
        }
        void closeChannel(const mq::CloseChannelReqPtr &req)
        {
            _channels->closeChannel(req->chid());
            return basicCommonResponse(req->rid(), req->chid(), true);
        }
        Channel::ptr getChannel(const std::string &chid)
        {
            return _channels->getChannel(chid);
        }

三.ConnectionManager的实现

ConnectionManager 类的主要功能是管理所有的 Connection 实例，它通过维护一个 unordered_map 容器，将 muduo::net::TcpConnectionPtr 与 Connection 实例相关联。

这是因为每个Connection内部的TcpConnection都是唯一的。

成员变量

• _connections：使用 std::unordered_map 存储 TCP 连接与 Connection 实例的映射关系。
• _mutex：用于保证对 _connections 容器的访问是线程安全的。

class ConnectionManager
{
private:
    std::unordered_map<muduo::net::TcpConnectionPtr, Connection::ptr> _connections;
    std::mutex _mutex;

连接的增删获取

    void addConnection(const ChannelManager::ptr &channels,
                           const VirtualHost::ptr &vhost,
                           const ConsumerManager::ptr &cmp,
                           const muduo::net::TcpConnectionPtr &conn,
                           const ProtobufCodecPtr &codec,
                           const ThreadPool::ptr &pool)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _connections.find(conn);
            if (it == _connections.end())
            {
                DLOG("addConnection: conn already exists %s", conn->name().c_str());
                return;
            }
            auto new_conn = std::make_shared<Connection>(channels, vhost, cmp, conn, codec, pool);
            _connections.emplace(conn, new_conn);
            DLOG("addConnection: conn %s", conn->name().c_str());
        }
        void removeConnection(const muduo::net::TcpConnectionPtr &ptr)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _connections.erase(ptr);
        }
        Connection::ptr getConnection(const muduo::net::TcpConnectionPtr &ptr)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _connections.find(ptr);
            if (it == _connections.end())
            {
                DLOG("getConnection: conn not exists %s", ptr->name().c_str());
                return Connection::ptr();
            }
            return it->second;
        }

四.全部代码

#pragma once
#include "channel.hpp"

namespace mq
{
    class Connection
    {
    private:
        ChannelManager::ptr _channels;      // 信道管理器
        VirtualHost::ptr _vhost;            // 虚拟机的句柄
        ConsumerManager::ptr _cmp;          // 消费者管理器
        ProtobufCodecPtr _codec;            // Protobuf协议处理器,对收到的req数据进行协议处理
        muduo::net::TcpConnectionPtr _conn; // tcp连接
        ThreadPool::ptr _pool;              // 线程池
    public:
        using ptr = std::shared_ptr<Connection>;
        Connection() {}
        Connection(const ChannelManager::ptr &channels,
                   const VirtualHost::ptr &vhost,
                   const ConsumerManager::ptr &cmp,
                   const muduo::net::TcpConnectionPtr &conn,
                   const ProtobufCodecPtr &codec,
                   const ThreadPool::ptr &pool)
            : _channels(channels),
              _vhost(vhost),
              _cmp(cmp),
              _conn(conn),
              _codec(codec),
              _pool(pool)
        {
        }

        void openChannel(const mq::OpenChannelPtr &req)
        {
            bool ret = _channels->openChannel(req->chid(), _vhost, _cmp, _conn, _codec, _pool);
            if (!ret)
            {
                DLOG("openChannel failed %s already exists", req->chid().c_str());
                return basicCommonResponse(req->rid(), req->chid(), false);
            }
            return basicCommonResponse(req->rid(), req->chid(), true);
        }
        void closeChannel(const mq::CloseChannelReqPtr &req)
        {
            _channels->closeChannel(req->chid());
            return basicCommonResponse(req->rid(), req->chid(), true);
        }
        Channel::ptr getChannel(const std::string &chid)
        {
            return _channels->getChannel(chid);
        }

    private:
        void basicCommonResponse(const std::string &rid, const std::string &chid, bool success)
        {
            msg::BasicCommonResponse resp;
            resp.set_rid(rid);
            resp.set_chid(chid);
            resp.set_success(success);
            return _codec->send(_conn, resp);
        }
    };

    class ConnectionManager
    {
    private:
        // muduo库中的tcp连接和connection的映射
        std::unordered_map<muduo::net::TcpConnectionPtr, Connection::ptr> _connections;
        std::mutex _mutex;

    public:
        using ptr = std::shared_ptr<ConnectionManager>;
        ConnectionManager() {}
        void addConnection(const ChannelManager::ptr &channels,
                           const VirtualHost::ptr &vhost,
                           const ConsumerManager::ptr &cmp,
                           const muduo::net::TcpConnectionPtr &conn,
                           const ProtobufCodecPtr &codec,
                           const ThreadPool::ptr &pool)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _connections.find(conn);
            if (it == _connections.end())
            {
                DLOG("addConnection: conn already exists %s", conn->name().c_str());
                return;
            }
            auto new_conn = std::make_shared<Connection>(channels, vhost, cmp, conn, codec, pool);
            _connections.emplace(conn, new_conn);
            DLOG("addConnection: conn %s", conn->name().c_str());
        }
        void removeConnection(const muduo::net::TcpConnectionPtr &ptr)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _connections.erase(ptr);
        }
        Connection::ptr getConnection(const muduo::net::TcpConnectionPtr &ptr)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _connections.find(ptr);
            if (it == _connections.end())
            {
                DLOG("getConnection: conn not exists %s", ptr->name().c_str());
                return Connection::ptr();
            }
            return it->second;
        }
    };
};