ZeroMQ Router模式C++代码示例

具体的Router模式这里不再介绍，直接贴代码，Linux下可以编译测试通过。

Client代码：

#include<zmq.hpp>
#include<iostream>
using std::endl;
using std::cout;

int main()
{
    zmq::context_t Context(1);
    zmq::socket_t ReqSock(Context, ZMQ_REQ);
    ReqSock.setsockopt(ZMQ_IDENTITY,"client",7);
    ReqSock.connect("tcp://localhost:7001");

    while (true)
    {
        printf("press Enter to send message\n");
        getchar();

        //发送消息
        zmq_msg_t msgOut; // 创建消息结构
        zmq_msg_init_size (&msgOut, 6); // 以字符串长度(不包括'\0')初始化成消息
        memcpy (zmq_msg_data (&msgOut), "hello", 6); // 将字符串的内容(不包括'\0')拷贝给消息
        zmq_msg_send(&msgOut,ReqSock,0); // 发送消息
        cout << "send:" << (char*)zmq_msg_data(&msgOut) << endl;
        zmq_msg_close (&msgOut); // 释放和销毁消息


        zmq_msg_t msgIn;
        zmq_msg_init(&msgIn);
        zmq_msg_recv(&msgIn, ReqSock, 0);
        cout << "recv:" << (char*)zmq_msg_data(&msgIn) << endl;
        zmq_msg_close(&msgIn);
    }
    ReqSock.close();
    Context.close();
    return 0;
}

Proxy代码：

#define _CRT_SECURE_NO_WARNINGS
#include<zmq.hpp>
#include<iostream>
#include<cassert>
#include <unistd.h>
using std::endl;
using std::cout;

int main()
{
    zmq::context_t Context(1);
    zmq::socket_t frontEnd(Context, ZMQ_ROUTER);
    zmq::socket_t backEnd(Context, ZMQ_ROUTER);
    frontEnd.bind("tcp://*:7001");
    backEnd.bind("tcp://*:7002");

    char pWorkerStr[7];//用于保存工人ID;
    int szWorkerID=7;
    while (true)
    {
        zmq_pollitem_t items[]=
                {
                        {frontEnd,0,ZMQ_POLLIN,0},
                        {backEnd, 0,ZMQ_POLLIN,0}
                };
        
        int rc = zmq_poll(items, 2, -1);
        if (rc==-1)
        {
            break;
        }
        
        //只在后端有可用工人时，才处理前端请求;
        if (items[1].revents&ZMQ_POLLIN)
        {
            //后端会收到5帧;
            //第1帧,工人的ID;
            zmq_msg_t backframe1;
            zmq_msg_init(&backframe1);
            zmq_msg_recv(&backframe1, backEnd, 0);
            memcpy(pWorkerStr, zmq_msg_data(&backframe1), 7);//保存工人ID;
            if (!zmq_msg_data(&backframe1))
            {
                cout <<"erro:后端第1帧，null"<<endl;
                break;
            }
            cout <<"后端第1帧，Worker的ID:"<<(char*)zmq_msg_data(&backframe1)<<endl;
            zmq_msg_close(&backframe1);

            //第2帧,空;
            zmq_msg_t backframe2;
            zmq_msg_init(&backframe2);
            int size0= zmq_msg_recv(&backframe2, backEnd, 0);
            cout << "后端第2帧，空" << size0<<endl;
            zmq_msg_close(&backframe2);

            //第3帧,客户端ID/或者ready;
            zmq_msg_t backframe3;
            zmq_msg_init(&backframe3);
            zmq_msg_recv(&backframe3, backEnd, 0);
            cout <<"后端第3帧，客户端ID/或者ready： "<< (char*)zmq_msg_data(&backframe3) << endl;
            if (zmq_msg_more(&backframe3))
            {
                //第4帧,空;
                zmq_msg_t backframe4;
                zmq_msg_init(&backframe4);
                zmq_msg_recv(&backframe4, backEnd, 0);
                cout << "后端第4帧，空" << endl;

                //第5帧,来自工人的回答;
                zmq_msg_t backframe5;
                zmq_msg_init(&backframe5);
                zmq_msg_recv(&backframe5, backEnd, 0);
                cout << "后端第5帧，来自工人的回答：" <<(char*)zmq_msg_data(&backframe5)<< endl;

                //将后3帧给前端;
                zmq_msg_send(&backframe3, frontEnd, ZMQ_SNDMORE);
                zmq_msg_send(&backframe4, frontEnd, ZMQ_SNDMORE);
                zmq_msg_send(&backframe5, frontEnd, 0);
                cout<<"后端3帧消息发送给前端 frame5:"<<(char*)zmq_msg_data(&backframe5)<<endl;

                zmq_msg_close(&backframe3);
                zmq_msg_close(&backframe4);
                zmq_msg_close(&backframe5);
            }
            else
            {
                zmq_msg_close(&backframe3);
            }
            
        }
        //来自前端的请求;
        if (items[0].revents&ZMQ_POLLIN)
        {
            //前端收会到3帧:[client身份][空][请求];
            zmq_msg_t frame3;
            zmq_msg_init(&frame3);
            zmq_msg_recv(&frame3, frontEnd, 0);
            if (!zmq_msg_data(&frame3))
            {
                cout <<"erro:前端第3帧，null"<<endl;
                break;
            }
            cout << "前端第3帧，client身份：" <<(char*)zmq_msg_data(&frame3)<< endl;

            zmq_msg_t frame4;
            zmq_msg_init(&frame4);
            zmq_msg_recv(&frame4, frontEnd, 0);
            cout << "前端第4帧，空" <<endl;

            zmq_msg_t frame5;
            zmq_msg_init(&frame5);
            zmq_msg_recv(&frame5, frontEnd, 0);
            cout << "前端第5帧，请求内容:" <<(char*)zmq_msg_data(&frame5)<< endl;

            //再制造2帧:[worker身份][空];
            zmq_msg_t frame1;
            zmq_msg_init_size(&frame1, 7);
            memcpy(zmq_msg_data(&frame1), pWorkerStr, 7);
            if (!zmq_msg_data(&frame1))
            {
                cout <<"erro:前端第1帧，null"<<endl;
                break;
            }
            cout << "前端第1帧，worker身份:" <<(char*)zmq_msg_data(&frame1)<< endl;

            zmq_msg_t frame2;
            zmq_msg_init(&frame2);
            cout << "前端第2帧，空" <<endl;

            //将这5帧发给后端[WorkerID] [NULL] [clientID] [NULL] [msg]
            zmq_msg_send(&frame1, backEnd, ZMQ_SNDMORE);
            zmq_msg_send(&frame2, backEnd, ZMQ_SNDMORE);
            zmq_msg_send(&frame3, backEnd, ZMQ_SNDMORE);
            zmq_msg_send(&frame4, backEnd, ZMQ_SNDMORE);
            zmq_msg_send(&frame5, backEnd, 0);
            cout<<"前端5帧消息发送给后端 frame5:"<<(char*)zmq_msg_data(&frame5)<<endl;
            zmq_msg_close(&frame1);
            zmq_msg_close(&frame2);
            zmq_msg_close(&frame3);
            zmq_msg_close(&frame4);
            zmq_msg_close(&frame5);
        }
    }
    frontEnd.close();
    backEnd.close();
    Context.close();
    return 0;
}

