devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Qt中使用RabbitMQ-c（一）：使用CMake + MinGW编译RabbitMQ-c_qt rabbitmq-c

作者：人工智能uu | 2024-07-11 04:29:35

赞

踩

qt rabbitmq-c

      项目需要，在发送和接受数据的时候使用RabbitMQ队列作为中间基站。想要对RabbitMQ有个基本的了解，可以结合官网：http://www.rabbitmq.com/，和这篇博客：http://blog.csdn.net/anzhsoft/article/details/19563091一起来理解。

      因为是在Qt中使用，所以需要用RabbitMQ-c，官网没有c语言使用RabbitMQ的详细介绍，上面的博客是使用Python来作为说明的，所以还需另寻他路，自己琢磨琢磨。

      准备工作：

      1、使用Qt 4.7.4和Qt Creator 2.4.1及其的MinGW：

            具体的下载安装请见另一篇博客：Qt中使用Protocol Buffers（一）：使用QT的MinGW + msys编译Protocol Buffers v2.6.1

      2、Cmak：

            下载：https://cmake.org/download/，当前最新版本3.8.0，下载cmake-3.8.0-win64-x64.zip

            安装：解压并将bin目录添加到环境目录中去，安装成功后可以在cmd中输入cmake --version查看cmake的版本，cmake --help查看cmake的帮助

            

            

      3、RabbitMQ-c：

            下载：GitHub上下载：https://github.com/alanxz/rabbitmq-c/，下载rabbitmq-c-master.zip，下载完后解压，就可以开始编译啦

      开始编译：

     根据RabbitMQ-c的下载地址下面的说明文档进行编译

      1、使用cmd进入到RabbitMQ的解压地址，在rabbitmq-c-master文件夹中的cmake文件夹中创建文件夹build，然后输入cmake -G "MinGW Makefiles" -DCMAKE_INSTALL_PREFIX=../../install ../..来配置

            cmake表示命令

            -G "MinGW Makefiles"表示使用MinGW来生成文件

            -DCMAKE_INSTALL_PREFIX=../../install表示在rabbitmq-c-master文件夹中创建（如果没有）install文件夹，并在install的时候将文件存放其中。

            ../..表示CmakeLists.txt所在的文件夹rabbitmq-c-master的文件夹

            配置结果：

            

            在这一步的时候遇到两个错误：

            Error1: could not find cmakeroot，解决办法：重新安装cmake

            Error2: could not find openssl：

            

            解决办法在这个网站找到：https://zhidao.baidu.com/question/587845628097951765.html，即将CMakeLists.txt文件中的ENABLE_SSL_SUPPORT的ON改成OFF，再删除之前生成的文件重新编译。

            正确的编译结果是：

            D:\RabbitMQ\rabbitmq-c-master\cmake\build>cmake -G "MinGW Makefiles" -DCMAKE_INSTALL_PREFIX=../../install ../..
            -- The C compiler identification is GNU 4.4.0
            -- Check for working C compiler: D:/Qt/qtcreator-2.4.1/mingw/bin/gcc.exe
            -- Check for working C compiler: D:/Qt/qtcreator-2.4.1/mingw/bin/gcc.exe -- works
            -- Detecting C compiler ABI info
            -- Detecting C compiler ABI info - done
            -- Detecting C compile features
            -- Detecting C compile features - done
            -- CMAKE_BUILD_TYPE not specified. Creating Release build
            -- Found C inline keyword: inline
            -- Looking for htonll
            -- Looking for htonll - not found
            -- Looking for poll
            -- Looking for poll - not found
            -- Looking for clock_gettime in rt
            -- Looking for clock_gettime in rt - not found
            -- Looking for posix_spawnp in rt
            -- Looking for posix_spawnp in rt - not found
            -- Performing Test HAVE_GNU90
            -- Performing Test HAVE_GNU90 - Failed
            -- Performing Test HAVE_C90
            -- Performing Test HAVE_C90 - Failed
            -- Could NOT find POPT (missing:  POPT_INCLUDE_DIR POPT_LIBRARY)
            -- Could NOT find XMLTO (missing:  XMLTO_EXECUTABLE)
            -- Could NOT find Doxygen (missing:  DOXYGEN_EXECUTABLE)
            -- Looking for pthread.h
            -- Looking for pthread.h - found
            -- Looking for pthread_create
            -- Looking for pthread_create - not found
            -- Looking for pthread_create in pthreads
            -- Looking for pthread_create in pthreads - not found
            -- Looking for pthread_create in pthread
            -- Looking for pthread_create in pthread - found
            -- Found Threads: TRUE
            -- Building rabbitmq as a shared library - yes
            -- Building rabbitmq as a static library - yes
            -- Configuring done
            -- Generating done
            -- Build files have been written to: D:/RabbitMQ/rabbitmq-c-master/cmake/build

      2、配置成功后就是编译make，输入make

      3、编译成功后就是安装，输入make install：

            如果安装成功后再次输入make install就是如下内容：

            

      4、安装成功，可以在install文件夹中查找到以下内容：

            bin文件夹：librabbitmq.4.dll

            include文件夹：amqp.h、amqp_framing.h、amqp_tcp_socket.h

            lib文件夹：liblibrabbitmq.4.a、librabbitmq.4.dll.a

      简单实例：（测试安装是否成功）

      依然是根据GitHub上面的安装教程，后面接着的running the examples，不过它是用cmd命令行运行的，我直接在Qt中使用。

      1、分别建两个工程，控制台类型，一个用来发送一个用来监听

      2、分别在每个工程文件的文件夹里添加上三个头文件：amqp.h、amqp_framing.h、amqp_tcp_socket.h和一个静态库文件：librabbitmq.4.dll.a

      3、分别在每个工程的.pro文件中添加

