Consuming REST APIs In Golang

So main looks like this,

func main() {
    getPosts()
}

Our entire file is something like this.

package main
import("fmt"
    "io/ioutil"
    "net/http"
    "os")
func main() {
    getPosts()
}
func getPosts() {
    response,
    err: = http.Get("https://jsonplaceholder.typicode.com/posts")
    if err != nil {
        fmt.Print(err.Error())
        os.Exit(1)
    }
    responseData,
    err: = ioutil.ReadAll(response.Body)
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(string(responseData))
}

Now we will open our terminal in the same directory again and run the following command

go run main.go

Once we press enter we should see the output of our code in the console.

As you can see we got the response from HTTP Get Endpoint and it's printed in the console.

Now let’s convert this string response into a code object that we can use further.

We will create a struct with the properties of posts.

We will create an empty file called posts.go inside a folder named models,

Let’s take a look at our posts object,

{
    "userId": 1,
    "id": 1,
    "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
    "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
}

So according to this object our struct should have these four properties.

So our posts will look something like this,

package models
type Posts struct {
    UserId int `json:"userId"`
    Id int `json:"id"`
    Title string `json:"title"`
    Body string `json:"body"`
}

Here string inside `` represents which property of JSON should go bind the values from.

In the above code we can see UserId property of struct is binded to userId keyword from JSON.

Now we will unmarshal our JSON.

To use our Posts struct, we have to import its package which is models, so in order to do that we will write the following line in our main.go’s import section

"consume-rest-api/models"

Name of our application defined in go.mod and after it the package name.

Now we can write the code to unmarshal the JSON,

var responseObject []models.Posts 
json.Unmarshal(responseData, &responseObject)
fmt.Println(responseObject)

Here we just declared the array of Posts model, then we have used JSON library provided by go itself to call unmarshal method, which will convert the JSON data into the array of our struct type using the JSON keys that we have mentioned in our struct. After that we are just printing out the response object.

So now our entire file looks something like this.

package main
import("consume-rest-api/models"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os")
func main() {
    getPosts()
}
func getPosts() {
    response,
    err: = http.Get("https://jsonplaceholder.typicode.com/posts")
    if err != nil {
        fmt.Print(err.Error())
        os.Exit(1)
    }
    responseData,
    err: = ioutil.ReadAll(response.Body)
    if err != nil {
        fmt.Print(err)
    }
    var responseObject[] models.Posts
    json.Unmarshal(responseData, & responseObject)
    fmt.Println(responseObject)
}

Now try to run our code again using

go run main.go

As we can see values are getting printed from our Posts object now.

Now let’s quickly see the HTTP POST endpoint as well.

func savePosts() {
    post: = models.Posts {
        UserId: 1,
        Body: "Body",
        Title: "title",
    }
    json_data,
    err: = json.Marshal(post)
    if err != nil {
        fmt.Print(err)
    }
    response,
    err: = http.Post("https://jsonplaceholder.typicode.com/posts", "application/json", bytes.NewBuffer(json_data))
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(response.StatusCode)
}

Initially, we are declaring a post object and initializing it with some values.

Now after that we are marshalling our data using JSON library’s marshal method. It will transform our code object into the JSON data that is understood by the REST APIs.

We check for errors from that method.

After that, we call the http.Post method now.

Unlike http.Get which takes just one parameter URL, post takes three parameters.

First is URL of your REST API, second is the content type. Which is application/json in our case because we are using json data type. Third parameter is the actual data that we want to send over, so we take our json data and pass it to bytes.NewBuffer method.

After that we again check for errors and print out the status code.

If everything goes well then standard response for HTTP POST API is 201 which is for entity created.

So let’s try to run our code after calling this method in main and see the output.

As we can see we are getting the response status code as 201, which means we are consuming the post API properly.

Our entire file is,

package main
import("bytes"
    "consume-rest-api/models"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os")
func main() {
    getPosts()
    savePosts()
}
func getPosts() {
    response,
    err: = http.Get("https://jsonplaceholder.typicode.com/posts")
    if err != nil {
        fmt.Print(err.Error())
        os.Exit(1)
    }
    responseData,
    err: = ioutil.ReadAll(response.Body)
    if err != nil {
        fmt.Print(err)
    }
    var responseObject[] models.Posts
    json.Unmarshal(responseData, & responseObject)
    //fmt.Println(responseObject)
}
func savePosts() {
    post: = models.Posts {
        UserId: 1,
        Body: "Body",
        Title: "title",
    }
    json_data,
    err: = json.Marshal(post)
    if err != nil {
        fmt.Print(err)
    }
    response,
    err: = http.Post("https://jsonplaceholder.typicode.com/posts", "application/json", bytes.NewBuffer(json_data))
    if err != nil {
        fmt.Print(err)
    }
    fmt.Println(response.StatusCode)
}

Summary

In today’s article, we have seen how to consume REST APIs in golang. We consumed HTTP GET method and HTTP Post method here.

If you wish to see the code please click here!