仿RabbitMq实现简易消息队列正式篇（连接篇）

于 2024-08-15 18:18:32 发布
阅读量311 收藏 4
点赞数 2
文章标签： rabbitmq c++ 分布式 C++ 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62812354/article/details/141224015
版权

连接关系着客户端和服务端，所以这里分别介绍这个项目的客户端与服务端之间的连接

请求回应设计

syntax = "proto3";
package mymq;

import "msg.proto";

//信道的打开与关闭
message openChannelRequest{
    string rid = 1;
    string cid = 2;
};
message closeChannelRequest{
    string rid = 1;
    string cid = 2;
};
//交换机的声明与删除
message declareExchangeRequest{
    string rid = 1;
    string cid = 2;
    string exchange_name = 3;
    ExchangeType exchange_type = 4;
    bool durable = 5;
    bool auto_delete = 6;
    map<string, string> args = 7;
};
message deleteExchangeRequest{
    string rid = 1;
    string cid = 2;
    string exchange_name = 3;
};
//队列的声明与删除
message declareQueueRequest{
    string rid = 1; 
    string cid = 2;
    string queue_name = 3;
    bool exclusive = 4;
    bool durable = 5;
    bool auto_delete = 6;
    map<string, string> args = 7;
};
message deleteQueueRequest{
    string rid = 1;  
    string cid = 2;
    string queue_name = 3;
};
//队列的绑定与解除绑定
message queueBindRequest{
    string rid = 1;
    string cid = 2;
    string exchange_name = 3;
    string queue_name = 4;
    string binding_key = 5;
};
message queueUnBindRequest{
    string rid = 1;
    string cid = 2;
    string exchange_name = 3;
    string queue_name = 4;
};
//消息的发布
message basicPublishRequest {
    string rid = 1;
    string cid = 2;
    string exchange_name = 3;
    string body = 4;
    BasicProperties properties = 5;
};
//消息的确认
message basicAckRequest {
    string rid = 1;
    string cid = 2;
    string queue_name = 3;
    string message_id = 4;
};
//队列的订阅
message basicConsumeRequest {
    string rid = 1;
    string cid = 2;
    string consumer_tag = 3;
    string queue_name = 4;
    bool auto_ack = 5;
};
//订阅的取消
message basicCancelRequest {
    string rid = 1;
    string cid = 2;
    string consumer_tag = 3;
    string queue_name = 4;
};
//消息的推送
message basicConsumeResponse {
    string cid = 1;
    string consumer_tag = 2;
    string body = 3;
    BasicProperties properties = 4;
};
//通用响应
message basicCommonResponse {
    string rid = 1;
    string cid = 2;
    bool ok = 3;
}

服务端

通过上面的请求与回应的设计，我们在客户端和服务端在进行消息交换的时候，直接解析和封装响应的报文即可。

信道

信道是网络通信中的一个概念，叫做通信通道

网络通信的时候，必然都是通过网络通信连接来完成的，为了能够更加充分的利用资源，因此对通信连接又进行了进一步的细化，细化出了通信通道。

对于用户来说，一个通信通道就是进行网络通信的载体，而一个真正的通信连接，可以创建出多个通信通道。

每一个信道之间，在用户的眼里是相互独立的，而本质上，他们使用同一个通信连接进行网络通信。

因此，因为信道是用户眼里的一个通信通道，所以所有网络通信服务都是由信道提供的。

信道提供的服务操作

  • 声明 / 删除 交换机
  • 声明 / 删除 队列
  • 绑定 / 解绑 队列和交换机
  • 发布消息/订阅队列消息/取消队列订阅/队列消息确认

信道要管理的数据：

  • 信道ID
  • 信道关联的虚拟机句柄：
  • 工作线程句柄：信道进行了消费发布到指定队列操作后，从指定队列获取一个消费者，对这条消息进行消费。也就是将这条消息推送给一个客户端的操作交给线程池执行。并非每个信道都有一个线程池，而是整个服务器有一个线程池，大家所有的信道都是通过同一个线程池进行异步操作。

信道的管理：

  • 创建一个信道
  •  关闭一个信道
  •  获取指定信道句柄

代码展示

#ifndef __M_CHANNEL_H__
#define __M_CHANNEL_H__

#include "muduo/net/TcpConnection.h"
#include "muduo/proto/codec.h"
#include "muduo/proto/dispatcher.h"
#include "../mqcommon/logger.hpp"
#include "../mqcommon/helper.hpp"
#include "../mqcommon/mq_proto.pb.h"
#include "../mqcommon/msg.pb.h"
#include "../mqcommon/threadpool.hpp"
#include "mq_consumer.hpp"
#include "mq_host.hpp"
#include "mq_route.hpp"

namespace mymq
{
    using ProtobufCodecPtr = std::shared_ptr<ProtobufCodec>;
    using openChannelRequestPtr = std::shared_ptr<openChannelRequest>;
    using closeChannelRequestPtr = std::shared_ptr<closeChannelRequest>;
    using declareExchangeRequestPtr = std::shared_ptr<declareExchangeRequest>;
    using deleteExchangeRequestPtr = std::shared_ptr<deleteExchangeRequest>;
    using declareQueueRequestPtr = std::shared_ptr<declareQueueRequest>;
    using deleteQueueRequestPtr = std::shared_ptr<deleteQueueRequest>;
    using queueBindRequestPtr = std::shared_ptr<queueBindRequest>;
    using queueUnBindRequestPtr = std::shared_ptr<queueUnBindRequest>;
    using basicPublishRequestPtr = std::shared_ptr<basicPublishRequest>;
    using basicAckRequestPtr = std::shared_ptr<basicAckRequest>;
    using basicConsumeRequestPtr = std::shared_ptr<basicConsumeRequest>;
    using basicCancelRequestPtr = std::shared_ptr<basicCancelRequest>;
    using basicConsumeResponsePtr = std::shared_ptr<basicConsumeResponse>;
    