LIBS += -L$$PWD/ -lrabbitmq.4
      “-L$$PWD”是当前目录，即main.cpp所在目录，因为我的librabbitmq.4.dll.a放在当前目录中，所以直接这么写就可以，注意：/后面可以有空格，但是-l和文件之间不能有空格，且文件名中的lib和.dll.a皆省略。

      4、编译运行文件会发现不成功，但会生成一个工程文件夹，将librabbitmq.4.dll文件添加到生成的工程文件夹中的debug文件夹中去，再次编译运行即

      运行结果：

      

      运行出现的错误：

      Logging in：socket is closed，两个可能：

      1、检查hostname、prot、exchange、routingkey / bindingkey、user、psw，可能笔误写错。

      2、主机的服务器没有开启，导致socket is closed，本例是使用localhost作为服务器，所以还需要在本地下载RabbitMQ的服务端，并打开使用才能成功运行。            

      rabbitmq-c的使用说明：

      1、需要有主机名：hostname、端口号：port、交换机：exchange、路由钥匙：routingkey / 绑定钥匙：bindingkey、用户名：user、密码：psw，我们的实例中默认用户名和密码都是guest。

      2、先建立TCP连接：

  1. conn = amqp_new_connection();
  2. socket = amqp_tcp_socket_new(conn);

      3、打开建立的TCP连接，使用socket，主机名和端口号：

status = amqp_socket_open(socket, hostname, port);
      4、登录： 

amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest");
      5、打开信道： 

  1. amqp_channel_open(conn, 1);
  2. amqp_get_rpc_reply(conn);
      6、开始发送或者监听消息

      7、关闭信道、关闭连接、销毁连接：

  1. amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS);
  2. amqp_connection_close(conn, AMQP_REPLY_SUCCESS);
  3. amqp_destroy_connection(conn);

      发送和监听的main.cpp文件分别是： 

  1. //发送"Hello World！”消息
  2. #include <QtCore/QCoreApplication>
  3. #include <QDebug>
  4. //RabbitMQ相关头文件
  5. #include "amqp.h"
  6. #include "amqp_framing.h"
  7. #include "amqp_tcp_socket.h"
  8.  
  9. void die_on_error(int x, char const *context)
  10. {
  11.   if (x < 0) {
  12.     fprintf(stderr, "%s: %s\n", context, amqp_error_string2(x));
  13.     exit(1);
  14.   }
  15. }
  16.  
  17. void die_on_amqp_error(amqp_rpc_reply_t x, char const *context)
  18. {
  19.   switch (x.reply_type) {
  20.   case AMQP_RESPONSE_NORMAL:
  21.     return;
  22.  
  23.   case AMQP_RESPONSE_NONE:
  24.     fprintf(stderr, "%s: missing RPC reply type!\n", context);
  25.     break;
  26.  
  27.   case AMQP_RESPONSE_LIBRARY_EXCEPTION:
  28.     fprintf(stderr, "%s: %s\n", context, amqp_error_string2(x.library_error));
  29.     break;
  30.  
  31.   case AMQP_RESPONSE_SERVER_EXCEPTION:
  32.     switch (x.reply.id) {
  33.     case AMQP_CONNECTION_CLOSE_METHOD: {
  34.       amqp_connection_close_t *m = (amqp_connection_close_t *) x.reply.decoded;
  35.       fprintf(stderr, "%s: server connection error %uh, message: %.*s\n",
  36.               context,
  37.               m->reply_code,
  38.               (int) m->reply_text.len, (char *) m->reply_text.bytes);
  39.       break;
  40.     }
  41.     case AMQP_CHANNEL_CLOSE_METHOD: {
  42.       amqp_channel_close_t *m = (amqp_channel_close_t *) x.reply.decoded;
  43.       fprintf(stderr, "%s: server channel error %uh, message: %.*s\n",
  44.               context,
  45.               m->reply_code,
  46.               (int) m->reply_text.len, (char *) m->reply_text.bytes);
  47.       break;
  48.     }
  49.     default:
  50.       fprintf(stderr, "%s: unknown server error, method id 0x%08X\n", context, x.reply.id);
  51.       break;
  52.     }
  53.     break;
  54.   }
  55.  
  56.   exit(1);
  57. }
  58.  
  59. int main(int argc, char *argv[])
  60. {
  61.     QCoreApplication a(argc, argv);
  62.     //RabbitMQ start
  63.     char const *hostname;
  64.     int port, status;
  65.     char const *exchange;
  66.     char const *routingkey;
  67.     char const *messagebody;
  68.     amqp_socket_t *socket;
  69.     amqp_connection_state_t conn;
  70.  
  71.     hostname = "localhost";
  72.     port = 5672;
  73.     exchange = "amq.direct";
  74.     routingkey = "test";
  75.     messagebody = "Hello World!";
  76.  
  77.     conn = amqp_new_connection();
  78.  
  79.     socket = amqp_tcp_socket_new(conn);
  80.     if (!socket) {
  81.         qDebug() << "creating TCP socket";
  82.     }
  83.  
  84.     status = amqp_socket_open(socket, hostname, port);
  85.     if (status) {
  86.         qDebug() << "opening TCP socket";
  87.     }
  88.  
  89.     die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),
  90.                       "Logging in");
  91.     amqp_channel_open(conn, 1);
  92.     die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
  93.  
  94.     {
  95.       amqp_basic_properties_t props;
  96.       props._flags = AMQP_BASIC_CONTENT_TYPE_FLAG | AMQP_BASIC_DELIVERY_MODE_FLAG;
  97.       props.content_type = amqp_cstring_bytes("text/plain");
  98.       props.delivery_mode = 2; /* persistent delivery mode */
  99.       die_on_error(amqp_basic_publish(conn,
  100.                                       1,
  101.                                       amqp_cstring_bytes(exchange),
  102.                                       amqp_cstring_bytes(routingkey),
  103.                                       0,
  104.                                       0,
  105.                                       &props,
  106.                                       amqp_cstring_bytes(messagebody)),
  107.                    "Publishing");
  108.     }
  109.  
  110.     die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel");
  111.     die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
  112.     die_on_error(amqp_destroy_connection(conn), "Ending connection");
  113.     //RabbitMQ end
  114.  
  115.     return a.exec();
  116. }

  1. //监听“Hello World！”消息
  2. #include <QtCore/QCoreApplication>
  3. #include <QDebug>
  4. //RabbitMQ相关头文件
  5. #include "amqp.h"
  6. #include "amqp_framing.h"
  7. #include "amqp_tcp_socket.h"
  8.  
  9. void die_on_error(int x, char const *context)
  10. {
  11.   if (x < 0) {
  12.     fprintf(stderr, "%s: %s\n", context, amqp_error_string2(x));
  13.     exit(1);
  14.   }
  15. }
  16.  
  17. void die_on_amqp_error(amqp_rpc_reply_t x, char const *context)
  18. {
  19.   switch (x.reply_type) {
  20.   case AMQP_RESPONSE_NORMAL:
  21.     return;
  22.  
  23.   case AMQP_RESPONSE_NONE:
  24.     fprintf(stderr, "%s: missing RPC reply type!\n", context);
  25.     break;
  26.  
  27.   case AMQP_RESPONSE_LIBRARY_EXCEPTION:
  28.     fprintf(stderr, "%s: %s\n", context, amqp_error_string2(x.library_error));
  29.     break;
  30.  
  31.   case AMQP_RESPONSE_SERVER_EXCEPTION:
  32.     switch (x.reply.id) {
  33.     case AMQP_CONNECTION_CLOSE_METHOD: {
  34.       amqp_connection_close_t *m = (amqp_connection_close_t *) x.reply.decoded;
  35.       fprintf(stderr, "%s: server connection error %uh, message: %.*s\n",
  36.               context,
  37.               m->reply_code,
  38.               (int) m->reply_text.len, (char *) m->reply_text.bytes);
  39.       break;
  40.     }
  41.     case AMQP_CHANNEL_CLOSE_METHOD: {
  42.       amqp_channel_close_t *m = (amqp_channel_close_t *) x.reply.decoded;
  43.       fprintf(stderr, "%s: server channel error %uh, message: %.*s\n",
  44.               context,
  45.               m->reply_code,
  46.               (int) m->reply_text.len, (char *) m->reply_text.bytes);
  47.       break;
  48.     }
  49.     default:
  50.       fprintf(stderr, "%s: unknown server error, method id 0x%08X\n", context, x.reply.id);
  51.       break;
  52.     }
  53.     break;
  54.   }
  55.  
  56.   exit(1);
  57. }
  58.  
  59. static void dump_row(long count, int numinrow, int *chs)
  60. {
  61.   int i;
  62.  
  63.   printf("%08lX:", count - numinrow);
  64.  
  65.   if (numinrow > 0) {
  66.     for (i = 0; i < numinrow; i++) {
  67.       if (i == 8) {
  68.         printf(" :");
  69.       }
  70.       printf(" %02X", chs[i]);
  71.     }
  72.     for (i = numinrow; i < 16; i++) {
  73.       if (i == 8) {
  74.         printf(" :");
  75.       }
  76.       printf("   ");
  77.     }
  78.     printf("  ");
  79.     for (i = 0; i < numinrow; i++) {
  80.       if (isprint(chs[i])) {
  81.         printf("%c", chs[i]);
  82.       } else {
  83.         printf(".");
  84.       }
  85.     }
  86.   }
  87.   printf("\n");
  88. }
  89.  
  90. static int rows_eq(int *a, int *b)
  91. {
  92.   int i;
  93.  
  94.   for (i=0; i<16; i++)
  95.     if (a[i] != b[i]) {
  96.       return 0;
  97.     }
  98.  
  99.   return 1;
  100. }
  101.  
  102. void amqp_dump(void const *buffer, size_t len)
  103. {
  104.   unsigned char *buf = (unsigned char *) buffer;
  105.   long count = 0;
  106.   int numinrow = 0;
  107.   int chs[16];
  108.   int oldchs[16] = {0};
  109.   int showed_dots = 0;
  110.   size_t i;
  111.  
  112.   for (i = 0; i < len; i++) {
  113.     int ch = buf[i];
  114.  
  115.     if (numinrow == 16) {
  116.       int j;
  117.  
  118.       if (rows_eq(oldchs, chs)) {
  119.         if (!showed_dots) {
  120.           showed_dots = 1;
  121.           printf("          .. .. .. .. .. .. .. .. : .. .. .. .. .. .. .. ..\n");
  122.         }
  123.       } else {
  124.         showed_dots = 0;
  125.         dump_row(count, numinrow, chs);
  126.       }
  127.  
  128.       for (j=0; j<16; j++) {
  129.         oldchs[j] = chs[j];
  130.       }
  131.  
  132.       numinrow = 0;
  133.     }
  134.  
  135.     count++;
  136.     chs[numinrow++] = ch;
  137.   }
  138.  
  139.   dump_row(count, numinrow, chs);
  140.  
  141.   if (numinrow != 0) {
  142.     printf("%08lX:\n", count);
  143.   }
  144. }
  145.  
  146. int main(int argc, char *argv[])
  147. {
  148.     QCoreApplication a(argc, argv);
  149.     
  150.     //RabbitMQ start
  151.     char const *hostname;
  152.     int port, status;
  153.     char const *exchange;
  154.     char const *bindingkey;
  155.     amqp_socket_t *socket = NULL;
  156.     amqp_connection_state_t conn;
  157.  
  158.     amqp_bytes_t queuename;
  159.  
  160.     hostname = "localhost";
  161.     port = 5672;
  162.     exchange = "amq.direct";
  163.     bindingkey = "test";
  164.  
  165.     conn = amqp_new_connection();
  166.  
  167.     socket = amqp_tcp_socket_new(conn);
  168.     if (!socket) {
  169.       qDebug() << "creating TCP socket";
  170.     }
  171.  
  172.     status = amqp_socket_open(socket, hostname, port);
  173.     if (status) {
  174.       qDebug() << "opening TCP socket";
  175.     }
  176.  
  177.     die_on_amqp_error(amqp_login(conn, "/", 0, 131072, 0, AMQP_SASL_METHOD_PLAIN, "guest", "guest"),
  178.                       "Logging in");
  179.     amqp_channel_open(conn, 1);
  180.     die_on_amqp_error(amqp_get_rpc_reply(conn), "Opening channel");
  181.  
  182.     //大括号指明变量的作用域
  183.     {
  184.       amqp_queue_declare_ok_t *r = amqp_queue_declare(conn, 1, amqp_empty_bytes, 0, 0, 0, 1,
  185.                                    amqp_empty_table);
  186.       die_on_amqp_error(amqp_get_rpc_reply(conn), "Declaring queue");
  187.       queuename = amqp_bytes_malloc_dup(r->queue);
  188.       if (queuename.bytes == NULL) {
  189.         fprintf(stderr, "Out of memory while copying queue name");
  190.         return 1;
  191.       }
  192.     }
  193.  
  194.     amqp_queue_bind(conn, 1, queuename, amqp_cstring_bytes(exchange), amqp_cstring_bytes(bindingkey),
  195.                     amqp_empty_table);
  196.     die_on_amqp_error(amqp_get_rpc_reply(conn), "Binding queue");
  197.  
  198.     amqp_basic_consume(conn, 1, queuename, amqp_empty_bytes, 0, 1, 0, amqp_empty_table);
  199.     die_on_amqp_error(amqp_get_rpc_reply(conn), "Consuming");
  200.  
  201.     {
  202.       for (;;) {
  203.         amqp_rpc_reply_t res;
  204.         amqp_envelope_t envelope;
  205.  
  206.         amqp_maybe_release_buffers(conn);
  207.  
  208.         res = amqp_consume_message(conn, &envelope, NULL, 0);
  209.  
  210.         if (AMQP_RESPONSE_NORMAL != res.reply_type) {
  211.           break;
  212.         }
  213.  
  214.         printf("Delivery %u, exchange %.*s routingkey %.*s\n",
  215.                (unsigned) envelope.delivery_tag,
  216.                (int) envelope.exchange.len, (char *) envelope.exchange.bytes,
  217.                (int) envelope.routing_key.len, (char *) envelope.routing_key.bytes);
  218.  
  219.         if (envelope.message.properties._flags & AMQP_BASIC_CONTENT_TYPE_FLAG) {
  220.           printf("Content-type: %.*s\n",
  221.                  (int) envelope.message.properties.content_type.len,
  222.                  (char *) envelope.message.properties.content_type.bytes);
  223.         }
  224.         printf("----\n");
  225.  
  226.         amqp_dump(envelope.message.body.bytes, envelope.message.body.len);
  227.  
  228.         amqp_destroy_envelope(&envelope);
  229.       }
  230.     }
  231.  
  232.     die_on_amqp_error(amqp_channel_close(conn, 1, AMQP_REPLY_SUCCESS), "Closing channel");
  233.     die_on_amqp_error(amqp_connection_close(conn, AMQP_REPLY_SUCCESS), "Closing connection");
  234.     die_on_error(amqp_destroy_connection(conn), "Ending connection");
  235.     //RabbitMQ end
  236.  
  237.     return a.exec();
  238. }


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/808746
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号