Is there a way to extract JSON from an http response without having to build structs?

All of the ways I'm seeing involve building structs and unmarshalling the data into the struct. But what if I'm getting JSON responses with hundreds of fields? I don't want to have to create 100 field structs just to be able to get to the data I want. Coming from a Java background there are easy ways to simply get the http response as a string and then pass the JSON string into a JSON object that allows for easy traversal. It's very painless. Is there anything like this in Go?

Java example in pseudo code:

<!--code: java -->

String json = httpResponse.getBody();
JsonObject object = new JsonObject(json); 
object.get("desiredKey");

Golang: fetch JSON from an HTTP response without using structs as helpers

This is a typical scenario we come across. This is achieved by json.Unmarshal.

Here is a simple json

<!-- language: javascript -->

{"textfield":"I'm a text.","num":1234,"list":[1,2,3]}

which is serialized to send across the network and unmarshaled at Golang end.

package main

import (
	"fmt"
	"encoding/json"
)

func main() {
    // replace this by fetching actual response body
	responseBody := `{"textfield":"I'm a text.","num":1234,"list":[1,2,3]}`
	var data map[string]interface{}
	err := json.Unmarshal([]byte(responseBody), &data)
	if err != nil {
   		panic(err)
	}
	fmt.Println(data["list"])
	fmt.Println(data["textfield"])
}

Hope this was helpful.

The json.Unmarshal method will unmarshal to a struct that does not contain all the fields in the original JSON object. In other words, you can cherry-pick your fields. Here is an example where FirstName and LastName are cherry-picked and MiddleName is ignored from the json string:

package main

import (
  "encoding/json"
  "fmt"
)
  
type Person struct {
  FirstName string `json:"first_name"`
  LastName  string `json:"last_name"`
}
  
func main() {
  jsonString := []byte("{\"first_name\": \"John\", \"last_name\": \"Doe\", \"middle_name\": \"Anderson\"}")

  var person Person
  if err := json.Unmarshal(jsonString, &person); err != nil {
    panic(err)
  }
  
  fmt.Println(person)
}

The other answers here are misleading, as they don't show you what happens if you try to go deeper in the Map. This example works fine enough:

package main

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

func main() {
   r, e := http.Get("https://github.com/manifest.json")
   if e != nil {
      panic(e)
   }
   body := map[string]interface{}{}
   json.NewDecoder(r.Body).Decode(&body)
   /*
   [map[
      id:com.github.android
      platform:play
      url:https://play.google.com/store/apps/details?id=com.github.android
   ]]
   */
   fmt.Println(body["related_applications"])
}

but if you try to go one level deeper, it fails:

/*
invalid operation: body["related_applications"][0] (type interface {} does not
support indexing)
*/
fmt.Println(body["related_applications"][0])

Instead, you would need to assert type at each level of depth:

/*
map[
   id:com.github.android
   platform:play
   url:https://play.google.com/store/apps/details?id=com.github.android
]
*/
fmt.Println(body["related_applications"].([]interface{})[0])

You can as well unmarshal it into a map[string]interface{}

body, err := ioutil.ReadAll(resp.Body)
map := &map[string]interface{}{}
json.Unmarshal(body, map)
desiredValue := map["desiredKey"]

The received json must have an object as the most outer element. The map can also contain lists or nested maps, depending on the json.