项目第九弹：信道管理模块

最新推荐文章于 2024-10-15 23:12:40 发布
最新推荐文章于 2024-10-15 23:12:40 发布
阅读量682 收藏 19
点赞数 14
分类专栏： 仿RabbitMQ实现消息队列 文章标签： 项目 rabbitmq 信道
wzs@版权
本文链接：https://blog.csdn.net/Wzs040810/article/details/140357821
版权

项目第九弹：信道管理模块

一、为何要有信道管理模块

是为了进行资源隔离：
通过利用线程独占栈空间来限制句柄资源的可见性，从而实现多线程之间的资源隔离，将同一个连接这个临界资源细分为信道这个非临界资源，从而在保证线程安全的情况下提高程序运行的并发效率

这样做还有其他的好处：

  1. 减少了TCP连接建立和销毁的开销，信道的创建与销毁更加轻量
    【就像是线程创建，销毁比进程的创建，销毁更加轻量】
  2. 迁就多线程的并发编程，提高并发编程的运行效率

二、信道管理模块的设计

1.信道模块的设计

上一弹我们完成了自定义应用层网络协议，下面就正式进入网络模块的设计

信道是具体提供对应服务的模块，而我们的服务：

  1. 声明/删除虚拟机
  2. 声明/删除交换机
  3. 声明/删除队列
  4. 绑定/解绑队列
  5. 订阅/取消订阅队列
  6. 发布/确认消息

因此，成员就需要有：

  1. 虚拟机管理模块句柄
  2. 消费者管理模块句柄

我们也说了，我们的项目是采用请求—响应模式
所以我们针对这12个请求都要进行处理，并且在处理之后要根据结果构建响应发送给对应的客户端

因此成员还需要有：

  1. TcpConnectionPtr
  2. ProtobufCodecPtr（这里保存句柄是因为我们会有多个信道，所以共用同一个ProtobufCodec即可，用shared_ptr共享一下提高效率。毕竟：勿以小优化而不为，勿以浪费资源而为之）

我们之前写的异步工作线程池也要用到，因为有些操作我们不想耽误当前的信道服务执行流
（老师傅将耗时，解耦任务交给学徒去干）
【比如：推送消息、消费消息这两个任务就是耗时，解耦的】

信道自身成员：

  1. 信道ID（信道自身的唯一标识，信道的句柄）
  2. 当前信道关联的消费者句柄（出于简化RabbitMQ，我们规定一个信道最多关联一个消费者）

信道模块要不要互斥锁呢？
不需要，因为下面三个句柄资源的内部都有互斥锁
ConsumerManager::ptr _consumer_manager_ptr;
VirtualHostManager::ptr _vhost_manager_ptr;
threadpool::ptr _pool_ptr;

1.为何要规定一个信道最多要关联一个消费者？

我们要从消息的发布与消费还有信道的问题来进行考虑：
在这里插入图片描述

2.信道管理模块的设计

增、删、查
接口：

  1. 声明/删除信道
  2. 获取指定信道

成员：
unordered_map<信道ID，信道::ptr> 哈希表
互斥锁

我们就提供这两个接口了，遵循KISS和YAGNI，至于其他的函数，都需要通过获取信道之后用信道句柄进行访问

Talk is cheap，Show me the code

三、信道管理模块的实现

1.信道模块的实现

1.前置工作

为了进行优化，提高效率，我们的参数类型都是Request的智能指针
所以需要定义12个Request（打开和关闭信道由连接模块负责）和1个ProtobufCodecPtr

using ProtobufCodecPtr = std::shared_ptr<ProtobufCodec>;

using DeclareVirtualHostRequestPtr = std::shared_ptr<DeclareVirtualHostRequest>;
using EraseVirtualHostRequestPtr = std::shared_ptr<EraseVirtualHostRequest>;

using DeclareExchangeRequestPtr = std::shared_ptr<DeclareExchangeRequest>;
using EraseExchangeRequestPtr = std::shared_ptr<EraseExchangeRequest>;

using DeclareMsgQueueRequestPtr = std::shared_ptr<DeclareMsgQueueRequest>;
using EraseMsgQueueRequestPtr = std::shared_ptr<EraseMsgQueueRequest>;

using BindRequestPtr = std::shared_ptr<BindRequest>;
using UnbindRequestPtr = std::shared_ptr<UnbindRequest>;

using BasicConsumeRequestPtr = std::shared_ptr<BasicConsumeRequest>;
using BasicCancelRequestPtr = std::shared_ptr<BasicCancelRequest>;

using BasicPublishRequestPtr = std::shared_ptr<BasicPublishRequest>;
using BasicAckRequestPtr = std::shared_ptr<BasicAckRequest>;

2.大框架

class Channel
{
public:
    using ptr = std::shared_ptr<Channel>;
    // 处理Channel自身相关联的消费者句柄_consumer无需显式初始化以外，其他都要初始化
    //_consumer默认初始化为空的shared_ptr
    Channel(const std::string &channel_id, const muduo::net::TcpConnectionPtr &conn, const ProtobufCodecPtr &codec,
            const ConsumerManager::ptr consumer_manager_ptr, const VirtualHostManager::ptr vhost_manager_ptr, threadpool::ptr pool_ptr);

