这里有三段代码分别是RabbitmqClient.h RabbitmqClient.cpp main;
注释非常详细，自己弄来跑就可以，环境是centos7，且docker部署了MQ，Rabbitmq支持百万并发是没有问题的；
常见疑问解答：
1、RabbitMQ有多种模式，如何选择呢？
理论上所有模式可以简化看成广播模式，具体要用哪个模式，就改然后在路由处添加不一样的筛选条件；具体做看我的代码注释；
2、RabbitMQ不是线程安全的！那么涉及多任务怎么办？如何最大限度利用CPU？
对于多个算法，每个算法需要不同个数CPU时，要么将每个算法单独做成一个项目，独立会话；要么多进程设置各个进程的亲核性！具体怎么做可以查我的博客《多进程下设置CPU亲核性》
3、死信队列，延迟队列
信息传递不及时导致溢出队列的最大消息量，MQ会主动删掉最老的消息，这种情况要设置一个队列专门存放
//RabbitmqClient.h
#ifndef RABBITMQ_CLIENT_H_
#define RABBITMQ_CLIENT_H_
#include <string>
#include <vector>
#include "amqp_tcp_socket.h"
using std::string;
using std::vector;
class CRabbitmqClient{
public:
CRabbitmqClient();
~CRabbitmqClient();
int Connect(const string &strHostname, int iPort, const string &strUser,
const string &strPasswd);
int Disconnect();
/**
* @brief ExchangeDeclare 声明exchange
* @param [in] strExchange
* @param [in] strType
* @return 等于0值代表成功创建exchange，小于0代表错误
*/
int ExchangeDeclare(const string &strExchange, const string &strType);
/**
* @brief QueueDeclare 声明消息队列
* @param [in] strQueueName 消息队列实例
* @param
* @return 等于0值代表成功创建queue，小于0代表错误
*/
int QueueDeclare(const string &strQueueName);
/**
* @brief QueueBind 将队列，交换机和绑定规则绑定起来形成一个路由表
* @param [in] strQueueName 消息队列
* @param [in] strExchange 交换机名称
* @param [in] strBindKey 路由名称 “msg.#” “msg.weather.**”
* @return 等于0值代表成功绑定，小于0代表错误
*/
int QueueBind(const string &strQueueName, const string &strExchange,
const string &strBindKey);
/**
* @brief QueueUnbind 将队列，交换机和绑定规则绑定解除
* @param [in] strQueueName 消息队列
* @param [in] strExchange 交换机名称
* @param [in] strBindKey 路由名称 “msg.#” “msg.weather.**”
* @return 等于0值代表成功绑定，小于0代表错误
*/
int QueueUnbind(const string &strQueueName, const string &strExchange,
const string &strBindKey);
/**
* @brief QueueDelete 删除消息队列。
* @param [in] strQueueName 消息队列名称
* @param [in] iIfUnused 消息队列是否在用，1 则论是否在用都删除
* @return 等于0值代表成功删除queue，小于0代表错误
*/
int QueueDelete(const string &strQueueName, int iIfUnused);
/**
* @brief Publish 发布消息
* @param [in] strMessage 消息实体
* @param [in] strExchange 交换器
* @param [in] strRoutekey 路由规则
* 1.Direct Exchange – 处理路由键。需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。
* 2.Fanout Exchange – 不处理路由键。将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。
* 3.Topic Exchange – 将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。
* 因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.*” 只会匹配到“audit.irs”
* @return 等于0值代表成功发送消息实体，小于0代表发送错误
*/
int Publish(const string &strMessage, const string &strExchange,
const string &strRoutekey);
/**
* @brief consumer 消费消息
* @param [in] strQueueName 队列名称
* @param [out] message_array 获取的消息实体
* @param [int] GetNum 需要取得的消息个数
* @param [int] timeout 取得的消息是延迟，若为NULL，表示持续取，无延迟，阻塞状态
* @return 等于0值代表成功，小于0代表错误，错误信息从ErrorReturn返回
*/
int Consumer(const string &strQueueName, vector<string> &message_array,
int GetNum = 1, struct timeval *timeout = NULL);
private:
CRabbitmqClient(const CRabbitmqClient & rh);
void operator=(const CRabbitmqClient & rh);
int ErrorMsg(amqp_rpc_reply_t x, char const *context);
string m_strHostname; // amqp主机
int m_iPort; // amqp端口
string m_strUser;
string m_strPasswd;
int m_iChannel;
amqp_socket_t *m_pSock;
amqp_connection_state_t m_pConn;
};
#endif
//RabbitmqClient.cpp
#include "RabbitmqClient.h"
#include <unistd.h>
CRabbitmqClient::CRabbitmqClient()
: m_strHostname("")
, m_iPort(0)
, m_strUser("")
, m_strPasswd("")
, m_iChannel(1) //默认用1号通道，通道无所谓
, m_pSock(NULL)
, m_pConn(NULL) {
}
CRabbitmqClient::~CRabbitmqClient() {
if (NULL != m_pConn) {
Disconnect();
m_pConn = NULL;
}
}
int CRabbitmqClient::Connect(const string &strHostname, int iPort, const string &strUser, const string &strPasswd) {
m_strHostname = strHostname;
m_iPort = iPort;
m_strUser = strUser;
m_strPasswd = strPasswd;
m_pConn = amqp_new_connection();
if (NULL == m_pConn) {
fprintf(stderr, "amqp new connection failed\n");
return -1;
}
m_pSock = amqp_tcp_socket_new(m_pConn);
if (NULL == m_pSock) {
fprintf(stderr, "amqp tcp new socket failed\n");
return -2;
}
int status = amqp_socket_open(m_pSock, m_strHostname.c_str(), m_iPort);
if (status<0) {
fprintf(stderr, "amqp socket open failed\n");
return -3;
}
// amqp_login(amqp_connection_state_t state,char const *vhost, int channel_max, int frame_max, int heartbeat, amqp_sasl_method_enum sasl_method, ..)
if (0 != ErrorMsg(amqp_login(m_pConn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, m_strUser.c_str(), m_strPasswd.c_str()), "Logging in")) {
return -4;
}
return 0;
}
int CRabbitmqClient::Disconnect() {
if (NULL != m_pConn) {
if (0 != ErrorMsg(amqp_connection_close(m_pConn, AMQP_REPLY_SUCCESS), "Closing connection"))
return -1;
if (amqp_destroy_connection(m_pConn) < 0)
return -2;
m_pConn = NULL;
}
return 0;
}
int CRabbitmqClient::ExchangeDeclare(const string &strExchange, const string &strType) {
amqp_channel_open(m_pConn, m_iChannel);
amqp_bytes_t _exchange = amqp_cstring_bytes(strExchange.c_str());
amqp_bytes_t _type = amqp_cstring_bytes(strType.c_str());
int _passive= 0;
int _durable= 0; // 交换机是否持久化
amqp_exchange_declare(m_pConn, m_iChannel, _exchange, _type, _passive, _durable, 0, 0, amqp_empty_table);
if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "exchange_declare")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -1;
}
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return 0;
}
int CRabbitmqClient::QueueDeclare(const string &strQueueName) {
if(NULL == m_pConn) {
fprintf(stderr, "QueueDeclare m_pConn is null\n");
return -1;
}
amqp_channel_open(m_pConn, m_iChannel);
amqp_bytes_t _queue = amqp_cstring_bytes(strQueueName.c_str());
int32_t _passive = 0;
int32_t _durable = 0;
int32_t _exclusive = 0;
int32_t _auto_delete = 1;
amqp_queue_declare(m_pConn, m_iChannel, _queue, _passive, _durable, _exclusive, _auto_delete, amqp_empty_table);
if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "queue_declare")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -1;
}
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return 0;
}
int CRabbitmqClient::QueueUnbind(const string &strQueueName, const string &strExchange, const string &strBindKey) {
if(NULL == m_pConn) {
fprintf(stderr, "QueueUnbind m_pConn is null\n");
return -1;
}
amqp_channel_open(m_pConn, m_iChannel);
amqp_bytes_t _queue = amqp_cstring_bytes(strQueueName.c_str());
amqp_bytes_t _exchange = amqp_cstring_bytes(strExchange.c_str());
amqp_bytes_t _routkey = amqp_cstring_bytes(strBindKey.c_str());
amqp_queue_unbind(m_pConn, m_iChannel, _queue, _exchange, _routkey, amqp_empty_table);
if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "queue_unbind")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -1;
}
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return 0;
}
int CRabbitmqClient::QueueDelete(const string &strQueueName, int iIfUnused) {
if(NULL == m_pConn) {
fprintf(stderr, "QueueDelete m_pConn is null\n");
return -1;
}
amqp_channel_open(m_pConn, m_iChannel);
if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "open channel")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -2;
}
amqp_queue_delete(m_pConn, m_iChannel, amqp_cstring_bytes(strQueueName.c_str()), iIfUnused, 0);
if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "delete queue")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -3;
}
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return 0;
}
int CRabbitmqClient::Publish(const string &strMessage, const string &strExchange, const string &strRoutekey) {
if (NULL == m_pConn) {
fprintf(stderr, "publish m_pConn is null, publish failed\n");
return -1;
}
amqp_channel_open(m_pConn, m_iChannel);
if(0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "open channel")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -2;
}
amqp_bytes_t message_bytes;
message_bytes.len = strMessage.length();
message_bytes.bytes = (void *)(strMessage.c_str());
//fprintf(stderr, "publish message(%d): %.*s\n", (int)message_bytes.len, (int)message_bytes.len, (char *)message_bytes.bytes);
/*
amqp_basic_properties_t props;
props._flags = AMQP_BASIC_CONTENT_TYPE_FLAG | AMQP_BASIC_DELIVERY_MODE_FLAG;
props.content_type = amqp_cstring_bytes(m_type.c_str());
props.delivery_mode = m_durable; // persistent delivery mode
*/
amqp_bytes_t exchange = amqp_cstring_bytes(strExchange.c_str());
amqp_bytes_t routekey = amqp_cstring_bytes(strRoutekey.c_str());
//if (0 != amqp_basic_publish(m_pConn, m_iChannel, exchange, routekey, 0, 0, &props, message_bytes)) {
if (0 != amqp_basic_publish(m_pConn, m_iChannel, exchange, routekey, 0, 0, NULL, message_bytes)) {
fprintf(stderr, "publish amqp_basic_publish failed\n");
if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "amqp_basic_publish")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -3;
}
}
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return 0;
}
int CRabbitmqClient::Consumer(const string &strQueueName, vector<string> &message_array, int GetNum, struct timeval *timeout) {
if (NULL == m_pConn) {
fprintf(stderr, "Consumer m_pConn is null, Consumer failed\n");
return -1;
}
amqp_channel_open(m_pConn, m_iChannel);
if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "open channel")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -2;
}
amqp_basic_qos(m_pConn, m_iChannel, 0, GetNum, 0);
int ack = 1; // no_ack 是否需要确认消息后再从队列中删除消息
amqp_bytes_t queuename= amqp_cstring_bytes(strQueueName.c_str());
amqp_basic_consume(m_pConn, m_iChannel, queuename, amqp_empty_bytes, 0, ack, 0, amqp_empty_table);
if (0 != ErrorMsg(amqp_get_rpc_reply(m_pConn), "Consuming")) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -3;
}
int hasget = 0;
amqp_rpc_reply_t res;
amqp_envelope_t envelope;
while (GetNum > 0) {
amqp_maybe_release_buffers(m_pConn);
res = amqp_consume_message(m_pConn, &envelope, timeout, 0);
if (AMQP_RESPONSE_NORMAL != res.reply_type) {
fprintf(stderr, "Consumer amqp_channel_close failed\n");
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
if (0 == hasget)
return -res.reply_type;
else
return 0;
}
string str((char *)envelope.message.body.bytes, (char *)envelope.message.body.bytes + envelope.message.body.len);
message_array.push_back(str);
int rtn = amqp_basic_ack(m_pConn, m_iChannel, envelope.delivery_tag, 1);
amqp_destroy_envelope(&envelope);
if (rtn != 0) {
amqp_channel_close(m_pConn, m_iChannel, AMQP_REPLY_SUCCESS);
return -4;
}
GetNum--;
hasget++;
usleep(1);
}
return 0;
}
int CRabbitmqClient::ErrorMsg(amqp_rpc_reply_t x, char const *context) {
switch (x.reply_type) {
case AMQP_RESPONSE_NORMAL:
return 0;
case AMQP_RESPONSE_NONE:
fprintf(stderr, "%s: missing RPC reply type!\n", context);
break;
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
fprintf(stderr, "%s: %s\n", context, amqp_error_string2(x.library_error));
break;
case AMQP_RESPONSE_SERVER_EXCEPTION:
switch (x.reply.id) {
case AMQP_CONNECTION_CLOSE_METHOD: {
amqp_connection_close_t *m = (amqp_connection_close_t *)x.reply.decoded;
fprintf(stderr, "%s: server connection error %uh, message: %.*s\n",
context, m->reply_code, (int)m->reply_text.len,
(char *)m->reply_text.bytes);
break;
}
case AMQP_CHANNEL_CLOSE_METHOD: {
amqp_channel_close_t *m = (amqp_channel_close_t *)x.reply.decoded;
fprintf(stderr, "%s: server channel error %uh, message: %.*s\n",
context, m->reply_code, (int)m->reply_text.len,
(char *)m->reply_text.bytes);
break;
}
default:
fprintf(stderr, "%s: unknown server error, method id 0x%08X\n",
context, x.reply.id);
break;
}
break;
}
return -1;
}
main
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <iostream>
#include "RabbitmqClient.h"
int main()
{
CRabbitmqClient objRabbitmq;
std::string strIP = "192.168.240.121";
int iPort = 8856;
std::string strUser = "rabbitadmin";
std::string strPasswd = "123321";
int iRet = objRabbitmq.Connect(strIP, iPort, strUser, strPasswd);
printf("Rabbitmq Connect Ret: %d\n", iRet);
std::string strExchange = "ExchangeTest";
std::string strRoutekey = "routekeyTest";
std::string strQueuename = "queueTest";
// 可选操作 Declare Exchange
iRet = objRabbitmq.ExchangeDeclare(strExchange, "direct");
printf("Rabbitmq ExchangeDeclare Ret: %d\n", iRet);
// 可选操作（接收） Declare Queue
iRet = objRabbitmq.QueueDeclare(strQueuename);
printf("Rabbitmq QueueDeclare Ret: %d\n", iRet);
// 可选操作（接收） Queue Bind
iRet = objRabbitmq.QueueBind(strQueuename, strExchange, strRoutekey);
printf("Rabbitmq QueueBind Ret: %d\n", iRet);
// Send Msg
std::string strSendMsg1 = "rabbitmq send test msg1";
std::string strSendMsg2 = "rabbitmq send test msg2";
iRet = objRabbitmq.Publish(strSendMsg1, strExchange, strRoutekey);
printf("Rabbitmq Publish 1 Ret: %d\n", iRet);
iRet = objRabbitmq.Publish(strSendMsg2, strExchange, strRoutekey);
printf("Rabbitmq Publish 2 Ret: %d\n", iRet);
// Recv Msg
std::vector<std::string> vecRecvMsg;
iRet = objRabbitmq.Consumer(strQueuename, vecRecvMsg, 2);
printf("Rabbitmq Consumer Ret: %d\n", iRet);
for (size_t i=0; i<vecRecvMsg.size(); ++i) {
printf("Consumer: %s\n", vecRecvMsg[i].c_str());
}
objRabbitmq.Disconnect();
return 0;
}
扫一扫
2564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
