AI CSS Golang JavaScript Laravel Linux MongoDB MySQL PHP Python Rust Vue

Working with REST APIs in Go: Fetching, Searching, Creating, Updating, and Deleting Data

3 min read .

When working with APIs, performing HTTP requests to fetch, create, update, or delete data is a common task. While JavaScript’s fetch API makes these operations straightforward, Go provides its own set of tools to achieve similar results. We’ll explore how to perform these HTTP operations in Go using the net/http package.

Fetching Data

To fetch data from a REST API, you can use the http.Get function provided by the net/http package. This function sends a GET request and returns a response.

Example: Fetching All Products

package main

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

func main() {
    // Fetch all products
    response, err := http.Get("https://dummyjson.com/products")
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    var data map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
        log.Fatal(err)
    }

    fmt.Println(data)
}

Explanation:

  • http.Get sends a GET request to the specified URL.
  • The response body is read and decoded into a map[string]interface{} to handle the JSON data.

Example: Fetching Products with a Search Query

package main

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

func main() {
    // Fetch products with a search query
    response, err := http.Get("https://dummyjson.com/products/search?q=phone")
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    var data map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
        log.Fatal(err)
    }

    fmt.Println(data)
}

Explanation:

  • The query string q=phone is appended to the URL to filter the products.

Creating Data

To create new data, you can use the http.Post function or create a custom POST request with http.NewRequest.

Example: Adding a New Product

package main

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

func main() {
    // Define the product data
    product := map[string]interface{}{
        "title": "BMW Pencil",
        // Add other product data as needed
    }
    jsonData, err := json.Marshal(product)
    if err != nil {
        log.Fatal(err)
    }

    // Create the POST request
    response, err := http.Post("https://dummyjson.com/products/add", "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
        log.Fatal(err)
    }

    fmt.Println(result)
}

Explanation:

  • Data is encoded to JSON using json.Marshal.
  • http.Post sends a POST request with the JSON data in the body.

Updating Data

To update existing data, you use an HTTP PUT or PATCH request. Go’s http.NewRequest allows you to create these requests.

Example: Updating a Product

package main

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

func main() {
    // Define the updated product data
    updatedProduct := map[string]interface{}{
        "title": "iPhone Galaxy +1",
    }
    jsonData, err := json.Marshal(updatedProduct)
    if err != nil {
        log.Fatal(err)
    }

    // Create the PUT request
    req, err := http.NewRequest("PUT", "https://dummyjson.com/products/1", bytes.NewBuffer(jsonData))
    if err != nil {
        log.Fatal(err)
    }
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    response, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
        log.Fatal(err)
    }

    fmt.Println(result)
}

Explanation:

  • http.NewRequest creates a PUT request to update the product.
  • The Content-Type header is set to application/json.

Deleting Data

To delete data, you send an HTTP DELETE request using http.NewRequest.

Example: Deleting a Product

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    // Create the DELETE request
    req, err := http.NewRequest("DELETE", "https://dummyjson.com/products/1", nil)
    if err != nil {
        log.Fatal(err)
    }

    client := &http.Client{}
    response, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
        log.Fatal(err)
    }

    fmt.Println(result)
}

Explanation:

  • http.NewRequest creates a DELETE request.
  • The response body is decoded to handle any response data from the server.

Conclusion

Go’s net/http package provides powerful tools for making HTTP requests, allowing you to fetch, create, update, and delete data from APIs. Whether you’re retrieving data with http.Get, sending POST requests with http.Post, or managing updates and deletions with custom requests, Go’s HTTP handling capabilities offer flexibility and control for interacting with web services.

Tags:
Golang

See Also

Working with Pandas: A Beginner’s Guide

Pandas is a powerful library for data manipulation and analysis in Python. We’ll explore some fundamental operations you can perform using Pandas, including renaming columns, adding, updating, and deleting data, and sorting and filtering DataFrames.

Building a CRUD API with Go, Gin, MySQL and GORM

In this tutorial, we will create a simple CRUD (Create, Read, Update, Delete) API using Go with the Gin web framework, MySQL for database management, and GORM as the ORM (Object-Relational Mapping) library.

Checking If a File Exists in Go

In Go, determining whether a file exists is a common task that can be performed using the os package. This functionality is essential for various scenarios, such as validating file paths, managing file operations, and implementing error handling.

Checking if a Map Contains a Key in Go

Maps are a powerful data structure in Go, allowing you to associate keys with values for efficient lookup and retrieval. One common operation when working with maps is checking if a specific key exists.

Concatenating Multiple Slices in Go

In Go, slices are a versatile data structure that can be used to store collections of elements. Concatenating slices—i.e., combining multiple slices into one—can be useful in various scenarios, such as merging data or combining results from different sources.

Converting a String to an Integer in Go

In Go, converting a string to an integer is a common operation, especially when dealing with user input or data read from external sources.

chevron-up