How to make API query in Golang

Golang is a relatively new programming language but has become the first choice among developers. Golang's high performance and concurrency make it an ideal choice when developing applications, especially when building scalable services. Golang's API query is a basic task. This article will introduce how to perform API query in Golang.

Introduction

API is the abbreviation of Application Programming Interface, and API query refers to the operation of using HTTP GET requests to access API endpoints to obtain data. The query API is required by many backend services, which typically provide response data in JSON or XML format.

In Golang, there are several ways to perform API queries. Using the standard library's net/http package is one of the most common methods. In addition, there are some third-party packages that can be used to perform API queries, such as grequests, gorequest, httpclient and resty.

Performing API queries using the standard library's net/http package

There are several steps required to perform API queries using the standard library's net/http package. First, you need to create an http client that will be used to access the API endpoint. In the following example, we will use http.DefaultClient:

func main() {
    resp, err := http.DefaultClient.Get("https://jsonplaceholder.typicode.com/posts/1")
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println(string(body))
}

In this example, we use http.DefaultClient to send a GET request that will access the specified API endpoint. We use the ReadAll function from the ioutil package to read the response body into a string and then print it to the console.

You can also use the http.NewRequest function to create a custom request, for example:

func main() {
    req, err := http.NewRequest("GET", "https://jsonplaceholder.typicode.com/posts/1", nil)
    if err != nil {
        log.Fatalln(err)
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }
    fmt.Println(string(body))
}

In this example, we use http.NewRequest to create a custom GET request that will access the specified API endpoint. We then perform the request using the http.DefaultClient.Do function and handle the response as in the previous example.

Using third-party packages for API queries

In addition to the net/http packages of the standard library, there are some third-party packages that can be used to perform API queries in Golang. Here are some of the most popular examples:

1. grequests

func main() {
    resp, err := grequests.Get("https://jsonplaceholder.typicode.com/posts/1", nil)
    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(resp.String())
}

In this example, we use the grequests package to send a GET request to the specified API endpoint and use resp. The String() method converts the response body to a string.

2. gorequest

func main() {
    resp, _, errs := gorequest.New().Get("https://jsonplaceholder.typicode.com/posts/1").End()

    if errs != nil {
        log.Fatalln(errs)
    }

    fmt.Println(resp)
}

In this example, we use the gorequest package to send a GET request to the specified API endpoint and use the resp variable to handle the response.

3. httpclient

func main() {
    client := httpclient.Defaults(httpclient.Map{
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:54.0) Gecko/20100101 Firefox/54.0",
    })
    resp, err := client.Get("https://jsonplaceholder.typicode.com/posts/1")

    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(resp)
}

In this example, we create a custom http client using the httpclient package and use that client to send a GET to the specified API endpoint ask. We use the resp variable to handle the response.

4. resty

func main() {
    client := resty.New()
    resp, err := client.R().Get("https://jsonplaceholder.typicode.com/posts/1")

    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(resp.String())
}

In this example, we use the resty package to create a custom http client and use that client to send a GET request to the specified API endpoint . We use the resp.String() function to convert the response body into a string.

Conclusion

In this article, we introduced how to make API queries in Golang using the net/http package of the standard library or a third-party package. For most API query scenarios, the standard library's net/http package works well enough, especially for simple GET requests. If you need to handle more complex requests and responses, you can try third-party packages such as grequests, gorequest, httpclient, and resty.

Using Golang for API queries can help you easily get data from web services, and Golang's high performance and concurrency make it ideal for handling large-scale data. In actual development, you can choose the method that best suits you to perform API queries based on your needs.

The above is the detailed content of How to make API query in Golang. For more information, please follow other related articles on the PHP Chinese website!