Sto valutando i buffer del protocollo di Google per un servizio basato su Java (ma mi aspetto modelli di agnostica linguistica). Ho due domande:
Il primo è una domanda generale generica:
What patterns are we seeing people use? Said patterns being related to class organization (e.g., messages per .proto file, packaging, and distribution) and message definition (e.g., repeated fields vs. repeated encapsulated fields*) etc.
Ci sono pochissime informazioni di questo tipo nelle pagine della Guida di Google Protobuf e nei blog pubblici, mentre ci sono un sacco di informazioni per protocolli consolidati come XML.
Ho anche domande specifiche sui seguenti due diversi modelli:
-
Rappresenta i messaggi nei file .proto, li impacchettano come contenitori separati e li spediscono ai consumatori target del servizio, che è fondamentalmente l'approccio predefinito.
-
Fai lo stesso, ma includi anche wrapper fatti a mano (non sottoclassi!) attorno ad ogni messaggio che implementa un contratto che supporta almeno questi due metodi (T è la classe wrapper, V è la classe message (usando i generics ma sintassi semplificata per brevità):
public V toProtobufMessage() { V.Builder builder = V.newBuilder(); for (Item item : getItemList()) { builder.addItem(item); } return builder.setAmountPayable(getAmountPayable()). setShippingAddress(getShippingAddress()). build(); } public static T fromProtobufMessage(V message_) { return new T(message_.getShippingAddress(), message_.getItemList(), message_.getAmountPayable()); }
Un vantaggio che vedo con (2) è che posso nascondere le complessità introdotte da V.newBuilder().addField().build() e aggiungere alcuni metodi significativi come isOpenForTrade() o isAddressInFreeDeliveryZone() ecc. nei miei wrapper. Il secondo vantaggio che vedo con (2) è che i miei clienti si occupano di oggetti immutabili (qualcosa che posso applicare nella classe wrapper).
Uno svantaggio che vedo con (2) è che io duplico il codice e devo sincronizzare le mie classi wrapper con i file .proto.
Qualcuno ha tecniche migliori o ulteriori critiche su uno dei due approcci?
* Incapsulando un campo ripetuto intendo messaggi come questo:
message ItemList {
repeated item = 1;
}
message CustomerInvoice {
required ShippingAddress address = 1;
required ItemList = 2;
required double amountPayable = 3;
}
al posto di messaggi come questo:
message CustomerInvoice {
required ShippingAddress address = 1;
repeated Item item = 2;
required double amountPayable = 3;
}
Mi piace il secondo, ma sono felice di sentire argomenti contro di esso.