『功能项目』QFrameWork拾取道具UGUI【69】

文章目录

• 一.编写思路
• 二.代码实践

一.编写思路

二.代码实践

#pragma once
#include "Exchange.hpp"
#include "MsgQueue.hpp"
#include "Binding.hpp"
#include "Message.hpp"
#include "../common/Log.hpp"
#include <memory>
namespace ns_data
{
    using ExchangeManagerPtr = std::shared_ptr<ExchangeManager>;
    using MsgQueueManagerPtr = std::shared_ptr<MsgQueueManager>;
    using BindingManagerPtr = std::shared_ptr<BindingManager>;
    using MessageManagerPtr = std::shared_ptr<MessageManager>;

    class VirtualHost
    {
    private:
        ExchangeManagerPtr _exchangeManagerPtr;
        MsgQueueManagerPtr _msgQueueManagerPtr;
        BindingManagerPtr _bindingManagerPtr;
        MessageManagerPtr _messageManagerPtr;

    public:
        VirtualHost(const std::string &dbName, const std::string &baseDir)
            : _exchangeManagerPtr(std::make_shared<ExchangeManager>(dbName)),
              _msgQueueManagerPtr(std::make_shared<MsgQueueManager>(dbName)),
              _bindingManagerPtr(std::make_shared<BindingManager>(dbName))
        {
            std::vector<std::string> qnames;
            _msgQueueManagerPtr->getAllQueueName(&qnames);
            _messageManagerPtr = std::make_shared<MessageManager>(baseDir, qnames);
        }

        /**********
         * 声明交换机
         * *****************/
        bool declareExchange(const std::string &name, ExchangeType type, bool isDurable)
        {
            return _exchangeManagerPtr->declareExechange(name, type, isDurable);
        }

        /***************
         * 删除交换机
         * 交换机删除，与之相关的绑定也要删除
         * *************/
        void deleteExchange(const std::string &name)
        {
            _exchangeManagerPtr->removeExchange(name);
            _bindingManagerPtr->removeExchangeBindings(name);
        }

        /***********
         * 声明队列
         * 新增一个队列，消息管理句柄中也要新增一个队列消息管理句柄
         * ****************/
        bool declareMsgQueue(const std::string &name, bool isDurable)
        {
            _messageManagerPtr->initQueueMessageManager(name);
            return _msgQueueManagerPtr->declareMsgQueue(name, isDurable);
        }

        /************
         * 删除队列
         * 删除一个队列，与之相关的绑定也要随之删除
         * 同时要移除与之对应的队列消息
         * **********/
        void deleteMsgQueue(const std::string &name)
        {
            _bindingManagerPtr->removeMsqQueueBindings(name);
            _messageManagerPtr->removeQueueMessages(name);
            _msgQueueManagerPtr->removeMsgQueue(name);
        }

        /***************
         * 绑定交换机和队列
         * ***********/
        bool bind(const std::string &ename, const std::string &qname, const std::string& bindingKey)
        {
            //内部判断绑定是否需要持久化
            bool isDurable = false;
            if (_msgQueueManagerPtr->getMsgQueue(qname)->_isDurable && _exchangeManagerPtr->getExchange(ename))
            {
                isDurable = true;
            }
            return _bindingManagerPtr->bind(ename, qname, bindingKey, isDurable);
        }

        /*************
         * 解绑交换机和队列
         * *************/
        void unbind(const std::string &ename, const std::string &qname)
        {            
            auto exchanePtr = _exchangeManagerPtr->getExchange(ename);
            if (exchanePtr == nullptr)
            {
                return;
            }

            auto msgQueuePtr = _msgQueueManagerPtr->getMsgQueue(qname);
            if (msgQueuePtr == nullptr)
            {
                return;
            }
            
            bool isDurable = false;
            if (msgQueuePtr->_isDurable && exchanePtr->_isDurable)
            {
                isDurable = true;
            }
            _bindingManagerPtr->unbind(ename, qname, isDurable);
        }

        /**********
         * 向指定队列发布一条消息
         * ***************/
        bool publish(const std::string &qname, const std::string &id, const std::string &routingKey,
                     const std::string &body, DeliveryMode deliveryMode)
        {
            return _messageManagerPtr->insertMessage(qname, id, routingKey, body, deliveryMode);
        }

        /*************
         * 从指定队列消费一条消息
         * *************/
        MessagePtr consume(const std::string& qname)
        {
            return _messageManagerPtr->popFront(qname);
        }

        /***************
         * 应答指定队列的指定消息
         * **************/
        void ack(const std::string& qname, const std::string& msgId)
        {
            _messageManagerPtr->ack(qname, msgId);
        }

        /************
         * 获取与指定交换机相关的所有绑定
         * *mapPtr:key->队列名, value->BindingPtr
         * ****************/
        bool getExchangeBindings(const std::string& ename, std::unordered_map<std::string, BindingPtr>* mapPtr)
        {
            return _bindingManagerPtr->getExchangeBindings(ename, mapPtr);
        }
    };
}