    ~Channel();

    void declareVirtualHost(const DeclareVirtualHostRequestPtr &req);

    void eraseVirtualHost(const EraseVirtualHostRequestPtr &req);

    void declareExchange(const DeclareExchangeRequestPtr &req);
    
    void eraseExchange(const EraseExchangeRequestPtr &req);

    void declareMsgQueue(const DeclareMsgQueueRequestPtr &req);

    void eraseMsgQueue(const EraseMsgQueueRequestPtr &req);

    void bind(const BindRequestPtr &req);

    void unBind(const UnbindRequestPtr &req);

    void basicConsume(const BasicConsumeRequestPtr &req);
    

    // 正常情况下肯定是当前信道所关联的消费者才会调用取消订阅这个函数
    void basicCancel(const BasicCancelRequestPtr &req);

    void basicAck(const BasicAckRequestPtr &req);

    void basicPublish(const BasicPublishRequestPtr &req);

private:
    //  推送消息(取出消息,取出消费者,调用对应消费者的消费处理回调函数)
    void publishCallback(const std::string &vname, const std::string &qname);
	
	// 消费消息（构造BasicConsumeResponse，发送给对应的消费者）
    void consumeCallback(const std::string &consumer_tag, const BasicProperities *bp, const std::string &body);

	// 基础响应（构造BasicCommonResponse，发送给对应的消费者）
    void basicResponse(const std::string &req_id, const std::string &channel_id, bool ret);

    // channel自身成员
    std::string _channel_id;
    Consumer::ptr _consumer;

    // muduo    protobuf
    muduo::net::TcpConnectionPtr _conn; // muduo库底层网络通信连接
    ProtobufCodecPtr _codec;

    // 资源句柄
    ConsumerManager::ptr _consumer_manager_ptr;
    VirtualHostManager::ptr _vhost_manager_ptr;
    threadpool::ptr _pool_ptr;
};

下面我们一一实现：
其实总体步骤就一个：

  1. 进行操作
  2. 返回基础响应

3.构造与析构

构造的时候，就直接构造就行了，其他的啥也不用做（因为对应的事情早在那些对象刚创建的时候就做好了）

析构的时候，说明该信道已经关闭，那么该信道关联的消费者也需要移除了，因为我们规定，一个信道关联一个消费者，一个消费者也关联一个信道，它们是一个命运共同体

// 处理Channel自身相关联的消费者句柄_consumer无需显式初始化以外，其他都要初始化
//_consumer默认初始化为空的shared_ptr
Channel(const std::string &channel_id, const muduo::net::TcpConnectionPtr &conn, const ProtobufCodecPtr &codec,
        const ConsumerManager::ptr consumer_manager_ptr, const VirtualHostManager::ptr vhost_manager_ptr, threadpool::ptr pool_ptr)
    : _channel_id(channel_id), _conn(conn), _codec(codec), _consumer_manager_ptr(consumer_manager_ptr), _vhost_manager_ptr(vhost_manager_ptr), _pool_ptr(pool_ptr) {}

~Channel()
{
    // 信道被删除的时候,要删除该信道关联的消费者
    // 信道被删除的时候,要删除该信道关联的消费者
    if (_consumer.get() != nullptr)
    {
        _consumer_manager_ptr->removeConsumer(_consumer->_vhost_name, _consumer->_qname, _consumer->_consumer_tag);
        _consumer.reset();
    }
}

4.声明/删除虚拟机，basicResponse

void declareVirtualHost(const DeclareVirtualHostRequestPtr &req)
{
    // 1. 调用函数
    bool ret = _vhost_manager_ptr->declareVirtualHost(req->vhost_name(), req->dbfile(), req->basedir());
    // 2. 构建响应
    basicResponse(req->req_id(), req->channel_id(), ret);
}

void eraseVirtualHost(const EraseVirtualHostRequestPtr &req)
{
    // 1. 调用函数
    bool ret = _vhost_manager_ptr->eraseVirtualHost(req->vhost_name());
    // 2. 构建响应
    basicResponse(req->req_id(), req->channel_id(), ret);
}

void basicResponse(const std::string &req_id, const std::string &channel_id, bool ret)
{
    // 构建基础响应
    BasicCommonResponse resp;
    resp.set_req_id(req_id);
    resp.set_channel_id(channel_id);
    resp.set_ok(ret);
    // 直接传给codec
    // void send(const muduo::net::TcpConnectionPtr & conn, const google::protobuf::Message & message)
    _codec->send(_conn, resp);
}

5.声明/删除交换机

因为交换机的声明与删除只牵扯虚拟机内部的行为，而那些行为早已在虚拟机模块内部屏蔽掉了。
所以我们直接复用即可

