【RabbitMQ 项目】服务端数据管理模块之交换机管理

已于 2024-09-26 20:15:30 修改
阅读量812 收藏 1
点赞数 8
分类专栏： RabbitMQ项目 文章标签： rabbitmq oracle 数据库
于 2024-09-15 09:49:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74113106/article/details/142279778
版权

文章目录

一.编写思路

  1. 定义交换机类型
    1. 直接交换
    2. 广播交换
    3. 主题交换
  2. 定义交换机
    1. 名字
    2. 类型
    3. 是否持久化
  3. 定义交换机持久化类(持久化到 sqlite3)
    1. 构造函数(只能成功，不能失败)
      如果数据库(文件)不存在则创建;打开数据库; 打开 exchange_table 数据库表
    2. 插入交换机
    3. 移除交换机
    4. 将数据库中的交换机恢复到内存中
      传入一个哈希表，key 为名字，value 为交换机的智能指针，填充该哈希表
  4. 定义交换机管理类(包含内存管理和持久化管理)
    1. 构造函数：从数据库中恢复交换机
    2. 声明交换机
    3. 移除交换机
    4. 获取交换机

二.代码实践

Exchange.hpp:

#pragma once
#include "../common/Util.hpp"
#include "../common/protocol.pb.h"
#include <string>
#include <memory>
#include <unordered_map>
#include <functional>
#include <mutex>

namespace ns_data
{
    // 声明
    class Exchange;

    using ExchangePtr = std::shared_ptr<Exchange>;

    /**********
     * 定义交换机
     * ***************/
    struct Exchange
    {
        std::string _name;
        ns_protocol::ExchangeType _type;
        bool _isDurable;

        Exchange()
        {
        }

        Exchange(const std::string &name, ns_protocol::ExchangeType type, bool isDurable)
            : _name(name),
              _type(type),
              _isDurable(isDurable)
        {
        }
    };

    /**************
     * 定义交换机持久化类
     * ****************/
    class ExchangeMapper
    {
    private:
        ns_util::Sqlite3Util _sqlite3; //线程安全可以保证

    public:
        ExchangeMapper(const std::string &dbName)
            : _sqlite3(dbName)
        {
            // 如果数据库不存在就创建
            if (!ns_util::FileUtil::createFile(dbName))
            {
                LOG(FATAL) << "creat database" << dbName << endl;
                exit(1);
            }
            if (!_sqlite3.open())
            {
                LOG(FATAL) << "open database " << dbName << " fail" << endl;
                exit(1);
            }
            createTable();
        }

        /************
         * 功能:插入交换机
         * *************/
        bool insertExchange(ExchangePtr exchangePtr)
        {
            char insertSql[1024];
            sprintf(insertSql, "insert into exchange_table values('%s', '%d', '%d');", (exchangePtr->_name).c_str(),
                    static_cast<int>(exchangePtr->_type), exchangePtr->_isDurable);
            if (!_sqlite3.exec(insertSql, nullptr, nullptr))
            {
                LOG(WARNING) << "insert Exchange fail, Exchange: " << exchangePtr->_name << endl;
                return false;
            }
            return true;
        }
        /**********
         * 功能：移除交换机
         * *************/
        void removeExchange(const std::string &exchangeName)
        {
            char removeSql[1024];
            sprintf(removeSql, "delete from exchange_table where name='%s';", exchangeName.c_str());
            if (!_sqlite3.exec(removeSql, nullptr, nullptr))
            {
                LOG(WARNING) << "remvoe Exchange fail, Exchange: " << exchangeName << endl;
            }
        }

        /***********
         * 功能：把数据库中的所有交换机恢复到内存中
         * *************/
        void recoverExchange(std::unordered_map<std::string, ExchangePtr> *mapPtr)
        {
            char selectSql[1024] ;
            sprintf(selectSql, "select * from exchange_table;");
            if (!_sqlite3.exec(selectSql, selectCallback, mapPtr))
            {
                LOG(FATAL) << "recover Exchange fail" << endl;
                exit(1);
            }
        }

        /*************
         * 功能:删除交换机数据表(仅用于调试)
         * ***********/
        void removeTable()
        {
            const std::string removeSql = "drop table if exists exchange_table;";
            if (!_sqlite3.exec(removeSql, nullptr, nullptr))
            {
                LOG(FATAL) << "remvoe exchange_table fail" <<  endl;
                exit(1);
            }
        }

    private:
        /*************
         * 功能：创建存储Exchange的数据表
         * *********/
        void createTable()
        {
            std::string createTableSql = "create table if not exists exchange_table(\
                name varchar(32) primary key,\
                type int,\
                durable int);";
            if (!_sqlite3.exec(createTableSql, nullptr, nullptr))
            {
                LOG(FATAL) << "创建交换机数据库表失败" << endl;
                exit(1);
            }
        }

