Zeromq ApacheAvro，在其他语言之间交换数据。（即C/C+；+；到JAVA）

我的应用程序与ZeroMQ交换消息，我将使用序列化解决方案（Apache Avro）在应用程序之间交换消息

然而，我面临着意想不到的困难。有人看过我的源代码吗

订阅者在“avro_record_get（person，“isincode”&isincode）；”处生成核心转储

#包括“zhelpers.h”
#包括
avro_schema_t person_schema；
const char PERSON_SCHEMA[]=
“{\”类型\“：\”记录\“\
\“名称\”：“A0\”\
\“字段\”：[\
{\'name\'：\'datatype\'，\'type\'：\'int\'}\
{\'name\'：\'market\'，\'type\'：\'int\'\
{\'name\'：\'infotype\'，\'type\'：\'int\'}\
{\'name\'：\'isincode\'，\'type\'：\'string\'\
{\'name\'：\'lastprice\'，\'type\'：\'int\'}]}；
int main（int argc，char*argv[]）{
//与服务器对话的套接字
init_schema（）；
zmq_msg_t msg；
avro_datum_t person=avro_记录（person_schema）；
void*context=zmq_ctx_new（）；
void*publisher=zmq_套接字（上下文，zmq_PUB）；
int rc=zmq_bind（发布者，“tcp://*：5563”）；
断言（rc==0）；
对于（；；）{
avro_数据类型=avro_int32（1）；
avro_数据市场=avro_int32（2）；
avro_数据信息类型=avro_int32（1）；
avro_数据isincode=avro_字符串（“KR7005930003”）；
avro_数据最后价格=avro_int64（1500000）；
avro_记录集（个人，“数据类型”，数据类型）；
avro_记录集（个人，“市场”，市场）；
avro_记录集（个人，“信息类型”，信息类型）；
avro_记录集（个人，“isincode”，isincode）；
avro_记录集（个人，“lastprice”，lastprice）；
int rc3=zmq_msg_init_size（&msg，sizeof（msg））；
memcpy（zmq_msg_数据（&msg）、person、sizeof（msg））；
int ret3=zmq_msg_send（&msg，publisher，0）；
zmq_msg_close（&msg）；
printf（“%d\n”，ret3）；
avro_数据人员2，isincode2；
char*p；
avro_record_get（个人，“isincode”和isincode2）；
avro_string_get（isincode，&p）；
fprintf（stdout，“%12s |”，p）；
}
zmq_close（出版商）；
zmq_ctx_销毁（上下文）；
返回0；
}
**[订户]**
#包括“zhelpers.h”
#包括
avro_schema_t person_schema；
const char PERSON_SCHEMA[]=
“{\”类型\“：\”记录\“\
\“名称\”：“A0\”\
\“字段\”：[\
{\'name\'：\'datatype\'，\'type\'：\'int\'}\
{\'name\'：\'market\'，\'type\'：\'int\'\
{\'name\'：\'infotype\'，\'type\'：\'int\'}\
{\'name\'：\'isincode\'，\'type\'：\'string\'\
{\'name\'：\'lastprice\'，\'type\'：\'int\'}]}；
/*将模式解析为模式数据结构*/
void init_模式（void）{
if（avro_schema_from_json_literal（PERSON_schema和PERSON_schema））{
fprintf（stderr，“无法分析人员架构”）；
退出（退出失败）；
}
}
int main（int argc，char*argv[]）{
init_schema（）；
avro_datum_t person=avro_记录（person_schema）；
init_schema（）；
void*context=zmq_ctx_new（）；
void*subscriber=zmq_套接字（上下文，zmq_SUB）；
int rc=zmq_连接（订户，“tcp://localhost:5563");
断言（rc==0）；
rc=zmq_setsockopt（订户，zmq_SUBSCRIBE，0，0）；
断言（rc==0）；
而(1){
//avro_数据_t人员，isincode；
avro_数据输入代码；
char*p；
zmq_msg_t回复；
zmq_msg_init（&reply）；
printf（“zmq_msg_init complete\n”）；
int recv_size=zmq_msg_recv（&reply，订户，0）；
printf（“zmq\u msg\u recv%d\n”，recv\u大小）；
int length=zmq\u msg\u大小（&reply）；
printf（“zmq\u msg\u大小%d\n”，长度）；
memcpy（个人、zmq_msg_数据和回复）、长度；
//zmq_msg_关闭（&reply）；
avro_record_get（个人，“isincode”和isincode）；
avro_string_get（isincode，&p）；
fprintf（stdout，“%12s |”，p）；
}
zmq_关闭（用户）；
zmq_ctx_销毁（上下文）；
返回0；
}

如何确保接收到的数据（“长度”）不大于avro___t中的数据？使用memcpy（）是错误的序列化方式，即使是跨进程或网络的序列化也是如此。例如，它不关心内部指针。还有一个注意事项：C代码

“foo”“bar”

是一个（！）字符串，这两个部分是隐式连接的，甚至跨行连接。您可以使用它来清理您的模式。您还应该将模式移动到一个公共头，供双方使用，毕竟他们必须对此达成一致。

#include "zhelpers.h"
#include <avro.h>

avro_schema_t person_schema;

const char PERSON_SCHEMA[] =
        "{\"type\":\"record\",\
  \"name\":\"A0\",\
  \"fields\":[\
     {\"name\": \"datatype\", \"type\": \"int\"},\
     {\"name\": \"market\", \"type\": \"int\"},\
     {\"name\": \"infotype\", \"type\": \"int\"},\
     {\"name\": \"isincode\", \"type\": \"string\"},\
     {\"name\": \"lastprice\", \"type\": \"int\"}]}";


int main(int argc, char *argv []) {
    //  Socket to talk to server


    init_schema();
    zmq_msg_t msg;

    avro_datum_t person = avro_record(person_schema);

    void *context = zmq_ctx_new();
    void *publisher = zmq_socket(context, ZMQ_PUB);
    int rc = zmq_bind(publisher, "tcp://*:5563");
    assert(rc == 0);

    for (;;) {

        avro_datum_t datatype = avro_int32(1);
        avro_datum_t market = avro_int32(2);
        avro_datum_t infotype = avro_int32(1);
        avro_datum_t isincode = avro_string("KR7005930003");
        avro_datum_t lastprice = avro_int64(1500000);

        avro_record_set(person, "datatype", datatype);
        avro_record_set(person, "market", market);
        avro_record_set(person, "infotype", infotype);
        avro_record_set(person, "isincode", isincode);
        avro_record_set(person, "lastprice", lastprice);

        int rc3 = zmq_msg_init_size(&msg, sizeof (msg));
        memcpy(zmq_msg_data(&msg), person, sizeof (msg));

        int ret3 = zmq_msg_send(&msg, publisher, 0);
        zmq_msg_close(&msg);

        printf("%d\n", ret3);

        avro_datum_t person2,   isincode2;
        char *p;

        avro_record_get(person, "isincode", &isincode2);
        avro_string_get(isincode, &p);
        fprintf(stdout, "%12s | ", p);

    }
    zmq_close(publisher);
    zmq_ctx_destroy(context);
    return 0;
}


**[Subscriber]**


#include "zhelpers.h"
#include <avro.h>


avro_schema_t person_schema;

const char PERSON_SCHEMA[] =
        "{\"type\":\"record\",\
  \"name\":\"A0\",\
  \"fields\":[\
     {\"name\": \"datatype\", \"type\": \"int\"},\
     {\"name\": \"market\", \"type\": \"int\"},\
     {\"name\": \"infotype\", \"type\": \"int\"},\
     {\"name\": \"isincode\", \"type\": \"string\"},\
     {\"name\": \"lastprice\", \"type\": \"int\"}]}";

/* Parse schema into a schema data structure */
void init_schema(void) {
    if (avro_schema_from_json_literal(PERSON_SCHEMA, &person_schema)) {
        fprintf(stderr, "Unable to parse person schema\n");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv []) {

    init_schema();
    avro_datum_t person = avro_record(person_schema);

    init_schema();
    void *context = zmq_ctx_new();
    void *subscriber = zmq_socket(context, ZMQ_SUB);
    int rc = zmq_connect(subscriber, "tcp://localhost:5563");
    assert(rc == 0);

    rc = zmq_setsockopt(subscriber, ZMQ_SUBSCRIBE, 0, 0);
    assert(rc == 0);

    while (1) {

        //  avro_datum_t person, isincode;
        avro_datum_t isincode;
        char *p;

        zmq_msg_t reply;

        zmq_msg_init(&reply);


        printf("zmq_msg_init complete \n");

        int recv_size = zmq_msg_recv(&reply, subscriber, 0);

        printf("zmq_msg_recv  %d\n", recv_size);

        int length = zmq_msg_size(&reply);

        printf("zmq_msg_size %d\n", length);

        memcpy(person, zmq_msg_data(&reply), length);
        // zmq_msg_close(&reply);

        avro_record_get(person, "isincode", &isincode);
        avro_string_get(isincode, &p);
        fprintf(stdout, "%12s | ", p);

    }

    zmq_close(subscriber);
    zmq_ctx_destroy(context);
    return 0;
}