void declareExchange(const DeclareExchangeRequestPtr &req)
{
    bool ret = _vhost_manager_ptr->declareExchange(req->vhost_name(), req->exchange_name(), req->type(), req->durable(), req->auto_delete(), req->args());
    basicResponse(req->req_id(), req->channel_id(), ret);
}

void eraseExchange(const EraseExchangeRequestPtr &req)
{
    bool ret = _vhost_manager_ptr->eraseExchange(req->vhost_name(), req->exchange_name());
    basicResponse(req->req_id(), req->channel_id(), ret);
}

6.声明/删除队列

队列的声明与删除不仅仅跟虚拟机模块有关，而且跟消费者管理模块有关，因此需要我们在信道这一层来进行额外操作：

即：初始化和销毁队列的消费者管理句柄

void declareMsgQueue(const DeclareMsgQueueRequestPtr &req)
{
    // 注意: 初始化队列的消费者管理句柄!!!!
    _consumer_manager_ptr->initQueueConsumerManager(req->vhost_name(), req->queue_name());
    bool ret = _vhost_manager_ptr->declareMsgQueue(req->vhost_name(), req->queue_name(), req->durable(), req->exclusive(),
                                                   req->auto_delete(), req->args());
    basicResponse(req->req_id(), req->channel_id(), ret);
}

void eraseMsgQueue(const EraseMsgQueueRequestPtr &req)
{
    // 注意: 销毁队列的消费者管理句柄
    _consumer_manager_ptr->destroyQueueConsumerManager(req->vhost_name(), req->queue_name());
    bool ret = _vhost_manager_ptr->eraseMsgQueue(req->vhost_name(), req->queue_name());
    basicResponse(req->req_id(), req->channel_id(), ret);
}

7.绑定/解绑队列

绑定和解绑也是只跟虚拟机模块有关，内部细节已经被屏蔽，我们直接复用即可

void bind(const BindRequestPtr &req)
{
    bool ret = _vhost_manager_ptr->bind(req->vhost_name(), req->exchange_name(), req->queue_name(), req->binding_key());
    basicResponse(req->req_id(), req->channel_id(), ret);
}

void unBind(const UnbindRequestPtr &req)
{
    bool ret = _vhost_manager_ptr->unBind(req->vhost_name(), req->exchange_name(), req->queue_name());
    basicResponse(req->req_id(), req->channel_id(), ret);
}

8.队列的订阅与取消订阅

1.取消订阅

正常情况下肯定是当前信道所关联的消费者才会调用取消订阅这个函数
所以别忘了_consumer.reset();

// 正常情况下肯定是当前信道所关联的消费者才会调用取消订阅这个函数
void basicCancel(const BasicCancelRequestPtr &req)
{
    bool ret = _consumer_manager_ptr->removeConsumer(req->vhost_name(), req->queue_name(), req->consumer_tag());
    _consumer.reset();
    basicResponse(req->req_id(), req->channel_id(), ret);
}
2.订阅

在这里插入图片描述
按照我们之前说的，这里需要实现并绑定一个消费处理回调函数

服务器的消费处理回调函数的任务就是：
构建基础消费响应，发送给该信道关联的消费者

void consumeCallback(const std::string &consumer_tag, const BasicProperities *bp, const std::string &body)
{
    // 构建基础消费响应,发给该信道关联的消费者
    BasicConsumeResponse resp;
    resp.set_consumer_tag(consumer_tag);
    if (bp != nullptr)
    {
        resp.mutable_properities()->set_msg_id(bp->msg_id());
        resp.mutable_properities()->set_mode(bp->mode());
        resp.mutable_properities()->set_routing_key(bp->routing_key());
    }
    resp.set_body(body);
    _codec->send(_conn, resp);
}

void basicConsume(const BasicConsumeRequestPtr &req)
{
    // 1. 看看当前信道有无关联什么消费者
    if (_consumer.get() != nullptr)
    {
    	default_error("当前信道的队列订阅失败，因为当前信道已经关联了消费者，信道ID：%s ，消费者tag：%s",_channel_id.c_str(),_consumer->_consumer_tag.c_str());
        basicResponse(req->req_id(), req->channel_id(), false);
        return;
    }
    // 2. 判断队列是否存在
    if(_vhost_manager_ptr->existMsgQueue(req->vhost_name(),req->queue_name()))
    {
    	default_error("当前信道的队列订阅失败，因为队列不存在，队列名：%s",req->queue_name().c_str());
        basicResponse(req->req_id(), req->channel_id(), false);
        return;
    }

   // 3. 创建消费者
    _consumer = _consumer_manager_ptr->createConsumer(req->vhost_name(), req->queue_name(), req->consumer_tag(),
                                                      ::std::bind(&Channel::consumeCallback, this, ::std::placeholders::_1, ::std::placeholders::_2, ::std::placeholders::_3), req->auto_ack());
    // 4. 返回响应
    basicResponse(req->req_id(), req->channel_id(), true);
}

