CODEWITHSUNDEEP
httpgowebweb-development-server
CrimsonKing
CrimsonKing

Reputation: 95

golang multiple parseBody for http.request

Hey there I would like to parse a http.resquest two times like below. When I parsed the Body the first time, the body will be closed. I need some help/hint what the best way is to handle this, do I have to create a copy of the request or is there a better way?

func myfunc(w http.ResponseWriter, req *http.Request) {
  err := parseBody(req, &type1){
  .....
  }

  err := parseBody(req, &type2){
  .....
  }
}

Thanks for help

Upvotes: 0

Views: 1709

Answers (2)

cn0047
cn0047

Reputation: 17071

It's true that you can read body only once and it's ok because to parse body more than once you don't have to read it more that one time. Let's consider simple example:

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type RequestData1 struct {
    Code   string `json:"code"`
    Status string `json:"status"`
}

type RequestData2 struct {
    Status  string `json:"status"`
    Message string `json:"message"`
}

func main() {
    http.HandleFunc("/post", post)
    http.ListenAndServe(":8080", nil)
}

If we use this code:

func post(w http.ResponseWriter, r *http.Request) {
    body1, err := ioutil.ReadAll(r.Body)
    if err != nil {
        panic(err)
    }
    rd1 := RequestData1{}
    err = json.Unmarshal(body1, &rd1)
    if err != nil {
        panic(err)
    }

    body2, err := ioutil.ReadAll(r.Body)
    if err != nil {
        panic(err)
    }
    rd2 := RequestData2{}
    err = json.Unmarshal(body2, &rd2)
    if err != nil {
        panic(err) // panic!!!
    }

    fmt.Printf("rd1: %+v \nrd2: %+v", rd1, rd2)
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`Look into console.`))
}

we will have panic: http: panic serving [::1]:54581: unexpected end of JSON input
but with next code:

func post(w http.ResponseWriter, r *http.Request) {
    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        panic(err)
    }

    rd1 := RequestData1{}
    err = json.Unmarshal(body, &rd1)
    if err != nil {
        panic(err)
    }

    rd2 := RequestData2{}
    err = json.Unmarshal(body, &rd2)
    if err != nil {
        panic(err)
    }

    fmt.Printf("rd1: %+v \nrd2: %+v", rd1, rd2)
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`Look into console.`))
}

all works! You can test it by issuing request:

curl -X POST 'http://localhost:8080/post' \
-H 'Content-Type: application/json' -d '{"code":"200", "status": "OK", "message": "200 OK"}'

Result will be:

rd1: {Code:200 Status:OK}
rd2: {Status:OK Message:200 OK}

Upvotes: 2

Adrian
Adrian

Reputation: 46432

When you read request.Body, you're reading the stream from the client (e.g. web browser). The client only sends the request once. If you want to parse it multiple times, read the whole thing out into a buffer (e.g. a []byte) and then parse that as many times as you want. Just be mindful of the potential memory use of many concurrent requests with large payloads, as you'll be holding the full payload in memory at least until you're fully done parsing it.

Upvotes: 0

Related Questions