        static int selectCallback(void* arg, int colNum, char** line, char** fields)
        {
            auto mapPtr = static_cast<std::unordered_map<std::string, ExchangePtr>*>(arg);

            std::string name = line[0];
            ns_protocol::ExchangeType type = static_cast<ns_protocol::ExchangeType>(std::stoi(line[1]));
            bool isDurable = line[2];

            mapPtr->insert({name, std::make_shared<Exchange>(name, type, isDurable)});
            return 0;
        }
    };

    /***********
     * 定义交换机管理类：包含内存管理和持久化管理两方面
     * *************/
    class ExchangeManager
    {
    private:
        ExchangeMapper _mapper;
        std::unordered_map<std::string, ExchangePtr> _exchanges;
        std::mutex _mtx;

    public:
        ExchangeManager(const std::string& dbName)
            :_mapper(dbName)
        {
            _mapper.recoverExchange(&_exchanges);
        }

        /**************
         * 功能：声明交换机：无则创建，有则什么都不管
         * *************/
        bool declareExechange(const std::string &name, ns_protocol::ExchangeType type, bool isDurable)
        {
            std::unique_lock<std::mutex> lck(_mtx);
            if (_exchanges.count(name))
            {
                return true;
            }

            auto exchangePtr = std::make_shared<Exchange>(name, type, isDurable);
            _exchanges[name] = exchangePtr;

            if (isDurable)  
            {
                return _mapper.insertExchange(exchangePtr);
            }

            return true;
        }

        /**********
         * 移除交换机：包括内存和磁盘两个地方
         * ************/
        void removeExchange(const std::string &name)
        {
            std::unique_lock<std::mutex> lck(_mtx);
            auto it = _exchanges.find(name);
            if (it == _exchanges.end())
            {
                return;
            }

            if (it->second->_isDurable)
            {
                _mapper.removeExchange(name);
            }
            _exchanges.erase(name);
        }

        /*************
         * 获取指定交换机
         * ***********/
        ExchangePtr getExchange(const std::string& name)
        {
            std::unique_lock<std::mutex> lck(_mtx);
            if (_exchanges.count(name) == 0)
            {
                return nullptr;
            }
            return _exchanges[name];
        }

        /***********
         * 清理所有交换机(仅调试)
         * ************/
        void clearExchanges()
        {
            std::unique_lock<std::mutex> lck(_mtx);
            _exchanges.clear();
            _mapper.removeTable();
        }
    };
}

Util.hpp:

#pragma once
#include "Log.hpp"
#include <string>
#include <sqlite3.h>
#include <iostream>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
using namespace ns_log;
namespace ns_util
{
    class Sqlite3Util
    {
    private:
        std::string _dbfile;
        sqlite3 *_handler;
        bool _isOpen;

    public:
        Sqlite3Util(const std::string &dbfile)
            : _dbfile(dbfile),
              _handler(nullptr),
              _isOpen(false)
        {
            open();
        }

        ~Sqlite3Util()
        {
            close();
        }

        bool open(int safeLevel = SQLITE_OPEN_FULLMUTEX)
        {
            if (_isOpen)
            {
                return true;
            }

            // 可读可写，不存在就创建，默认串行化访问
            int ret = sqlite3_open_v2(_dbfile.c_str(), &_handler, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | safeLevel,
                                      nullptr);
            if (ret != SQLITE_OK)
            {
                LOG(WARNING) << sqlite3_errmsg(_handler) << endl;
                return false;
            }

            _isOpen = true;
            return true;
        }
        // int sqlite3_exec(sqlite3*, char *sql, int (*callback) (void* arg,int colNum ,char** lines,char** fields), void* arg, char **err)
        bool exec(const std::string &sql, int (*cb)(void *, int, char **, char **), void *arg)
        {
            if (sqlite3_exec(_handler, sql.c_str(), cb, arg, nullptr) != SQLITE_OK)
            {
                LOG(WARNING) << "execute fail: error: " << sqlite3_errmsg(_handler) << endl;
                return false;
            }
            return true;
        }
        void close()
        {
            if (_handler)
            {
                sqlite3_close_v2(_handler);
            }
        }
    };

    class FileUtil
    {
    public:
        static void getParentDirectory(const std::string &pathName, std::string *dirPtr)
        {
            // 从后往前找，找到第一个“/”
            auto pos = pathName.rfind('/');
            if (pos == std::string::npos)
            {
                *dirPtr = "./";
                return;
            }
            *dirPtr = pathName.substr(0, pos);
        }