这里设置回调函数就是将该消费者的消费回调处理函数与该消费者关联的信道相绑定,通过this指针绑定

9.消息的发布与确认

1.消息的确认

因为消息的确认只跟虚拟机模块有关，内部细节已被屏蔽，所以在信道视角来看直接复用即可

void basicAck(const BasicAckRequestPtr &req)
{
    bool ret = _vhost_manager_ptr->basicAck(req->vhost_name(), req->queue_name(), req->msg_id());
    basicResponse(req->req_id(), req->channel_id(), ret);
}
2.消息的发布

消息的发布涉及到：

  1. 虚拟机模块
  2. 路由匹配模块
  3. 信道模块当中实现的publishCallback函数
  4. 异步工作线程池

涉及到这4个模块，因此我们并没有在虚拟机模块来完成这个操作，二是放到了信道模块来完成这个操作

它的步骤：

  1. 拿到该交换机的类型
  2. 拿到该交换机的所有绑定信息
  3. 遍历对应的绑定信息，进行消息的路由匹配
  4. 若匹配，则继续第5步，沿着往下走
  5. 把消息放到对应匹配成功的队列
  6. 往异步线程池当中抛入一个消息消费任务,交给线程池中的线程去做,解放Channel线程去做更重要的任务
void basicPublish(const BasicPublishRequestPtr &req)
{
    // 1. 先找到该交换机的交换机类型
    Exchange::ptr ep = _vhost_manager_ptr->getExchange(req->vhost_name(), req->exchange_name());
    if (ep.get() == nullptr)
    {
    	default_error("发布消息失败，因为交换机不存在\n，交换机名称：%s",req->exchange_name().c_str());
        basicResponse(req->req_id(), req->channel_id(), false);
        return;
    }
    // 2. 先找到消息发布的交换机  绑定的所有队列
    MsgQueueBindingMap qmap = _vhost_manager_ptr->getAllBindingsByExchange(req->vhost_name(), req->exchange_name());
    // 3. 遍历所有队列,进行路由匹配与消息投递
    for (auto &kv : qmap)
    {
        Binding::ptr bp = kv.second;
        BasicProperities *properities = nullptr;
        std::string routing_key;

        if (req->has_properities())
        {
            properities = req->mutable_properities();
            routing_key = properities->routing_key();
        }
        if (Router::route(routing_key, bp->binding_key, ep->type))
        {
            // 4. 把消息投递到指定队列
            _vhost_manager_ptr->basicPublish(req->vhost_name(), bp->queue_name, properities, req->body());
            // 5. 向线程池添加一个消息消费任务,消费任务交给线程池中的线程去做,解放Channel线程去做更重要的任务
            _pool_ptr->put(std::bind(&Channel::publishCallback, this, req->vhost_name(), bp->queue_name));
        }
    }
    // 返回响应即可
    basicResponse(req->req_id(), req->channel_id(), true);
}
3.消息推送任务的回调
  1. 取出消息
  2. 拿到消费者
  3. 调用对应消费者的消费处理回调函数
  4. 如果消费者有自动确认标志,则进行自动确认
//  推送消息(取出消息,取出消费者,调用对应消费者的消费处理回调函数)
void publishCallback(const std::string &vname, const std::string &qname)
{
    // 1.取出消息
    MessagePtr mp = _vhost_manager_ptr->basicConsume(vname, qname);
    if (mp.get() == nullptr)
    {
    	default_info("消息的消费失败, 因为消息队列为空,没有消息: %s",qname.c_str());
        return;
    }
    // 2.取出消费者
    Consumer::ptr cp = _consumer_manager_ptr->selectConsumer(vname, qname);
    if (cp.get() == nullptr)
    {
    	default_info("该队列中暂无消费者,无法消费消息 %s",qname.c_str());
        return;
    }
    // 3.调用消费者的消费处理回调函数
    cp->_callback(cp->_consumer_tag, mp->mutable_valid()->mutable_properities(), mp->valid().body());
    // 4.如果消费者有自动确认标志,则进行自动确认
    if (cp->_auto_ack == true)
    {
        _vhost_manager_ptr->basicAck(vname, qname, mp->valid().properities().msg_id());
    }
}

10.完整代码

using ProtobufCodecPtr = std::shared_ptr<ProtobufCodec>;
using namespace ns_helper;
using namespace ns_proto;

using DeclareVirtualHostRequestPtr = std::shared_ptr<DeclareVirtualHostRequest>;
using EraseVirtualHostRequestPtr = std::shared_ptr<EraseVirtualHostRequest>;

using DeclareExchangeRequestPtr = std::shared_ptr<DeclareExchangeRequest>;
using EraseExchangeRequestPtr = std::shared_ptr<EraseExchangeRequest>;

using DeclareMsgQueueRequestPtr = std::shared_ptr<DeclareMsgQueueRequest>;
using EraseMsgQueueRequestPtr = std::shared_ptr<EraseMsgQueueRequest>;

