Comment gérer le démarshaling des messages Protobuf inconnus ?

Protobuf Unmarshal : gestion des messages inconnus

Dans les scénarios où le type de message dans une charge utile protobuf n'est pas connu à l'avance, démarshaling dans une interface Le type {} n'est pas réalisable car il nécessite une implémentation du message protobuf interface.

Approche alternative

Lorsqu'au moins des informations partielles accompagnant la charge utile protobuf sont disponibles, comme une chaîne ou un nombre, vous pouvez l'utiliser comme clé pour instancier le type de protobuf concret approprié, puis effectuez le démarshaling.

Manipulation vraiment inconnue Messages

Si toutes les informations sur le type de message sont absentes, le package protowire peut être utilisé pour extraire des informations limitées du format filaire de la charge utile protobuf.

Risques et Limitations

L'analyse des messages proto inconnus présente certains défis :

• Représentation ambiguë :Le format filaire peut être ambigu, ce qui rend difficile la détermination du type exact de certaines structures de données.
• Perte d'informations sur les sous-champs : Les messages enveloppés peuvent perdre le contexte concernant le type de fil et le numéro d'étiquette, limitant potentiellement la capacité de reconstruire le message d'origine. structure.
• Exclusion des types non-proto : Les données non-proto telles que le JSON ou le XML encapsulé peuvent ne pas être capturées avec précision.

Exemple Implémentation

Le code ci-dessous fournit un exemple d'analyse d'un protobuf inconnu message :

package main

import (
    "fmt"

    "github.com/jhump/protoreflect/desc"
    "github.com/jhump/protoreflect/internal/strategy"
    "github.com/jhump/protoreflect/protopath"
)

// Field represents an individual element parsed from an unknown protobuf message.
type Field struct {
    Tag   Tag
    Val   interface{}
    Length int
}

// Tag represents a field tag with its number and wire type.
type Tag struct {
    Num  int32
    Type int
}

// parseUnknown parses an unknown protobuf message.
func parseUnknown(b []byte, parentMsg *desc.MessageDescriptor) []Field {
    parser := &protowireParser{msg: parentMsg, buf: b}
    return parser.run()
}

type protowireParser struct {
    msg *desc.MessageDescriptor
    buf []byte
}

const wireTypeMask = 0x7

func (p *protowireParser) run() (fields []Field) {
    for len(p.buf) > 0 {
        field, l, err := protowire.ConsumeField(p.buf)
        if err != nil || l < 1 {
            log.Printf("Error parsing field: %v", err)
            p.buf = nil
            return
        }

        tag := Tag{Num: field.Tag, Type: field.WireType & wireTypeMask}

        var v interface{}
        switch field.WireType & wireTypeMask {
        // ... handle different wire types
        }

        fields = append(fields, Field{Tag: tag, Val: v, Length: l})
        p.buf = p.buf[l:]
    }

    return fields
}

Conclusion

L'analyse des messages protobuf vraiment inconnus est une tâche complexe, mais en tirant parti du package protowire, vous pouvez extraire des informations limitées qui peuvent être suffisantes pour votre scénario spécifique. N'oubliez pas que cette approche ne convient pas aux applications de production où une représentation précise est essentielle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!