用于替换自定义TCP消息的JSON或协议缓冲区

Question

Originally, We have two applications communication with TCP/IP, and both of them are implemented by C++. The messages between them are custom message type.

Now the client program will be changed to web application based on nodejs and the communication between them will be changed to message bus such as rabbitmq

So the message type between them should be changed.

JSON comes to my mind first, however the custom messages are too complicated, which are defined by template and inheritance . It seems that convert the custom message to JSON is not a good option. Am I right?

class Address {
    int network;
    int addressType;
    //...
};

class MsgType{
    unsigned char   msgSeq;
    unsigned int    msgLen;
    //...
};

class Message{
    Address destination;
    Address source;
    MsgType msgType;

    //...
};

template <typename T, int RESPONSE_TYPE>
class ResponseMessage : public Message{
    //...
}

typedef struct{
    int number;
    int type;
}ConfigResp;

class CfgResp : public ResponseMessage<ConfigResp, CONFIG_REQUEST>
{
    //...
}

Protocol Buffers is another option for me to do that. What should I do? redefine the custom message into protocol buffer? no no

Here is my solution: Just wrap the whole original custom message (binary type) into protocol buffer as one message in the server side, then decode the custom message(binary type) in client side. Is that possible?

Answer 1

It looks like you are structuring your application to become more extensible. Not using a nice message format is completely counter to that aim.

Don't embed your binary format inside a protocol buffer chunk. You'll gain nothing - you'll need to rewrite parsing and writing code for each component that wants to use the message bus. Thats wasted time and effort.

There is pain in mapping your C++ structures to JSON or protocol buffers. But it will make hooking into those messages using node.js or other things peeking into the message bus much easier later.

Personally I'd use protocol buffers - since they're more type safe. And there are differences between handling of various types in JSON libraries, because the JSON format is (intentionally) lax. In particular I've found handling of long integers problematic.

Typically I write a helper template struct for each class I need to convert - then conversion becomes a lot of boilerplate. Something like

template<typename T> class ProtocolBufferHelper {
}

template<> class ProtocolBufferHelper<Address> {
  typedef address_buffer protocol_buffer_type;
  void writeToProtocolBuffer( const Address &a, address_buffer & buffer) {
    buffer.setNetwork(a.network);
    ...
  }
  ...
}

template<> class ProtocolBufferHelper<Message> {
  void writeToProtocolBuffer(  const Message &m, address_buffer & buffer) {
    ::writeToProtocolBuffer(buffer.getDestination(), m.destination);
    ::writeToProtocolBuffer(buffer.getSource(), m.source);
    ...
  }
}

template<typename T> void writeToProtocolBuffer( const T &value, ProtocolBufferHelper<T>::protocol_buffer_type & buffer ) {
   ProtocolBufferHelper<T>::writeToProtocolBuffer(value, buffer);
}

You'll have to forgive me for not remembering exactly what the protocol buffer syntax is in C++ (its been a while...). but hopefully its enough to get you started.