using BindRequestPtr = std::shared_ptr<BindRequest>;
using UnbindRequestPtr = std::shared_ptr<UnbindRequest>;

using BasicConsumeRequestPtr = std::shared_ptr<BasicConsumeRequest>;
using BasicCancelRequestPtr = std::shared_ptr<BasicCancelRequest>;

using BasicPublishRequestPtr = std::shared_ptr<BasicPublishRequest>;
using BasicAckRequestPtr = std::shared_ptr<BasicAckRequest>;

class Channel
{
public:
    using ptr = std::shared_ptr<Channel>;
    // 处理Channel自身相关联的消费者句柄_consumer无需显式初始化以外，其他都要初始化
    //_consumer默认初始化为空的shared_ptr
    Channel(const std::string &channel_id, const muduo::net::TcpConnectionPtr &conn, const ProtobufCodecPtr &codec,
            const ConsumerManager::ptr consumer_manager_ptr, const VirtualHostManager::ptr vhost_manager_ptr, threadpool::ptr pool_ptr)
        : _channel_id(channel_id), _conn(conn), _codec(codec), _consumer_manager_ptr(consumer_manager_ptr), _vhost_manager_ptr(vhost_manager_ptr), _pool_ptr(pool_ptr) {}

    ~Channel()
    {
        // 信道被删除的时候,要删除该信道关联的消费者
        // 信道被删除的时候,要删除该信道关联的消费者
        if (_consumer.get() != nullptr)
        {
            _consumer_manager_ptr->removeConsumer(_consumer->_vhost_name, _consumer->_qname, _consumer->_consumer_tag);
            _consumer.reset();
        }
    }

