Golang lire du corps de la requête

Inspectant et en se moquant du corps de la requête

Lorsque vous lisez d'abord le corps, vous devez le stocker une fois que vous avez fini avec cela, vous pouvez définir un nouveau io.ReadCloser que le corps de la requête construite à partir des données d'origine. Alors, quand on avance dans la chaîne, le gestionnaire suivant peut lire le même corps.

Une option est de lire l'ensemble du corps à l'aide de ioutil.ReadAll(), qui vous donne le corps comme un octet tranche.

Vous pouvez utiliser octets.NewBuffer() pour obtenir une io.Lecteur à partir d'un octet tranche.

La dernière pièce manquante est de faire de la io.Reader un io.ReadCloser, parce que bytes.Buffer ne dispose pas d'un Close() méthode. Pour cela, vous pouvez utiliser ioutil.NopCloser() qui encapsule une io.Reader, et renvoie un io.ReadCloser, dont ajoutée Close() méthode sera un no-op (ne fait rien).

Notez que vous pouvez même modifier le contenu de l'octet tranche que vous utilisez pour créer le "nouveau" corps. Vous avez le plein contrôle sur elle.

^{Soins doivent être pris même si, comme il pourrait y avoir d'autres champs HTTP comme content-length et les sommes de contrôle qui peut devenir non valide si vous modifiez uniquement les données. Si par la suite des gestionnaires de vérifier ces, vous aussi, vous avez besoin de modifier ces trop!}

Inspection /modifier le corps de la réponse

Si vous aussi vous voulez lire le corps de la réponse, alors vous devez envelopper la http.ResponseWriter que vous obtenez, et passer le wrapper sur la chaîne. Ce wrapper peut mettre en cache les données envoyées, que vous pouvez inspecter après, sur la volée (par la suite à des gestionnaires d'écrire).

Ici est un simple ResponseWriter wrapper, qui met en cache les données, de sorte qu'il sera disponible après que la réparation gestionnaire retourne:

type MyResponseWriter struct {
    http.ResponseWriter
    buf *bytes.Buffer
}

func (mrw *MyResponseWriter) Write(p []byte) (int, error) {
    return mrw.buf.Write(p)
}

Noter que MyResponseWriter.Write() juste écrit les données dans un tampon. Vous pouvez également choisir de l'inspecter à la volée (dans le Write() méthode) et écrire les données directement sur le enveloppés intégrés/ResponseWriter. Vous pouvez même modifier les données. Vous avez le plein contrôle.

^{Soins doivent être prises à nouveau si, par la suite les gestionnaires peuvent aussi envoyer des en-têtes de réponse HTTP liée à la réponse de données –telles que la longueur, ou sommes– qui peut également devenir invalide si vous modifiez les données de réponse.}

Exemple complet

De mettre les morceaux ensemble, voici un exemple de travail:

func loginmw(handler http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        body, err := ioutil.ReadAll(r.Body)
        if err != nil {
            log.Printf("Error reading body: %v", err)
            http.Error(w, "can't read body", http.StatusBadRequest)
            return
        }

        //Work /inspect body. You may even modify it!

        //And now set a new body, which will simulate the same data we read:
        r.Body = ioutil.NopCloser(bytes.NewBuffer(body))

        //Create a response wrapper:
        mrw := &MyResponseWriter{
            ResponseWriter: w,
            buf:            &bytes.Buffer{},
        }

        //Call next handler, passing the response wrapper:
        handler.ServeHTTP(mrw, r)

        //Now inspect response, and finally send it out:
        //(You can also modify it before sending it out!)
        if _, err := io.Copy(w, mrw.buf); err != nil {
            log.Printf("Failed to send out response: %v", err)
        }
    })
}