    class Channel
    {
    public:
        using ptr = std::shared_ptr<Channel>;
        Channel(const std::string& id, 
            const VirtualHost::ptr& host,
            const ConsumerManager::ptr& cmp,
            const ProtobufCodecPtr& codec,
            const muduo::net::TcpConnectionPtr &conn,
            const threadPool::ptr& pool)
            :_cid(id),
            _conn(conn),
            _codec(codec),
            _cmp(cmp),
            _host(host),
            _pool(pool)
        {
            DLOG("new Cannel: %p", this);
        }

        ~Channel()
        {
            if(_consumer.get() != nullptr)
            {
                _cmp->remove(_consumer->tag, _consumer->qname);
            }
            DLOG("del Channel : %p", this);
        }

        // 交换机的声明和删除
        void declareExchange(const declareExchangeRequestPtr& req)
        {
            bool ret = _host->declareExchange(req->exchange_name(),
                                                req->exchange_type(),
                                                req->durable(),
                                                req->auto_delete(),
                                                req->args());
            return basicResponse(ret, req->rid(), req->cid());
        }

        void deleteExchange(const deleteExchangeRequestPtr& req)
        {
            _host->deleteExchange(req->exchange_name());
            return basicResponse(true, req->rid(), req->cid());
        }

        // 队列的声明和删除
        void declareQueue(const declareQueueRequestPtr& req)
        {
            bool ret = _host->declareQueue(req->queue_name(),
                                                req->durable(),
                                                req->exclusive(),
                                                req->auto_delete(),
                                                 req->args());
            if (ret == false) {
                return basicResponse(false, req->rid(), req->cid());
            }
            _cmp->initQueueConsumer(req->queue_name());//初始化队列的消费者管理句柄
            return basicResponse(true, req->rid(), req->cid());
        }


        void deleteQueue(const deleteQueueRequestPtr& req)
        {
            _cmp->destroyQueueConsumer(req->queue_name());
            _host->deleteQueue(req->queue_name());
            return basicResponse(true, req->rid(), req->cid());
        }
        
        // 队列的绑定和解除绑定
        void queueBind(const queueBindRequestPtr& req)
        {
            bool ret = _host->bind(req->exchange_name(), 
                        req->queue_name(), 
                        req->binding_key());
            return basicResponse(ret, req->rid(), req->cid());
        }

        void queueUnBind(const queueUnBindRequestPtr& req)
        {
            _host->unBind(req->exchange_name(), req->queue_name());
            return basicResponse(true, req->rid(), req->cid());
        }

        // 消息的发布
        void basicPulish(const basicPublishRequestPtr& req)
        {
            // 1. 判断交换机是否存在
            auto ep = _host->selectExchange(req->exchange_name());
            if(ep.get() == nullptr)
            {
                return basicResponse(false, req->rid(), req->cid());
            }
            // 2. 进行交换路由，判断消息可以发布到交换机绑定的哪个队列中
            MsgQueueBindingMap mqpm = _host->exchangeBindings(req->exchange_name());
            BasicProperties* properties = nullptr;
            std::string routing_key;
            if(req->has_properties())
            {
                properties = req->mutable_properties();
                routing_key = properties->rounting_key();
            }
            for(auto& binding : mqpm)
            {
                if(Router::route(ep->type, routing_key, binding.second->binding_key))
                {
                    printf("%s:%d 匹配成功 %s - %s\n",__FILE__,__LINE__, routing_key.c_str(), binding.second->binding_key.c_str());
                    _host->basicPublish(binding.first, properties, req->body());
                    //  函数绑定
                    // 这里会调用
                    auto task = std::bind(&Channel::consume, this, binding.first);
                    _pool->push(task);
                }
            }
            printf("%s:%d 发布消息成功\n",__FILE__,__LINE__);
            return basicResponse(true, req->rid(), req->cid());
        }

        // 消息的确认
        void basicAck(const basicAckRequestPtr& req)
        {
            _host->basicAck(req->queue_name(), req->message_id());
            return basicResponse(true, req->rid(), req->cid());
        }

        // 订阅队列消息
        void basicConsume(const basicConsumeRequestPtr& req)
        {
            // 1. 判断队列是否存在
            bool ret = _host->existsQueue(req->queue_name());
            if(ret == false)
            {
                return basicResponse(false, req->rid(), req->cid());
            }
            // 2. 创建队列的消费者
            auto cb = std::bind(&Channel::callback, this, std::placeholders::_1, 
                                std::placeholders::_2, std::placeholders::_3);
            // 创建了消费者之后，当前的channel角色就是个消费者
            _consumer = _cmp->create(req->consumer_tag(), req->queue_name(), req->auto_ack(), cb);
            printf("%s:%d 创建消费者成功: %s\n",__FILE__,__LINE__, _consumer->qname.c_str());
            return basicResponse(true, req->rid(), req->cid());
        }
        // 取消订阅
        void basicCancel(const basicCancelRequestPtr& req)
        {
            _cmp->remove(req->consumer_tag(), req->queue_name());
            return basicResponse(true, req->rid(), req->cid());
        }
    private:
        void callback(const std::string tag, const BasicProperties* bp, const std::string & body)
        {
            // 针对参数组织出推送消息请求，将消息推送给channel对应的客户端
            basicConsumeResponse resp;
            resp.set_cid(_cid);
            resp.set_consumer_tag(tag);
            resp.set_body(body);
            if(bp)
            {
                resp.mutable_properties()->set_id(bp->id());
                resp.mutable_properties()->set_delivery_mode(bp->delivery_mode());
                resp.mutable_properties()->set_rounting_key(bp->rounting_key());
            }
            _codec->send(_conn, resp);
        }