        static bool createDirectory(const std::string &dirName)
        {
            // 从第一个父目录开始，逐层创建
            size_t prev = 0;
            while (true)
            {
                auto pos = dirName.find('/', prev);
                if (pos == std::string::npos)
                {
                    break;
                }

                std::string dir = dirName.substr(0, pos);
                int ret = mkdir(dir.c_str(), 0775);
                if (ret != 0 && errno != EEXIST)
                {
                    LOG(WARNING) << "创建目录" << dir << "失败, error: " << strerror(errno) << endl;
                    return false;
                }

                prev = pos + 1;
            }

            int ret = mkdir(dirName.c_str(), 0775);
            if (ret != 0 && errno != EEXIST)
            {
                LOG(WARNING) << "创建目录" << dirName << "失败, error: " << strerror(errno) << endl;
                return false;
            }

            return true;
        }

        static bool createFile(const std::string pathName)
        {
            //先创建它的父目录
            std::string parentDir;
            getParentDirectory(pathName, &parentDir);
            if (!createDirectory(parentDir))
            {
                LOG(WARNING) << "创建文件失败，因为创建父目录失败" << endl;
                return false;
            }
            //再创建文件
            int fd = open(pathName.c_str(), O_CREAT, 0775);
            if (fd == -1)
            {
                LOG(WARNING) << "创建文件失败, error: " << strerror(errno) << endl;
                return false;
            }
            close(fd);
            return true;
        }

