Netty + ProtoBuffer: quelques messages de communication pour une connexion

Lors de la lecture de la Netty tutoriel, j'ai trouvé un simple description de comment intégrer Netty et Google Protocol Buffers. J'ai commencé à étudier son exemple (car il n'y a pas plus d'informations dans la documentation) et écrit une application simple comme dans l'exemple que l'heure locale de l'application. Mais cet exemple est à l'aide d'initialisation statique dans PipeFactory Classe, par exemple:

import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.handler.codec.protobuf.ProtobufDecoder;
import org.jboss.netty.handler.codec.protobuf.ProtobufEncoder;
import org.jboss.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
import org.jboss.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;

import static org.jboss.netty.channel.Channels.pipeline;

/**
 * @author sergiizagriichuk
 */
class ProtoCommunicationClientPipeFactory implements ChannelPipelineFactory {

    public ChannelPipeline getPipeline() throws Exception {
        ChannelPipeline p = pipeline();
        p.addLast("frameDecoder", new ProtobufVarint32FrameDecoder());
        p.addLast("protobufDecoder", new ProtobufDecoder(Communication.DataMessage.getDefaultInstance()));

        p.addLast("frameEncoder", new ProtobufVarint32LengthFieldPrepender());
        p.addLast("protobufEncoder", new ProtobufEncoder());

        p.addLast("handler", new ProtoCommunicationClientHandler());
        return p;
    }

}

(Veuillez jeter un oeil à la ligne p.addLast("protobufDecoder", new ProtobufDecoder(Communication.DataMessage.getDefaultInstance()));)
et juste une usine peut être créé (comme je le comprends) pour ClientBootstrap classe, je veux dire bootstrap.setPipelineFactory() méthode. Si, dans cette situation je peux utiliser UN message à envoyer au serveur et UN message pour recevoir depuis le serveur, et c'est mauvais pour moi, et je ne pense pas juste pour moi 🙁 Comment puis-je utiliser différents messages vers et à partir pour juste un lien?
Peut-être que je peux créer un peu de protobufDecoder comme ce

p.addLast("protobufDecoder", new ProtobufDecoder(Communication.DataMessage.getDefaultInstance()));
p.addLast("protobufDecoder", new ProtobufDecoder(Communication.TestMessage.getDefaultInstance()));
p.addLast("protobufDecoder", new ProtobufDecoder(Communication.SrcMessage.getDefaultInstance()));

ou d'autres techniques?
Merci beaucoup.

Vous pouvez ajouter de nombreux décodeurs/encodeurs dans le pipeline, mais ils devraient être en mesure de transmettre des données qu'ils ne savent pas comment gérer. Regarder les netty source sur github il semble qu'Il n'est pas le cas. Donc il y a probablement un moyen de le faire, mais je suis sceptique, il s aussi simple. Essayez tout de même et à partager les résultats 🙂
Oui, Il n'est pas simple et veut travailler dur 🙁

OriginalL'auteur Sergii Zagriichuk | 2011-10-18

5

J'ai trouvé le thread de l'auteur de netty dans google groupes et compris que je dois changer mon architecture ou d'écrire mon propre décodeur comme je l'ai écrit ci-dessus, Alors, Commencer à penser de quelle façon sera facile et mieux.

Je pense que le point de ce qui les groupes de discussion est que si vous voulez envoyer plusieurs types de messages, une solution serait de définir de 1 à usage général "container" (disons ProtocolMessage) dans protobuf qui va contenir 1 ou plusieurs différents types de messages. Vous pouvez alors utiliser la protobuf décodeur pour la ProtocolMessage type de message, et de laisser toute autre interprétation à vous de gestionnaire de message dans Netty.
Oui, j'ai bien compris, merci.

OriginalL'auteur Sergii Zagriichuk
3

Si vous allez écrire vos propres codecs de toute façon, vous voudrez peut-être regarder à la mise en œuvre de l'interface Externalizable de données personnalisés objets.
- Serializable est faible effort, mais le pire performance (sérialise tout).
- Protobuf est un bon compromis entre l'effort et de la performance (nécessite .proto entretien)
- Externalizable est un effort important, mais le meilleur rendement (mesure minimale codecs)
Si vous connaissez déjà votre projet aura à l'échelle comme une chèvre de montagne, vous pourriez avoir à aller la route difficile. Protobuf n'est pas une panacée.