        void consume(const std::string& qname)
        {
            // 指定队列消费消息
            // 1. 从队列中取出一个消息
            printf(" %s:%d  %s开始消费\n", __FILE__,__LINE__, qname.c_str());
            // 获取队首消息
            MessagePtr mp = _host->basicConsume(qname);
            //  不存在队首消息，说明消费者对应的消息队列不存在
            if(mp.get() == nullptr)
            {
                DLOG("执行消费任务失败，%s 队列不存在", qname.c_str());
                return ;
            }
            // 2. 从队列订阅者中取出一个订阅者
            // RR轮转
            Consumer::ptr cmp= _cmp->choose(qname);
            if(cmp.get() == nullptr)
            {
                DLOG("执行消费任务失败，%s 队列没有消费者", qname.c_str());
                return ;
            }
            // 3. 调用订阅者对应的消费者处理函数，实现消费的推送
            // 4. 这里是调用消费者对应的回调函数，回调函数的定义在客户端的订阅客户端中
            cmp->callback(cmp->tag, mp->mutable_payload()->mutable_properties(), mp->mutable_payload()->body());
            if(cmp->auto_ack)
                _host->basicAck(qname, mp->payload().properties().id());
        }

        void basicResponse(bool ok, const std::string& rid, const std::string& cid)
        {
            basicCommonResponse resp;
            resp.set_ok(ok);
            resp.set_rid(rid);
            resp.set_cid(cid);
            _codec->send(_conn, resp);
        }
    private:
        std::string _cid;
        Consumer::ptr _consumer;
        muduo::net::TcpConnectionPtr _conn;
        ProtobufCodecPtr _codec;
        ConsumerManager::ptr _cmp;
        VirtualHost::ptr _host;
        threadPool::ptr _pool;
    };

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

        bool openChannel(const std::string& id, const VirtualHost::ptr _host,
                        const ConsumerManager::ptr& cmp, const ProtobufCodecPtr& codec,
                        const muduo::net::TcpConnectionPtr& conn, const threadPool::ptr& pool)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _channels.find(id);
            if(it != _channels.end())
            {
                DLOG("信道：%s 已存在",id.c_str());
                return false;
            }
            auto channel = std::make_shared<Channel>(id, _host, cmp, codec, conn, pool);
            _channels.insert(std::make_pair(id, channel));
            return true;
        }

        void closeChannel(const std::string& id)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _channels.erase(id);
        }

        Channel::ptr getChannel(const std::string& id)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _channels.find(id);
            if(it == _channels.end())
            {
                return Channel::ptr(); 
            }
            return it->second;
        }
    private:
        std::mutex _mutex;
        std::unordered_map<std::string, Channel::ptr> _channels;
    };
}

#endif

连接

在网络通信模块中，我们使用muduo库来实现底层通信，muduo库中本身就有Connection连接的概念和对象类，但是我们的连接中，还有一个上层通信信道的概念，所以需要对这个Connection进行二次封装，形成我们自己的连接类，来适配上面的信道

管理的数据

  • muduo库的通信连接
  • 当前连接关联的信道管理句柄

连接提供的操作

  • 创建信道
  • 关闭信道
  • 获得信道
  • 报文回复

管理的操作

  • 新增连接
  • 关闭连接
  • 获取指定连接信息

代码展示

#include "mq_channel.hpp"

namespace mymq
{
    class Connection
    {
    public:
        using ptr = std::shared_ptr<Connection>;
        Connection(const VirtualHost::ptr& host, const ConsumerManager::ptr& cmp, 
                    const ProtobufCodecPtr& codec, const muduo::net::TcpConnectionPtr& conn, 
                    const threadPool::ptr& pool)
                    :_host(host),
                    _cmp(cmp),
                    _codec(codec),
                    _conn(conn),
                    _pool(pool),
                    _channels(std::make_shared<ChannelManager>())
        {}
        void openChannel(const openChannelRequestPtr& req)
        {
            // 1. 判断信道ID是否重复，创建信道
            bool ret = _channels->openChannel(req->cid(), _host, _cmp, _codec, _conn, _pool);
            if(ret == false)
            {
                DLOG("创建信道失败，信道 %s 已存在", req->cid().c_str());
                return basicResponse(false, req->rid(), req->cid());
            }
            DLOG("创建信道 %s 成功", req->cid().c_str());
            return basicResponse(true, req->rid(), req->cid());
        }

        void closeChannel(const closeChannelRequestPtr& req)
        {
            _channels->closeChannel(req->cid());
            return basicResponse(true, req->rid(), req->cid());
        }

        Channel::ptr getChannel(const std::string& id)
        {
            return _channels->getChannel(id);
        }
    private:
        void basicResponse(bool ok, const std::string& rid, const std::string& cid)
        {
            basicCommonResponse br;
            br.set_ok(ok);
            br.set_rid(rid);
            br.set_cid(cid);
            _codec->send(_conn, br);
        }
    private:
        muduo::net::TcpConnectionPtr _conn;
        ProtobufCodecPtr _codec;
        ConsumerManager::ptr _cmp;
        VirtualHost::ptr _host;
        threadPool::ptr _pool;
        ChannelManager::ptr _channels;
    };


    class ConnectionManager
    {
    public:
        using ptr = std::shared_ptr<ConnectionManager>;
        ConnectionManager()
        {}
        void newConnection(const VirtualHost::ptr& host, const ConsumerManager::ptr& cmp, 
                    const ProtobufCodecPtr& codec, const muduo::net::TcpConnectionPtr& conn, 
                    const threadPool::ptr& pool)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _conns.find(conn);
            if(it != _conns.end())
            {
                DLOG("连接已存在");
                return ;
            }
            Connection::ptr self_conn = std::make_shared<Connection>(host, cmp, codec, conn, pool);
            _conns.insert(make_pair(conn, self_conn));
        }