Worker代码：

#include<zmq.hpp>
#include<iostream>
#include<cassert>
using std::endl;
using std::cout;

int main()
{
    zmq::context_t Context(1);
    zmq::socket_t ReqSock(Context, ZMQ_REQ);
    ReqSock.setsockopt(ZMQ_IDENTITY, "worker", 7);
    ReqSock.connect("tcp://localhost:7002");

    //把自己的身份通过第一次消息发送给后端;
    //cout << "---" << endl;

    //发送消息
    zmq_msg_t msgOut; // 创建消息结构
    zmq_msg_init_size (&msgOut, 6); // 以字符串长度(不包括'\0')初始化成消息
    memcpy (zmq_msg_data (&msgOut), "ready", 6); // 将字符串的内容(不包括'\0')拷贝给消息
    zmq_msg_send(&msgOut,ReqSock,0); // 发送消息
    zmq_msg_close (&msgOut); // 释放和销毁消息

    cout << "Worker first send msg to backend: ready" << endl;
    while (true)
    {
        zmq_msg_t clientID;
        zmq_msg_init(&clientID);
        int szClientID=zmq_msg_recv(&clientID, ReqSock, 0);
        char* pClientStr = new char[szClientID];
        memset(pClientStr, 0, szClientID );
        memcpy(pClientStr, zmq_msg_data(&clientID), szClientID);
        cout << "接收第1帧 客户端身份:" << pClientStr << endl;
        zmq_msg_close(&clientID);

        zmq_msg_t zeroFrame;
        zmq_msg_init(&zeroFrame);
        int szFrame2=zmq_msg_recv(&zeroFrame, ReqSock, 0);
        assert(szFrame2 == 0);
        cout << "接收第2帧，空" << endl;
        zmq_msg_close(&zeroFrame);

        zmq_msg_t msg;
        zmq_msg_init(&msg);
        zmq_msg_recv(&msg, ReqSock, 0);
        cout << "接收第3帧，客户端消息:" << (char*)zmq_msg_data(&msg) << endl;
        zmq_msg_close(&msg);

//        //回复;
//        //第一帧;
        zmq_msg_t frame1;
        zmq_msg_init_size (&frame1, szClientID); // 以字符串长度(不包括'\0')初始化成消息
        memcpy (zmq_msg_data (&frame1), pClientStr, szClientID); // 将字符串的内容(不包括'\0')拷贝给消息
        zmq_msg_send(&frame1, ReqSock, ZMQ_SNDMORE);
        zmq_msg_close(&frame1);

        zmq_msg_t frame2;
        zmq_msg_init(&frame2);
        zmq_msg_send(&frame2, ReqSock, ZMQ_SNDMORE);
        cout << "接收第2帧，空" << endl;
        zmq_msg_close(&frame2);

        static int i = 0;
        zmq_msg_t frame3;
        zmq_msg_init_size(&frame3, 7);
        memcpy(zmq_msg_data(&frame3), "world", 6);
        zmq_msg_send(&frame3, ReqSock, 0);
        cout << "发送第3帧，响应消息" << (char*)zmq_msg_data(&frame3) << endl;
        zmq_msg_close(&frame3);


        cout << "final" << endl;
        delete []pClientStr;//销毁身份;
    }
    ReqSock.close();
    Context.close();
    return 0;

}