        static bool removeFileOrDir(const std::string& name)
        {
            
            if (remove(name.c_str()) != 0)
            {
                LOG(WARNING) << "remove " << name << " fail, error: " << strerror(errno) << endl;
                return false;
            }
            return true;
        }
    } ;
}
月夜星辉雪
关注
专栏目录
RabbitMQ 相关整合实战项目（完结）
HUJIAXIN的博客
09-17 948
RabbitMQ 整合 PD 商城实战项目流程总结 一、订单流量削峰（解耦） 简单模式，若多添加几个消费者则用工作模式。 导入商城项目 将 step5 课前资料里面 /elasticsearch/pd商城.zip 解压。 第二层目录下 pd-web 文件夹解压到 rabbitmq 工程目录下面。 修改 pom.xml 文件中的 SpringBoot 版本为 2.3.2.RELEASE（可拖拽至 idea 内更改）。 在 rabbitmq 工程中导入模块（若之前在 idea 内更改则可以直接
【RabbitMQ 项目】服务端：数据管理模块之绑定管理
weixin_74113106的博客
09-15 690
Rabbit项目：服务端数据管理模块之绑定管理
【RabbitMQ 项目】服务端：数据管理模块之虚拟机模块
weixin_74113106的博客
09-19 508
服务端：数据管理模块整合
【RabbitMQ 项目】服务端：数据管理模块之消息管理
weixin_74113106的博客
09-18 1390
服务端数据管理模块之消息管理
【RabbitMQ 项目】服务端：信道模块
weixin_74113106的博客
09-26 1321
服务端：信道模块
【RabbitMQ 项目】服务端：服务器模块
weixin_74113106的博客
09-26 602
服务端：服务器模块
SpringBoot整合RabbitMQ之直连交换机模式
Curtisjia的博客
11-12 1060
SpringBoot整合RabbitMQ之交换机模式 安装Rabbitmq 说实话关于安装rabbitmq的问题的确让人头疼，因为准备环境实在是太多太复杂，我个人建议使用docker镜像拉取！详情可以看我之前的博客：https://blog.csdn.net/Curtisjia/article/details/104199105 OK，到这里我就假设你的rabbitmq环境已经没有问题了！ 登陆的用户名密码都是guest，如果你觉得有必要，你也可以自己去配置virtual-host，我这里就不需要了，就使
43：RabbitMQ四大类型的交换机持久化
王永安的博客
07-18 988
目录环境配置同步架构分布式异步队列队列（异步队列/异步架构）解读常见异步队列组件C#驱动RabbitMQ单生产者单消费者多生产者多消费者互为生产消费者RabbitMQ Exchange（交换机）Direct Exchange应用Fanout ExchangeTopic ExchangeHeader Exchange消息持久化发布订阅RabbitMQ生产端消息确认RabbitMQ消费端消息确认系统架构 环境配置 环境配置地址：访问：https://blog.csdn.net/hello_mr_anan/
SpringBoot整合RabbitMQ——交换机和队列的管理和绑定
Amos技术足迹
07-16 1778
本博文从某个角度来说，应该是rabbitMQ应用开发的知识点梳理，使用目前最广泛流行的SpringBoot来集成rabbitMQ的功能开发，在开发的过程中讲解rabbitMQ的各种特性、技能点以及开发过程中需要注意的地方 上一篇博文Centos7下RabbitMQ的搭建我们已经搭建好RabbitMQ的服务器，并且简单的介绍了MQ服务中主要的几个概念，各个概念的主要作用以及为了实现消息的发送和接...
【RabbitMQ 项目】客户端：信道模块
weixin_74113106的博客
09-26 595
客户端：信道模块
秒杀系统企业级实战应用（真实工业界案例）70-71 高并发之消息队列RabbitMQ和spring整合
03-25
通过Spring的AMQP模块，我们可以方便地声明RabbitMQ的实体，如队列、交换机和绑定，同时利用Spring的依赖注入和AOP特性，实现消息的发布和消费。 在实际操作中，我们需要创建一个RabbitTemplate实例，配置连接工厂...
基于springboot和rabbitmq的消息收发demo
01-20
综上所述，本项目是一个使用Spring Boot和RabbitMQ实现的消息收发示例，涉及了Spring Boot的依赖注入、配置管理、RabbitMQ的消息发送与接收，以及可能的MySQL数据库操作。这样的设计有助于提升系统的可扩展性和异步...
RabbitMQ从原理到实战—基于Golang【万字详解】
weixin_44545838的博客
08-27 5129
最近秋招开始找工作，顺便回顾消息队列并且总结。
Python RabbitMQ 入门 pika
随便写写
10-10 673
服务, (RabbitMQ 依赖于 Erlang 环境, 所以还要装 Erlang),启动服务后, 访问 http://localhost:15672/# 也有GUI界面。）的开源消息代理软件（亦称面向消息的。与RabbitMQ，安装路径都应不含。RabbitMQ服务器是用。均有与代理接口通讯的客户端库。消费者 consumer.py。生产者 producer.py。语言编写的，而集群和。
第六章 RabbitMQ之Work模式
Calvin的博客
10-10 1437
在上一章的讲解中，我们通过一个simple模式的简单示例代码给大家做了快速入门演示，本章节我们就来讲讲RabbitMQ的Work模式。讲解之前，先简单介绍下RabbitMQ支持六种主要的工作模式‌，分别是简单模式、工作队列模式、发布订阅模式、路由模式、通配符模式和远程调用模式（RPC）。其中，远程调用模式不常用，因此主要介绍前五种模式‌。Work模型的使用：多个消费者绑定到一个队列，可以加快消息处理速度同一条消息只会被一个消费者处理。
第十三章 RabbitMQ之消息幂等性
Calvin的博客
10-11 653
实际项目开发中，我们在提交表单时，很多时候可能会重复提交表单，这个时候我们通过token令牌等唯一标识来解决，第一次提交页面将缓存中的唯一标识删除，后面再重新提交时缓存中的标识已经被删了因此重复提交失败。结合业务逻辑，基于业务本身做判断。以余额支付业务为例，我们要在支付后修改订单状态为已支付，应该在修改订单状态前先查询订单状态，判断状态是否是未支付。我们在消息消费的过程中也会存在同样的问题，即如何来保障所有业务在接收RabbitMQ消息时保证业务的幂等性，避免消息重复消费呢？
RabbitMQ 交换机的类型
canduecho的专栏
10-10 769
在 RabbitMQ 中，交换机（Exchange）是一个核心组件，负责接收来自生产者的消息，并根据特定的路由规则将消息分发到相应的队列。交换机的存在改变了消息发送的模式，使得消息的路由更加灵活和高效。
RabbitMQ消息队列MQ脑裂(网络分区)整理分析
最新发布
发现问题，面对问题，分析问题，解决问题，总结问题
10-13 1018
MQ 脑裂问题（Message Queue Split-Brain）通常发生在分布式系统中，尤其是在消息队列（Message Queue, MQ）系统中的集群部署下。所谓“脑裂”指的是集群系统中的多个节点由于网络分区或其他原因，失去了彼此之间的通信能力，但每个节点仍然认为自己是主节点。这种情况下，集群中可能会同时存在多个主节点，它们各自独立处理相同的数据或任务，从而导致数据不一致、消息重复或丢失等问题。也称为网络分区（Network Partition）问题。
第十二章 RabbitMQ之失败消息处理策略
Calvin的博客
10-11 1373
Spring AMQP提供了消费者失败重试机制，在消费者出现异常时利用本地重试，而不是无限地requeue到mq。我们可以定义一个异常队列和交换机，来接收其他交换机队列转发的无法处理的异常消息。然后我们可以查看其中的异常消息并进行人工处理。重试耗尽后，直接reject，丢弃消息（默认方式）重试耗尽后，将失败消息投递到指定的交换机（推荐）2. 定义接收失败消息的交换机、队列及其绑定关系。重试耗尽后，返回nack，消息重新入队。在实际项目的生产环境中，通过。
安装RabbitMQ的服务端
04-24
安装RabbitMQ的服务端可以按照以下步骤进行： 1. 首先，你需要下载并安装Erlang/OTP，这是RabbitMQ的依赖项。你可以从Erlang官方网站（https://www.erlang.org/downloads）下载适合你操作系统的版本，并按照官方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值