MQTT C++客户端

AMQP-CPP ======== [](https://travis-ci.org/CopernicaMarketingSoftware/AMQP-CPP) AMQP-CPP is a C++ library for communicating with a RabbitMQ message broker. The library can be used to parse incoming data from a RabbitMQ server, and to generate frames that can be sent to a RabbitMQ server. This library has a layered architecture, and allows you - if you like - to completely take care of the network layer. If you want to set up and manage the network connections yourself, the AMQP-CPP library will not make a connection to RabbitMQ by itself, nor will it create sockets and/or perform IO operations. As a user of this library, you create the socket connection and implement a certain interface that you pass to the AMQP-CPP library and that the library will use for IO operations. Intercepting this network layer is however optional, the AMQP-CPP library also comes with a predefined Tcp module that can be used if you trust the AMQP library to take care of the network handling. In that case, the AMQP-CPP library does all the system calls to set up network connections and send and receive the data. This layered architecture makes the library extremely flexible and portable: it does not necessarily rely on operating system specific IO calls, and can be easily integrated into any kind of event loop. If you want to implement the AMQP protocol on top of some [unusual other communication layer](https://tools.ietf.org/html/rfc1149), this library can be used for that - but if you want to use it with regular TCP connections, setting it up is just as easy. AMQP-CPP is fully asynchronous and does not do any blocking (system) calls, so it can be used in high performance applications without the need for threads. The AMQP-CPP library uses C++11 features, so if you intend use it, please make sure that your compiler is up-to-date and supports C++11. **Note for the reader:** This readme file has a peculiar structure. We start explaining the pure and hard core low level interface in which you have to take care of opening socket connections yourself. In reality, you probably want to use the simpler TCP interface that is being described [later on](#tcp-connections). ABOUT ===== This library is created and maintained by Copernica (www.copernica.com), and is used inside the MailerQ (www.mailerq.com), Yothalot (www.yothalot.com) and AMQPipe (www.amqpipe.com) applications. MailerQ is a tool for sending large volumes of email, using AMQP message queues, Yothalot is a big data processing map/reduce framework and AMQPipe is a tool for high-speed processing messages between AMQP pipes Do you appreciate our work and are you looking for high quality email solutions? Then check out our other commercial and open source solutions: * Copernica Marketing Suite (www.copernica.com) * MailerQ on-premise MTA (www.mailerq.com) * AMQPipe (www.amqpipe.com) * Responsive Email web service (www.responsiveemail.com) * SMTPeter cloud based SMTP server (www.smtpeter.com) * PHP-CPP bridge between PHP and C++ (www.php-cpp.com) * PHP-JS bridge between PHP and Javascript (www.php-js.com) * Yothalot big data processor (www.yothalot.com) INSTALLING ========== AMQP-CPP comes with an optional Linux-only TCP module that takes care of the network part required for the AMQP-CPP core library. If you use this module, you are required to link with `pthread` and `dl`. There are two methods to compile AMQP-CPP: CMake and Make. CMake is platform portable and works on all systems, while the Makefile only works on Linux. Building of a shared library is currently not supported on Windows. After building there are two relevant files to include when using the library. File | Include when? ---------------------|-------------------------------------------------------- amqpcpp.h | Always amqpcpp/linux_tcp.h | If using the Linux-only TCP module On Windows you are required to define `NOMINMAX` when compiling code that includes public AMQP-CPP header files. ## Using cmake The CMake file supports both building and installing. You can choose not to use the install functionality, and instead manually use the build output at `build/bin/`. Keep in mind that the TCP module is only supported for Linux. An example install method would be: ```bash mkdir build cd build cmake .. [-DAMQP-CPP_AMQBUILD_SHARED] [-DAMQP-CPP_LINUX_TCP] cmake --build .. --target install ``` Option | Default | Meaning -------------------------|---------|----------------------------------------------------------------------- AMQP-CPP_BUILD_SHARED | OFF | Static lib(ON) or shared lib(OFF)? Shared is not supported on Windows. AMQP-CPP_LINUX_TCP | OFF | Should the Linux-only TCP module be built? ## Using make Compiling and installing AMQP-CPP with make is as easy as running `make` and then `make install`. This will install the full version of AMQP-CPP, including the system specific TCP module. If you do not need the additional TCP module (because you take care of handling the network stuff yourself), you can also compile a pure form of the library. Use `make pure` and `make install` for that. When you compile an application that uses the AMQP-CPP library, do not forget to link with the library. For gcc and clang the linker flag is -lamqpcpp. If you use the fullblown version of AMQP-CPP (with the TCP module), you also need to pass the -lpthread and -ldl linker flags, because the TCP module uses a thread for running an asynchronous and non-blocking DNS hostname lookup, and it may dynamically look up functions from the openssl library if a secure connection to RabbitMQ has to be set up. HOW TO USE AMQP-CPP =================== As we mentioned above, the library can be used in a network-agnostic fashion. It then does not do any IO by itself, and you need to pass an object to the library that the library can use for IO. So, before you start using the library, you first you need to create a class that extends from the ConnectionHandler base class. This is a class with a number of methods that are called by the library every time it wants to send out data, or when it needs to inform you that an error occured. ````c++ #include <amqpcpp.h> class MyConnectionHandler : public AMQP::ConnectionHandler { /** * Method that is called by the AMQP library every time it has data * available that should be sent to RabbitMQ. * @param connection pointer to the main connection object * @param data memory buffer with the data that should be sent to RabbitMQ * @param size size of the buffer */ virtual void onData(AMQP::Connection *connection, const char *data, size_t size) { // @todo // Add your own implementation, for example by doing a call to the // send() system call. But be aware that the send() call may not // send all data at once, so you also need to take care of buffering // the bytes that could not immediately be sent, and try to send // them again when the socket becomes writable again } /** * Method that is called by the AMQP library when the login attempt * succeeded. After this method has been called, the connection is ready * to use. * @param connection The connection that can now be used */ virtual void onConnected(AMQP::Connection *connection) { // @todo // add your own implementation, for example by creating a channel // instance, and start publishing or consuming } /** * Method that is called by the AMQP library when a fatal error occurs * on the connection, for example because data received from RabbitMQ * could not be recognized. * @param connection The connection on which the error occured * @param message A human readable error message