    void declareVirtualHost(const DeclareVirtualHostRequestPtr &req)
    {
        // 1. 调用函数
        bool ret = _vhost_manager_ptr->declareVirtualHost(req->vhost_name(), req->dbfile(), req->basedir());
        // 2. 构建响应
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void eraseVirtualHost(const EraseVirtualHostRequestPtr &req)
    {
        // 1. 调用函数
        bool ret = _vhost_manager_ptr->eraseVirtualHost(req->vhost_name());
        // 2. 构建响应
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void declareExchange(const DeclareExchangeRequestPtr &req)
    {
        bool ret = _vhost_manager_ptr->declareExchange(req->vhost_name(), req->exchange_name(), req->type(), req->durable(), req->auto_delete(), req->args());
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void eraseExchange(const EraseExchangeRequestPtr &req)
    {
        bool ret = _vhost_manager_ptr->eraseExchange(req->vhost_name(), req->exchange_name());
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void declareMsgQueue(const DeclareMsgQueueRequestPtr &req)
	{
	    // 注意: 初始化队列的消费者管理句柄!!!!
	    _consumer_manager_ptr->initQueueConsumerManager(req->vhost_name(), req->queue_name());
	    bool ret = _vhost_manager_ptr->declareMsgQueue(req->vhost_name(), req->queue_name(), req->durable(), req->exclusive(),
	                                                   req->auto_delete(), req->args());
	    basicResponse(req->req_id(), req->channel_id(), ret);
	}
	
	void eraseMsgQueue(const EraseMsgQueueRequestPtr &req)
	{
	    // 注意: 销毁队列的消费者管理句柄
	    _consumer_manager_ptr->destroyQueueConsumerManager(req->vhost_name(), req->queue_name());
	    bool ret = _vhost_manager_ptr->eraseMsgQueue(req->vhost_name(), req->queue_name());
	    basicResponse(req->req_id(), req->channel_id(), ret);
	}

    void bind(const BindRequestPtr &req)
    {
        bool ret = _vhost_manager_ptr->bind(req->vhost_name(), req->exchange_name(), req->queue_name(), req->binding_key());
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void unBind(const UnbindRequestPtr &req)
    {
        bool ret = _vhost_manager_ptr->unBind(req->vhost_name(), req->exchange_name(), req->queue_name());
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void basicConsume(const BasicConsumeRequestPtr &req)
    {
        // 1. 看看当前信道有无关联什么消费者
        if (_consumer.get() != nullptr)
        {
        	default_error("当前信道的队列订阅失败，因为当前信道已经关联了消费者，信道ID：%s ，消费者tag：%s",_channel_id.c_str(),_consumer->_consumer_tag.c_str());
            basicResponse(req->req_id(), req->channel_id(), false);
            return;
        }
        // 2. 判断队列是否存在
        if(_vhost_manager_ptr->existMsgQueue(req->vhost_name(),req->queue_name()))
        {
        	default_error("当前信道的队列订阅失败，因为队列不存在，队列名：%s",req->queue_name().c_str());
            basicResponse(req->req_id(), req->channel_id(), false);
            return;
        }

        // 3. 创建消费者
        _consumer = _consumer_manager_ptr->createConsumer(req->vhost_name(),req->queue_name(), req->consumer_tag(),
                                                          std::bind(&Channel::consumeCallback, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3), req->auto_ack());
        // 4. 返回响应
        basicResponse(req->req_id(), req->channel_id(), true);
    }

    // 正常情况下肯定是当前信道所关联的消费者才会调用取消订阅这个函数
    void basicCancel(const BasicCancelRequestPtr &req)
    {
        bool ret = _consumer_manager_ptr->removeConsumer(req->vhost_name(), req->queue_name(), req->consumer_tag());
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void basicAck(const BasicAckRequestPtr &req)
    {
        bool ret = _vhost_manager_ptr->basicAck(req->vhost_name(), req->queue_name(), req->msg_id());
        basicResponse(req->req_id(), req->channel_id(), ret);
    }

    void basicPublish(const BasicPublishRequestPtr &req)
    {
        // 1. 先找到该交换机的交换机类型
        Exchange::ptr ep = _vhost_manager_ptr->getExchange(req->vhost_name(), req->exchange_name());
        if (ep.get() == nullptr)
        {
        	default_error("发布消息失败，因为交换机不存在\n，交换机名称：%s",req->exchange_name().c_str());
            basicResponse(req->req_id(), req->channel_id(), false);
            return;
        }
        // 2. 先找到消息发布的交换机  绑定的所有队列
        MsgQueueBindingMap qmap = _vhost_manager_ptr->getAllBindingsByExchange(req->vhost_name(), req->exchange_name());
        // 3. 遍历所有队列,进行路由匹配与消息投递
        for (auto &kv : qmap)
        {
            Binding::ptr bp = kv.second;
            BasicProperities *properities = nullptr;
            std::string routing_key;

            if (req->has_properities())
            {
                properities = req->mutable_properities();
                routing_key = properities->routing_key();
            }
            if (Router::route(routing_key, bp->binding_key, ep->type))
            {
                // 把消息投递到指定队列
                _vhost_manager_ptr->basicPublish(req->vhost_name(), bp->queue_name, properities, req->body());
                // 5. 向线程池添加一个消息消费任务,消费任务交给线程池中的线程去做,解放Channel线程去做更重要的任务
                _pool_ptr->put(std::bind(&Channel::publishCallback, this, req->vhost_name(), bp->queue_name));
            }
        }
        // 返回响应即可
        basicResponse(req->req_id(), req->channel_id(), true);
    }

private:
    //  推送消息(取出消息,取出消费者,调用对应消费者的消费处理回调函数)
    void publishCallback(const std::string &vname, const std::string &qname)
    {
        // 1.取出消息
        MessagePtr mp = _vhost_manager_ptr->basicConsume(vname, qname);
        if (mp.get() == nullptr)
        {
        	default_info("消息的消费失败, 因为消息队列为空,没有消息: %s",qname.c_str());
            return;
        }
        // 2.取出消费者
        Consumer::ptr cp = _consumer_manager_ptr->selectConsumer(vname, qname);
        if (cp.get() == nullptr)
        {
        	default_info("该队列中暂无消费者,无法消费消息 %s",qname.c_str());
            return;
        }
        // 3.调用消费者的消费处理回调函数
        cp->_callback(cp->_consumer_tag, mp->mutable_valid()->mutable_properities(), mp->valid().body());
        // 4.如果消费者有自动确认标志,则进行自动确认
        if (cp->_auto_ack == true)
        {
            _vhost_manager_ptr->basicAck(vname, qname, mp->valid().properities().msg_id());
        }
    }

    void consumeCallback(const std::string &consumer_tag, const BasicProperities *bp, const std::string &body)
    {
        // 构建基础消费响应,发给该信道关联的消费者
        BasicConsumeResponse resp;
        resp.set_consumer_tag(consumer_tag);
        if (bp != nullptr)
        {
            resp.mutable_properities()->set_msg_id(bp->msg_id());
            resp.mutable_properities()->set_mode(bp->mode());
            resp.mutable_properities()->set_routing_key(bp->routing_key());
        }
        resp.set_body(body);
        _codec->send(_conn, resp);
    }

    void basicResponse(const std::string &req_id, const std::string &channel_id, bool ret)
    {
        // 构建基础响应
        BasicCommonResponse resp;
        resp.set_req_id(req_id);
        resp.set_channel_id(channel_id);
        resp.set_ok(ret);
        // 直接传给codec
        // void send(const muduo::net::TcpConnectionPtr & conn, const google::protobuf::Message & message)
        _codec->send(_conn, resp);
    }

    // channel自身成员
    std::string _channel_id;
    Consumer::ptr _consumer;

    // muduo    protobuf
    muduo::net::TcpConnectionPtr _conn; // muduo库底层网络通信连接
    ProtobufCodecPtr _codec;

    // 资源句柄
    ConsumerManager::ptr _consumer_manager_ptr;
    VirtualHostManager::ptr _vhost_manager_ptr;
    threadpool::ptr _pool_ptr;
};

2.信道管理模块实现

1.要不要给basicResponse函数？

不给，因为我们的信道上面还有连接，我们在连接层给声明和删除信道的响应
换言之，这一层只负责干活，不负责交差
【仅负责执行具体任务，不负责任务成果的交付】
不负责处理具体Request

2.完整代码

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

    void OpenChannel(const std::string &channel_id, const muduo::net::TcpConnectionPtr &conn, const ProtobufCodecPtr &codec,
                     const ConsumerManager::ptr &consumer_manager_ptr, const VirtualHostManager::ptr &vhost_manager_ptr, const threadpool::ptr &pool_ptr)
    {
        std::unique_lock<std::mutex> ulock(_mutex);
        if (_channel_map.count(channel_id))
            return;

        Channel::ptr cp = std::make_shared<Channel>(channel_id, conn, codec, consumer_manager_ptr, vhost_manager_ptr, pool_ptr);
        _channel_map.insert(std::make_pair(channel_id, cp));
    }

    void CloseChannel(const std::string &channel_id)
    {
        std::unique_lock<std::mutex> ulock(_mutex);
        _channel_map.erase(channel_id);
    }

    Channel::ptr getChannel(const std::string &channel_id)
    {
        std::unique_lock<std::mutex> ulock(_mutex);
        auto iter = _channel_map.find(channel_id);
        if (iter == _channel_map.end())
        {
            return Channel::ptr();
        }
        return iter->second;
    }

private:
    std::mutex _mutex;
    std::unordered_map<std::string, Channel::ptr> _channel_map;
};

以上就是项目第九弹：信道管理模块的全部内容

program-learner
关注
专栏目录
EB-Propsim-C8_2.3.rar_EB propsim_eb信道
09-20
EB-C8信道仿真仪是EB公司推出的一款高级通信系统模拟和测试工具，主要用于无线通信领域的信道建模与仿真。这款仿真仪可以帮助研发人员理解并分析不同通信环境下的信号传输特性，从而优化通信系统的性能。在“EB ...
Client客户端模块
lzf的博客
08-31 477
Client客户端模块
Channel信道管理模块
lzf的博客
08-22 658
Channel信道模块的实现
基于RabbitMQ原理的分布式消息队列系统
start_fall的博客
09-02 1076
​RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。异步处理无需即时返回且耗时的操作，提高系统吞吐量。解耦生产者和消费者，提高系统灵活性。实现分布式系统的集成。RabbitMQ实际上是实现了一个基于AMQP的生产者消费者模型。解耦合。并发处理。支持忙闲不均。削谷填峰等。在实际的后端开发中，尤其是分布式系统里，跨主机之间使用生产者消费者模型，也是很普遍的需求。因此我们以AMQP为核心封装一个独立的服务器程序。
仿RabbitMQ实现消息队列服务端（二）
weixin_74461263的博客
10-04 1171
在RabbitMQ中,虚拟主机是可以随意创建/删除的，但是咱们此处为了实现简单,并没有实现虚拟主机的管理，因此我们默认就只有⼀个虚拟主机的存在，但是在数据结构的设计上我们预留了对于多虚拟主机的管理，从⽽保证不同虚拟主机中的Exchange、Queue、Binding、Message等资源都是相互隔离的。具体通信的过程我们使⽤Muduo库来实现，使⽤TCP作为通信的底层协议，同时在这个基础上⾃定义应⽤层协议，完成客⼾端对服务器功能的远端调⽤。使⽤⼆进制的⽅式设计应⽤层协议。
rabbitMq------信道管理模块
2301_77412625的博客
10-02 1124
信道是在通信连接上更细粒度的一个划分，也就是一个通信连接上可以由多个信道，这些信道都是复用的同一条连接，为了充分利用资源。在用户眼中没有了网络通信的概念了，相当于信道他屏蔽了底层的网络通信细节。用户只需要使用信道提供的服务，不需要关心底层的网络通信细节。在用户眼中信道和信道就是完全独立的。这个信道管理是服务端的信道管理，而在客户端也会有一个信道，客户端的信道和服务端的信道是一一对应的。
详解MATLAB Simulink通信系统建模与仿真 随书源码-第4章信道.rar
10-14
第9 章 OFDM 系统仿真 9.1 OFDM 基本原理 9.2 基于OFDM 的802.11a 系统 9.3 IEEE 802.11a 系统的仿真 第10 章 CDMA 系统仿真 10.1 扩频通信基本原理 10.2 扩频码序列 10.3 直接序列扩频通信系统仿真 10.4 ...
串口wifi模块 第三代串口wifi模块使用技巧
07-13
安装配置卡驱动后，设置配置软件的“信道”为自动，搜索模块即可完成配置。 3. **加快启动速度**：在WPA/WPA2-PSK(TKIP/CCMP)安全模式下，使用十六进制格式的PMK代替ASCII格式的密钥，可以显著减少模块启动时间。 4....
详解MATLAB Simulink通信系统建模与仿真 随书源码-第8章信道编码和交织.rar
10-14
第9 章 OFDM 系统仿真 9.1 OFDM 基本原理 9.2 基于OFDM 的802.11a 系统 9.3 IEEE 802.11a 系统的仿真 第10 章 CDMA 系统仿真 10.1 扩频通信基本原理 10.2 扩频码序列 10.3 直接序列扩频通信系统仿真 10.4 ...
RFID技术中的解决LTE手机射频信道衰落测试方案
11-03
3GPP（第三代合作伙伴计划）在TS 36.521-1标准中定义了衡量LTE手机衰落特性的具体要求，以确保设备在各种复杂环境下的性能。 传统的衰落测试方法依赖于外部衰落模拟器和噪声源，通过这些设备来改变射频信号。这种...
仿RabbitMQ实现消息队列客户端
weixin_74461263的博客
10-04 1460
在RabbitMQ中，提供服务的是信道，因此在客⼾端的实现中，弱化了Client客⼾端的概念，也就是说在RabbitMQ中并不会向⽤⼾展⽰⽹络通信的概念出来，⽽是以⼀种提供服务的形式来体现。同样的，客⼾端也有信道，其功能与服务端⼏乎⼀致，或者说不管是客⼾端的channel还是服务端的channel都是为了⽤⼾提供具体服务⽽存在的，只不过服务端是为客⼾端的对应请求提供服务，⽽客⼾端的接⼝服务是为了⽤⼾具体需要服务，也可以理解是⽤⼾通过客⼾端channel的接⼝调⽤来向服务端发送对应请求，获取请求的服务。
如何解决MQ的重复消费问题？Kafka、ActiveMQ、RabbitMQ有什么区别？
weixin_53180424的博客
10-13 1152
如何解决MQ的重复消费问题？MQ（消息队列）的重复消费问题是一个需要认真对待的挑战，因为它可能导致业务逻辑的重复执行，进而引发数据不一致或其他问题。
尚硅谷rabbitmq2024介绍和工作模式 第4-9节 答疑
2401_86733530的博客
10-13 1168
如果 `consumer-A` 和 `consumer-B` 都属于 `group-1`，那么 Kafka 会自动将 `partition-0` 分配给 `consumer-A`，将 `partition-1` 分配给 `consumer-B`。假设你有一个Kafka主题 `my-topic`，它有两个分区 `partition-0` 和 `partition-1`，你有两个消费者 `consumer-A` 和 `consumer-B`，它们都属于同一个消费者组 `group-1`。
RabbitMQ 实际运用
最新发布
qq_56438516的博客
10-15 995
RabbitMQ 是一款广泛使用的消息中间件，它基于 AMQP（高级消息队列协议）构建，支持多种消息协议和开发语言。在实际应用中，RabbitMQ 可以解决多种复杂的业务场景，包括但不限于异步处理、应用解耦、流量削峰、分布式事务和消息分发等。
尚硅谷rabbitmq2024 工作模式发布订阅模式 第10节答疑
2401_86733530的博客
10-14 921
如果 `consumer-A` 和 `consumer-B` 都属于 `group-1`，那么 Kafka 会自动将 `partition-0` 分配给 `consumer-A`，将 `partition-1` 分配给 `consumer-B`。假设你有一个Kafka主题 `my-topic`，它有两个分区 `partition-0` 和 `partition-1`，你有两个消费者 `consumer-A` 和 `consumer-B`，它们都属于同一个消费者组 `group-1`。
RabbitMQ
weixin_44929475的博客
10-15 828
RabbitMQ是一个开源的消息代理和队列服务器，它提供了一个可靠的消息传递服务，适用于多种场景，包括但不限于异步处理、应用解耦、流量控制和提高消息系统的可靠性。RabbitMQ遵循AMQP（Advanced Message Queuing Protocol）协议，同时也支持其他消息协议，如STOMP、MQTT等。
尚硅谷rabbitmq 2024 Federation配置 第60节答疑
2401_86733530的博客
10-13 937
通过以上步骤，你就可以在 RabbitMQ 中设置联邦队列，实现不同 RabbitMQ 实例之间的消息共享和分布式处理。- 你可以点击 `Create Shovel` 按钮，输入名称 `new_shovel`，配置源和目标 RabbitMQ 服务器、队列或交换机，然后点击 `Save` 创建新的 Shovel。你说得对，`"federation-upstream-set":"all"` 和 `"federation-upstream":"upstream-name"` 是不同的配置方式。
尚硅谷rabbitmq 2024 Federation创建upstream连接点 第57节答疑
2401_86733530的博客
10-12 1209
假设你有两个 RabbitMQ 节点：`rabbit1` 和 `rabbit2`，你希望将 `rabbit1` 上的交换机 `source_exchange` 的消息路由到 `rabbit2` 上的交换机 `destination_exchange`。假设你有两个 RabbitMQ 节点：`rabbit1` 和 `rabbit2`，你希望将 `rabbit1` 上的交换机 `source_exchange` 的消息路由到 `rabbit2` 上的交换机 `destination_exchange`。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

program-learner

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

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

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

打赏作者

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

抵扣说明：

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

余额充值