        void delConnection(const muduo::net::TcpConnectionPtr& conn)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _conns.erase(conn);
        }

        Connection::ptr getConnection(const muduo::net::TcpConnectionPtr& conn)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _conns.find(conn);
            if(it == _conns.end())
            {
                DLOG("未找到连接");
                return Connection::ptr();
            }
            return it->second;
        }
    private:
        std::mutex _mutex;
        std::unordered_map<muduo::net::TcpConnectionPtr, Connection::ptr> _conns;
    };
}

经理

一切都写好了，自然要给Connection外部加一层封装来实现对各个请求的响应。参考muduo库实现网络通信。

代码展示

#ifndef __M_BROKER_H__
#define __M_BROKER_H__

#include "muduo/proto/codec.h"
#include "muduo/proto/dispatcher.h"
#include "muduo/base/Logging.h"
#include "muduo/base/Mutex.h"
#include "muduo/net/EventLoop.h"
#include "muduo/net/TcpServer.h"
#include "../mqcommon/threadpool.hpp"
#include "../mqcommon/logger.hpp"
#include "../mqcommon/mq_proto.pb.h"
#include "../mqcommon/msg.pb.h"
#include "mq_connection.hpp"
#include "mq_channel.hpp"
#include "mq_host.hpp"

namespace mymq
{
#define DBFILE "/meta.db"
#define HOSTNAME " MyVirtualHost"
    class Server
    {
    public:
        typedef std::shared_ptr<google::protobuf::Message> MessagePtr;
        Server(int port, const std::string &basedir)
            : _server(&_baseloop, muduo::net::InetAddress("0.0.0.0", port),
                      "Server", muduo::net::TcpServer::kReusePort),
              _dispatcher(std::bind(&Server::onUnknownMessage, this, std::placeholders::_1,
                                    std::placeholders::_2, std::placeholders::_3)),
              _codec(std::make_shared<ProtobufCodec>(std::bind(&ProtobufDispatcher::onProtobufMessage,
                                                               &_dispatcher, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))),
              _virtual_host(std::make_shared<VirtualHost>(HOSTNAME, basedir, basedir + DBFILE)),
              _consumer_manager(std::make_shared<ConsumerManager>()),
              _connection_manager(std::make_shared<ConnectionManager>()),
              _pool(std::make_shared<threadPool>())
        {
            // 针对历史消息中的所有队列，别忘了，初始化队列的消费者管理结构
            QueueMap qm = _virtual_host->allqueue();
            for (auto &q : qm)
            {
                _consumer_manager->initQueueConsumer(q.first);
            }

            // 注册业务请求处理函数
            _dispatcher.registerMessageCallback<mymq::openChannelRequest>(std::bind(&Server::onOpenChannel, this,
                                                                                     std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::closeChannelRequest>(std::bind(&Server::onCloseChannel, this,
                                                                                      std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::declareExchangeRequest>(std::bind(&Server::onDeclareExchange, this,
                                                                                         std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::deleteExchangeRequest>(std::bind(&Server::onDeleteExchange, this,
                                                                                        std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::declareQueueRequest>(std::bind(&Server::onDeclareQueue, this,
                                                                                      std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::deleteQueueRequest>(std::bind(&Server::onDeleteQueue, this,
                                                                                     std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::queueBindRequest>(std::bind(&Server::onQueueBind, this,
                                                                                   std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::queueUnBindRequest>(std::bind(&Server::onQueueUnBind, this,
                                                                                     std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::basicPublishRequest>(std::bind(&Server::onBasicPublish, this,
                                                                                      std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::basicAckRequest>(std::bind(&Server::onBasicAck, this,
                                                                                  std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::basicConsumeRequest>(std::bind(&Server::onBasicConsume, this,
                                                                                      std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<mymq::basicCancelRequest>(std::bind(&Server::onBasicCancel, this,
                                                                                     std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
        
            _server.setMessageCallback(std::bind(&ProtobufCodec::onMessage, _codec.get(), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _server.setConnectionCallback(std::bind(&Server::onConnection, this, std::placeholders::_1));
        
        }

        void start()
        {
            _server.start();
            _baseloop.loop();
        }

    private:
        // 打开信道
        void onOpenChannel(const muduo::net::TcpConnectionPtr &conn, const openChannelRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("打开信道时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            return mconn->openChannel(message);
        }
        // 关闭信道
        void onCloseChannel(const muduo::net::TcpConnectionPtr &conn, const closeChannelRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("打开信道时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            return mconn->closeChannel(message);
        }
        // 声明交换机
        void onDeclareExchange(const muduo::net::TcpConnectionPtr &conn, const declareExchangeRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("声明交换机时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("声明交换机的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->declareExchange(message);
        }

        // 删除交换机
        void onDeleteExchange(const muduo::net::TcpConnectionPtr &conn, const deleteExchangeRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("删除交换机时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("删除交换机的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->deleteExchange(message);
        }
        // 声明队列
        void onDeclareQueue(const muduo::net::TcpConnectionPtr &conn, const declareQueueRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("声明队列时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("声明队列的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->declareQueue(message);
        }
        // 删除队列
        void onDeleteQueue(const muduo::net::TcpConnectionPtr &conn, const deleteQueueRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("删除队列时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("删除队列的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->deleteQueue(message);
        }
        // 队列绑定
        void onQueueBind(const muduo::net::TcpConnectionPtr &conn, const queueBindRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("队列绑定时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("队列绑定的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->queueBind(message);
        }
        // 队列解绑
        void onQueueUnBind(const muduo::net::TcpConnectionPtr &conn, const queueUnBindRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("队列解绑时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("队列解绑的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->queueUnBind(message);
        }
        // 消息发布
        void onBasicPublish(const muduo::net::TcpConnectionPtr &conn, const basicPublishRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("消息发布时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("消息发布的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->basicPulish(message);
        }
        // 消息确认
        void onBasicAck(const muduo::net::TcpConnectionPtr &conn, const basicAckRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("消息确认时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("消息确认的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->basicAck(message);
        }
        // 队列消息订阅
        void onBasicConsume(const muduo::net::TcpConnectionPtr &conn, const basicConsumeRequestPtr &message, muduo::Timestamp)
        {
            printf("%s:%d onBasicConsume begin\n",__FILE__,__LINE__);
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("队列消息订阅时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("队列消息订阅的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            printf("%s:%d onBasicConsume begin\n",__FILE__,__LINE__);
            return cnp->basicConsume(message);
        }
        // 队列消息取消订阅
        void onBasicCancel(const muduo::net::TcpConnectionPtr &conn, const basicCancelRequestPtr &message, muduo::Timestamp)
        {
            Connection::ptr mconn = _connection_manager->getConnection(conn);
            if (mconn == nullptr)
            {
                DLOG("队列消息取消订阅时，没有找到对应的Connection对象");
                conn->shutdown();
                return;
            }
            Channel::ptr cnp = mconn->getChannel(message->cid());
            if (cnp == nullptr)
            {
                DLOG("队列消息取消订阅的时候，没有找到相关信道");
                conn->shutdown();
                return;
            }
            return cnp->basicCancel(message);
        }
        // 未知消息
        void onUnknownMessage(const muduo::net::TcpConnectionPtr &conn, const MessagePtr &message, muduo::Timestamp)
        {
            LOG_INFO << "onUnknownMessage: " << message->GetTypeName();
            conn->shutdown();
        }

        // 连接
        void onConnection(const muduo::net::TcpConnectionPtr &conn)
        {
            if (conn->connected())
            {
                _connection_manager->newConnection(_virtual_host, _consumer_manager, _codec, conn, _pool);
            }
            else
            {
                _connection_manager->delConnection(conn);
            }
        }

    private:
        muduo::net::EventLoop _baseloop;
        muduo::net::TcpServer _server;  // 服务器对象
        ProtobufDispatcher _dispatcher; // 请求分发器对象 -- 要向其中注册请求处理函数
        ProtobufCodecPtr _codec;        // protobuf 协议处理器 -- 针对收到的请求数据进行protobuf协议处理
        VirtualHost::ptr _virtual_host;
        ConsumerManager::ptr _consumer_manager;
        ConnectionManager::ptr _connection_manager;
        threadPool::ptr _pool;
    };
}

#endif

客户端

同理，和服务端一样，客户端我们也是将具体的报文发送功能交给Channel, Connection只进行信道的打开和关闭，获取等相关操作.

信道

#ifndef __M_CHANNEL_H__
#define __M_CHANNEL_H__

#include "muduo/net/TcpConnection.h"
#include "muduo/proto/codec.h"
#include "muduo/proto/dispatcher.h"
#include "../mqcommon/logger.hpp"
#include "../mqcommon/helper.hpp"
#include "../mqcommon/msg.pb.h"
#include "../mqcommon/mq_proto.pb.h"
#include "mq_consumer.hpp"
#include <iostream>
#include <mutex>
#include <condition_variable>
#include <unordered_map>

namespace mymq
{
    typedef std::shared_ptr<google::protobuf::Message> MessagePtr;
    using ProtobufCodecPtr = std::shared_ptr<ProtobufCodec>;
    using basicCommonResponsePtr = std::shared_ptr<basicCommonResponse>;
    using basicConsumeResponsePtr = std::shared_ptr<basicConsumeResponse>;
    class Channel
    {
    public:
        using ptr = std::shared_ptr<Channel>;
        Channel(const muduo::net::TcpConnectionPtr &conn, const ProtobufCodecPtr &codec)
            : _cid(UUIDHelper::uuid()), _conn(conn), _codec(codec)
        {
        }

        ~Channel()
        {
            basicCancel();
        }

        std::string cid()
        {
            return _cid;
        }

        bool openChannel()
        {
            std::string rid = UUIDHelper::uuid();
            openChannelRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            _codec->send(_conn, req);
            basicCommonResponsePtr resp = waitResponse(rid);
            return resp->ok();
        }

        void closeChannel()
        {
            std::string rid = UUIDHelper::uuid();
            closeChannelRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            _codec->send(_conn, req);
            waitResponse(rid);
            return;
        }

        bool declareExchange(const std::string &ename, ExchangeType type,
                             bool durable, bool auto_delete, google::protobuf::Map<std::string, std::string> &args)
        {
            // 构建一个声明虚拟机的请求对象
            std::string rid = UUIDHelper::uuid();
            declareExchangeRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_exchange_name(ename);
            req.set_exchange_type(type);
            req.set_durable(durable);
            req.set_auto_delete(auto_delete);
            req.mutable_args()->swap(args);
            _codec->send(_conn, req);
            basicCommonResponsePtr resp = waitResponse(rid);
            return resp->ok();
        }

        void deleteExchange(const std::string ename)
        {
            // 构建一个声明虚拟机的请求对象
            std::string rid = UUIDHelper::uuid();
            deleteExchangeRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_exchange_name(ename);
            _codec->send(_conn, req);
            waitResponse(rid);
            return;
        }

        bool declareQueue(const std::string &qname, bool exclusive, bool durable,
                          bool auto_delete, google::protobuf::Map<std::string, std::string> &args)
        {
            std::string rid = UUIDHelper::uuid();
            declareQueueRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_queue_name(qname);
            req.set_durable(durable);
            req.set_auto_delete(auto_delete);
            req.set_exclusive(exclusive);
            req.mutable_args()->swap(args);
            _codec->send(_conn, req);
            basicCommonResponsePtr resp = waitResponse(rid);
            return resp->ok();
        }

        void deleteQueue(const std::string &qname)
        {
            std::string rid = UUIDHelper::uuid();
            deleteQueueRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_queue_name(qname);
            _codec->send(_conn, req);
            waitResponse(rid);
            return;
        }

        bool queueBind(
            const std::string &ename,
            const std::string &qname,
            const std::string &key)
        {
            std::string rid = UUIDHelper::uuid();
            queueBindRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_exchange_name(ename);
            req.set_queue_name(qname);
            req.set_binding_key(key);
            _codec->send(_conn, req);
            basicCommonResponsePtr resp = waitResponse(rid);
            return resp->ok();
        }
        void queueUnBind(const std::string &ename, const std::string &qname)
        {
            std::string rid = UUIDHelper::uuid();
            queueUnBindRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_exchange_name(ename);
            req.set_queue_name(qname);
            _codec->send(_conn, req);
            waitResponse(rid);
            return;
        }

        void basicPublish(
            const std::string &ename,
            const BasicProperties *bp,
            const std::string &body)
        {
            std::string rid = UUIDHelper::uuid();
            basicPublishRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_body(body);
            req.set_exchange_name(ename);
            if (bp != nullptr)
            {
                req.mutable_properties()->set_id(bp->id());
                req.mutable_properties()->set_delivery_mode(bp->delivery_mode());
                req.mutable_properties()->set_rounting_key(bp->rounting_key());
            }
            _codec->send(_conn, req);
            waitResponse(rid);
            return;
        }

        void basicAck(const std::string &msgid)
        {
            if (_consumer.get() == nullptr)
            {
                DLOG("消息确认时，找不到消费者信息！");
                return;
            }
            std::string rid = UUIDHelper::uuid();
            basicAckRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_queue_name(_consumer->qname);
            req.set_message_id(msgid);
            _codec->send(_conn, req);
            waitResponse(rid);
            return;
        }

        void basicCancel()
        {
            if(_consumer.get() == nullptr)
            {
                return ;
            }
            std::string rid = UUIDHelper::uuid();
            basicCancelRequest req;
            req.set_rid(rid);
            req.set_cid(_cid);
            req.set_consumer_tag(_consumer->tag);
            req.set_queue_name(_consumer->qname);
            _codec->send(_conn, req);
            waitResponse(rid);
            _consumer.reset();
            return ;
        }

        bool basicConsume(const std::string& consumer_tag, const std::string queue_name, 
                            bool auto_ack, const ConsumerCallback& cb)
        {
            if(_consumer.get() != nullptr)
            {
                DLOG("当前信道已订阅了其他消费者！");
                return false;
            }
            std::string rid = UUIDHelper::uuid();
                basicConsumeRequest req;
                req.set_rid(rid);
                req.set_cid(_cid);
                req.set_queue_name(queue_name);
                req.set_consumer_tag(consumer_tag);
                req.set_auto_ack(auto_ack);
                _codec->send(_conn, req);
                basicCommonResponsePtr resp =  waitResponse(rid);
                if (resp->ok() == false) {
                    DLOG("添加订阅失败！");
                    return false;
                }
                _consumer = std::make_shared<Consumer>(consumer_tag, queue_name, auto_ack, cb);
                return true;
        }

        // 连接收到基础响应后，向hash_map中添加响应
        void putBasicResponse(const basicCommonResponsePtr &resp)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _basic_resp.insert(std::make_pair(resp->rid(), resp));
            _cv.notify_all();
        }

        // 连接收到消息推送后，还需要通过信道找到对应的消费者对象，通过回调函数进行消息处理
        void consume(const basicConsumeResponsePtr &resp)
        {
            if(_consumer.get() == nullptr)
            {
                DLOG("消息处理时，未处理订阅者信息");
                return ;
            }
            if(_consumer->tag != resp->consumer_tag())
            {
                DLOG("收到的推送消息中的消费者标识，与当前信道消费者标识不一致");
                return ;
            }
            _consumer->callback(resp->consumer_tag(), resp->mutable_properties(), resp->body());
        }

    private:
        basicCommonResponsePtr waitResponse(const std::string &rid)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cv.wait(lock, [&rid, this](){
                return _basic_resp.find(rid) != _basic_resp.end();
            });
            basicCommonResponsePtr basic_ptr = _basic_resp[rid];
            _basic_resp.erase(rid);
            return basic_ptr;
        }

    private:
        muduo::net::TcpConnectionPtr _conn;
        std::string _cid;
        Consumer::ptr _consumer;
        ProtobufCodecPtr _codec;
        std::mutex _mutex;
        std::condition_variable _cv;
        std::unordered_map<std::string, basicCommonResponsePtr> _basic_resp;
    };


    class ChannelManager
    {
    public:
        using ptr = std::shared_ptr<ChannelManager>;
        ChannelManager()
        {}
        Channel::ptr create(const muduo::net::TcpConnectionPtr& conn, ProtobufCodecPtr& codec)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto channel = std::make_shared<Channel>(conn, codec);
            _channels.insert(std::make_pair(channel->cid(), channel));
            return channel;
        }

        void remove(const std::string& name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _channels.erase(name);
        }

        Channel::ptr get(const std::string& name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _channels.find(name);
            if(it == _channels.end())
            {
                DLOG("未找到对应的信道");
                return Channel::ptr();
            }
            return it->second;
        }
    private:
        std::mutex _mutex;
        std::unordered_map<std::string, Channel::ptr> _channels;
    };


}

#endif

连接

#ifndef __M_CONNECTION_H__
#define __M_CONNECTION_H__

#include "muduo/proto/dispatcher.h"
#include "muduo/proto/codec.h"
#include "muduo/base/Logging.h"
#include "muduo/base/Mutex.h"
#include "muduo/net/EventLoop.h"
#include "muduo/net/TcpClient.h"
#include "muduo/net/EventLoopThread.h"
#include "muduo/base/CountDownLatch.h"

#include "mq_channel.hpp"
#include "mq_worker.hpp"

namespace mymq
{
    class Connection
    {
    public:
        using ptr = std::shared_ptr<Connection>;
        Connection(const std::string &sip, int sport, const AsyncWorker::ptr &worker)
            : _latch(1),
              _client(worker->loopthread.startLoop(),
                      muduo::net::InetAddress(sip, sport), "Client"),
              _dispatcher(std::bind(&Connection::onUnknownMessage, this, std::placeholders::_1,
                                    std::placeholders::_2, std::placeholders::_3)),
              _codec(std::make_shared<ProtobufCodec>(std::bind(&ProtobufDispatcher::onProtobufMessage, &_dispatcher,
                                                               std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))),
              _worker(worker),
              _channel_manager(std::make_shared<ChannelManager>())
        {
            _dispatcher.registerMessageCallback<basicCommonResponse>(std::bind(&Connection::basicResponse, this,
                                                                         std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _dispatcher.registerMessageCallback<basicConsumeResponse>(std::bind(&Connection::ConsumeResponse, this,
                                                                           std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

            _client.setMessageCallback(std::bind(&ProtobufCodec::onMessage, _codec.get(),
                                                 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            _client.setConnectionCallback(std::bind(&Connection::onConnection, this, std::placeholders::_1));

            _client.connect();

            _latch.wait(); // 阻塞等待，直到连接建立成功
        }

        Channel::ptr openChannel()
        {
            Channel::ptr channel = _channel_manager->create(_conn, _codec);
            bool ret = channel->openChannel();
            if (ret == false)
            {
                DLOG("打开信道失败！");
                return Channel::ptr();
            }
            return channel;
        }

        void closeChannel(const Channel::ptr &channel)
        {
            channel->closeChannel();
            _channel_manager->remove(channel->cid());
        }

    private:
        void basicResponse(const muduo::net::TcpConnectionPtr &conn, const basicCommonResponsePtr &message, muduo::Timestamp)
        {
            // 1. 找到信道
            Channel::ptr channel = _channel_manager->get(message->cid());
            if (channel == nullptr)
            {
                DLOG("未找到信道消息");
                return;
            }
            // 2. 将得到的响应对象，添加到信道的基础响应hash_map中
            channel->putBasicResponse(message);
        }
        void ConsumeResponse(const muduo::net::TcpConnectionPtr &conn, const basicConsumeResponsePtr &message, muduo::Timestamp)
        {
            // 1. 找到信道
            Channel::ptr channel = _channel_manager->get(message->cid());
            if (channel == nullptr)
            {
                DLOG("未找到信道消息");
                return;
            }
            // 2. 封装异步任务（消息处理任务），抛入线程池
            _worker->pool.push([channel, message]()
                               { channel->consume(message); });
        }

        void onUnknownMessage(const muduo::net::TcpConnectionPtr &conn, const MessagePtr &message, muduo::Timestamp)
        {
            LOG_INFO << "onUnknownMessage: " << message->GetTypeName();
            conn->shutdown();
        }

        void onConnection(const muduo::net::TcpConnectionPtr &conn)
        {
            if (conn->connected())
            {
                _conn = conn;
                _latch.countDown();
            }
            else
            {
                // 连接关闭是的操作
                _conn.reset();
            }
        }

    private:
        muduo::CountDownLatch _latch;       // 实现同步的
        muduo::net::TcpConnectionPtr _conn; // 客户端对应的连接
        muduo::net::TcpClient _client;      // 客户端
        ProtobufDispatcher _dispatcher;     //请求分发器
        ProtobufCodecPtr _codec;            // 协议处理器

        AsyncWorker::ptr _worker;
        ChannelManager::ptr _channel_manager;
    };
}

#endif

疏 石 兰 兮
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用消息队列实现的简单聊天程序
05-31
7. **负载均衡与扩展性**：消息队列可以连接多个服务器，实现负载均衡，当系统负载增加时，只需增加服务器数量，而无需修改客户端代码。 8. **代码实现**：虽然没有提供具体的代码，但通常会使用消息队列的SDK或者...
springmvc+rabbitmq+websocket
07-31
在本项目中，"springmvc+rabbitmq+websocket" 是一个整合了Spring MVC、RabbitMQ消息队列和WebSocket技术的简易聊天应用。这个项目旨在展示如何将这三种技术有效地结合，实现一个实时的在线交流平台。以下是这些技术...
仿RabbitMq实现简易消息队列正式篇（消费者篇）
最新发布
m0_62812354的博客
08-15 144
TOC。
仿RabbitMq实现简易消息队列基础篇（Muduo库的使用）
m0_62812354的博客
08-13 850
Muduo由陈硕⼤佬开发，是⼀个基于⾮阻塞IO和事件驱动的C++⾼并发TCP⽹络编程库。一个线程只能有一个事件循环（EventLoop），用于相应计时器和IO时间一个文件描述符只能由一个线程进行读写，换句话说就是一个TCP连接必须归属某个EventLoop管理Buffer *,public:public:/// 当⼀个新连接建⽴成功的时候被调⽤/// 消息的业务处理回调函数---这是收到新连接消息的时候被调⽤的函数public:/// 无限循环。
仿RabbiteMq实现简易消息队列正式篇（需求分析）
m0_62812354的博客
08-14 703
TOC消息队列中间件是在分布式系统中重要的组件，主要解决等等问题。实现高性能，高可用，可伸缩和最终一致性架构，是大型分布式系统不可缺少的中间件。目前常用的消息队列是RabbitMq, KafKa,ZeroMq,MetaMq等。我们是仿照RabbitMq实现简易的消息队列，就得先了解RabbitMq，RabbitMq是一种开源消息中间件，使用Erlang语言进行开发，实现了高级消息队列协议（AMQP）
仿RabbitMQ实现消息队列
m0_73920844的博客
08-13 864
仿Rabbit MQ实现消息队列目录前言：本项目是仿照RabbitMQ并基于SpringBoot + Mybatis + SQLite3实现的消息队列，该项目实现了MQ的核心功能：生产者、消费者、中间人、发布、订阅等。一、核心概念二、模块划分三、创建核心实体类3.1 创建交换机（Exchange）3.2 创建队列实体类（MSGQueue）3.3 创建绑定实体类（Binding）3.4 创建消息实体类（Message）四、数据库操作五、封装对数据库的操作六、消息的存储设计6.1 设计思路及设定。
通过gin框架和mongoDB实现的简易即使通信系统.zip
08-03
在高并发场景下，可能会使用消息队列（如RabbitMQ或NATS）来处理消息的异步传递，避免服务器因处理大量并发请求而过载。消息队列可以暂时存储待处理的消息，然后按照一定的策略分发到工作进程，提高系统的响应速度和...
安卓Andriod源码——简易微信客户端和服务器源码.zip
10-13
3. **消息队列MQ**：如RabbitMQ、Kafka或ActiveMQ，用于异步处理消息发送，提高系统的并发处理能力。 4. **安全性**：使用HTTPS协议保证通信安全，同时对用户密码进行加密存储，防止数据泄露。 5. **负载均衡**：在...
安卓Android源码——简易微信客户端和服务器源码.zip
10-11
4. **消息队列**：如RabbitMQ，用于异步处理高并发的消息传递，提高系统性能。 5. **API设计**：遵循RESTful原则，定义清晰的接口供客户端调用。 通过分析和学习这个简易微信客户端和服务器源码，开发者可以提升对...
死信队列.
weixin_52449894的博客
08-12 285
死信”是指在RabbitMQ中那些因为某些原因无法被正常处理的消息。
RabbitMQ 核⼼概念
m0_75227031的博客
08-14 685
RocketMQ采⽤Java语⾔开发, 由阿⾥巴巴开源, 后捐赠给了Apache.它在设计时借鉴了Kafka，做出了⼀些⾃⼰的改进, ⻘出于蓝⽽胜于蓝, 经过多年双⼗⼀的洗礼, 在可⽤性、可靠性以及稳定性⽅⾯都有出⾊的表现. 适合对于可靠性⽐较⾼,且并发⽐较⼤的场景, ⽐如互联⽹⾦融. 但⽀持的客⼾端语⾔不多, 且社区活跃度⼀般。综合: 由于RabbitMQ的综合能⼒较强, 咱们这边的项⽬没有那么⼤的⾼并发, 且RabbitMQ社区⽐较成熟, 管理界⾯友好, 所以咱们接下来主要学习RabbitMQ的使⽤。
仿RabbitMq实现简易消息队列正式篇(路由匹配篇)
m0_62812354的博客
08-15 182
TOC。
RabbitMq如何确保消息不丢失
weixin_64122713的博客
08-08 1071
RabbitMq如何确保消息不丢失
RabbitMQ消息队列
link2417的博客
08-14 354
由Scala和Java编写，其特点其实很明显，就是仅仅提供较少的核心功能，但是提供超高的吞吐量，ms级的延迟，极高的可用性以及可靠性，而且分布式可以任意扩展。阿里出品，Java系开源项目，源代码可以直接阅读，可以定制自己公司的MQ，并且RocketMQ有阿里巴巴的实际业务场景的实战考验，RocketMQ社区活跃度相对较为一般，文档相对来说简单一些，接口这块不是按照标准JMS规范走的有些系统要迁移需要修改大量代码。消息体，根据不同通信协议定义的固定格式进行编码的数据包，来封装业务数据，实现消息的传输。
RabbitMQ 的介绍与使用
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
08-12 895
RabbitMQ 是一个消息代理：它接受和转发消息。您可以将其视为邮局：当您将要寄的邮件放入邮箱时，您可以确信信使最终会将邮件发送给您的收件人。在本例中，RabbitMQ 是邮箱、邮局和信使。RabbitMQ 与邮局的主要区别在于它不处理纸张，而是接受、存储和转发二进制数据块——消息。RabbitMQ 和一般意义上的消息传递使用了一些术语。生产仅仅意味着发送。发送消息的程序称为生产者队列是 RabbitMQ 中邮箱的名称。虽然消息会流经 RabbitMQ 和您的应用程序，但它们只能存储在。
RabbitMQ如何保证消息的可靠性
qq_53098873的博客
08-14 500
在消费端可以设置手动ACK模式，为确保消息可靠性，手动确认消息是否被正常处理，若存在异常或者未运行，则消息超时后不会被删除，会被重新投递或者进入死信队列。在发布消息时，可以将消息标记为持久化（persistent），这样消息就会被持久化存储到磁盘上面，即使RabbitMQ服务器重启，消息也不会丢失。启用confirm模式，在消费者发布消息后，由RabbitMQ服务器确认，确保消息正常路由到队列中并采取相应的重试策略。
第四章 RabbitMQ消息队列
Shandy_stark223的博客
08-14 336
可登陆管理控制台(启用management plugin的情况下)，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)可登陆管理控制台(启用management plugin的情况下)，可查看所有的信息，并且可以对用户，策略(policy)进行操作。可登陆管理控制台(启用management plugin的情况下), 同时可以对policy进行管理。仅可登陆管理控制台(启用management plugin的情况下)，无法看到节点信息，也无法对策略进行管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值