OriginalL'auteur Dominic Cerisano
2

En théorie, cela peut être fait en modifiant le pipeline pour chaque message entrant pour adapter le message entrant. Jetez un oeil à la port de l'unification exemple dans Netty.

Séquence serait:

1) Dans le cadre de décodeur ou d'une autre "DecoderMappingDecoder" vous cochez le type de message du message entrant

2) Modifier le pipeline dynamiquement, comme illustré dans l'exemple

Mais pourquoi ne pas utiliser les différentes connexions, et procédez comme suit:

1) Ajouter d'autres décodeurs de pipeline basé sur le message entrant une seule fois.

2) Ajouter le même instance de canal en amont gestionnaire comme le dernier gestionnaire dans le pipeline, de cette façon tous les messages acheminés à la même instance, qui est presque comme avoir un unique de connexion.

Théoriquement, nous devrions modifier un décodeur pour lire quelques id de bytestream et sélectionnez corriger l'algorithme de décodage, je thout sur cette solution, mais Ce n'est pas simplement ou la bonne façon de le faire. Pourquoi je veux ouvrir juste un lien, parce que je veux configurer mon client et de préparer la connexion au serveur et l'utiliser (juste une) connexion pour envoyer TOUS les messages sur le serveur, les messages comme les opérations, et actuelles de l'architecture de me donner la possibilité de créer un grand nombre de clients pour chaque opération, je pense que c'est pas une bonne IDÉE!
Si vous avez n les types de message et n différentes façons de décoder, alors vous pouvez toujours utiliser la même connexion qui a un seul "MappingDecoder" qui permettra de vérifier le type de message et le transmettre sur le bon décodeur pour décoder. Jetez un oeil à netty intégré décodeur(grepcode.com/file/repository.jboss.org/maven2/org.jboss.netty/...) qui peuvent vous offrir un moyen d'utiliser le décodeur sans l'aide d'un pipeline.

OriginalL'auteur Abe
2

le problème est qu'il n'existe aucun moyen de distinguer deux différents protobuf les messages les uns des autres dans un format binaire. Mais il existe un moyen de résoudre le problème dans les protobuf fichier:
```
message AnyMessage {
    message DataMessage { [...] }
    optional DataMessage dataMessage = 1;
    message TestMessage { [...] }
    optional TestMessage testMessage = 2;
    message SrcMessage { [...] }
    optional SrcMessage srcMessage = 3;
}
```
champs facultatifs qui ne sont pas mis en produisent pas de frais généraux. En outre, vous pouvez ajouter un Enum, mais c'est juste un bonus.

OriginalL'auteur Arne
1

La question n'est pas tout à fait un Netty limitation ou l'encodeur/décodeur de limitation. Le problème est que Google Protocol Buffers sont à offrir un moyen de sérialiser/désérialiser des objets, mais n'est pas de fournir un protocole. Ils ont une sorte de RPC mise en œuvre en tant que partie de la distribution standard, mais si vous essayez de mettre en œuvre leur protocole RPC alors vous finirez avec 3 niveaux d'indirection.
Ce que j'ai fait dans le cadre du projet, a été de définir un message qui est fondamentalement une union de messages. Ce message contient un champ de Type et un autre champ qui est le véritable message. Vous aurez toujours la fin avec 2 indirection de couches, mais pas 3. De cette façon, l'exemple de Netty de travail pour vous, mais comme dit dans un post précédent, vous devez mettre plus de logique dans le gestionnaire de logique métier.

OriginalL'auteur devsprint
0

Vous pouvez utiliser le message de tunneling pour envoyer différents types de messages en tant que charge dans un seul message.
Hope qui aide

OriginalL'auteur Abhishek kapoor

Après de longues recherches et de la souffrance...
Je suis venu avec l'idée de l'utilisation de la composition de messages dans un wrapper de message. À l'intérieur de ce message-je utiliser oneof clé pour limiter le nombre de permis objets à la un seul. La caisse de l'exemple:

message OneMessage {
    MessageType messageType = 1;

    oneof messageBody {
        Event event = 2;
        Request request  = 3;
        Response response = 4;
    }

    string messageCode = 5; //unique message code
    int64 timestamp = 6; //server time
}

OriginalL'auteur Raman

Vous devez vous connecter pour publier un commentaire.