来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《调用第三方API的Go中API Handler》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

我正在构建一个 api 路由，需要向 go 中完全独立的外部 api 发出请求。我已经让它工作到我尝试将响应发送回客户端的程度，此时服务器根本没有响应。这是我正在做的一个非常简单的例子：

func myhandler(w http.responsewriter, r *http.request) {
    // ... get request body, etc.

    // make the external api call here:
    client := &http.client{}
    url := "https://some_api.com"
    req, _ := http.newrequest("get", url, nil)
    resp, err := client.do(req)
    if err != nil || resp.statuscode != 200 {
        fmt.println("error")
    }
    defer resp.body.close()

    // ... process the response from the external call
    
    // send a response back to my own api's client
    w.write([]byte("hello there"))
}

我很好地进入了处理程序。我向 some_api.com 发出 api 请求并获取数据，没有问题。完全没有错误。问题是 w.write() 没有向客户端发送任何内容。

如果我将 w.write([]byte("hi there")) 并立即返回之前调用 do client.do，则可以将文本发送回客户端。

这是怎么回事？我已尝试尽可能地隔离问题，但我无法实际显示任何错误。 w.write 如果是在外部 api 调用之后，则不会执行任何操作。

编辑 1

我尝试进一步简化代码以缩小问题范围，但我仍然无法成功。让我尝试更具体地说明我如何调用所有这些：

在我的处理程序中，我有以下代码：

func sendjson(w http.responsewriter, status int, message string, data interface{}) {
        w.header().set("content-type", "application/json")
        w.writeheader(status)
        err := json.newencoder(w).encode(&apiresponse{
            status: status,
            message: message,
            data: data,
        })
        if err != nil {
            fmt.println(err)
            http.error(w, err.error(), http.statusinternalservererror)
            return
        }
    }

    func myhandler(w http.responsewriter, r *http.request) {
        mylib := my_lib.new(token, secret)
        account := "512" // don't worry about this value
        if account == "" {
            // note: this works if account is empty
            sendjson(w, http.statusbadrequest, "invalid request", nil)
            return
        }
        events, err := mylib.getevents(account, "2023-09-01", "2023-10-31")
        if err != nil {
            // note: this does not happen because there's no error
            fmt.println("there's an error")
            sendjson(w, http.statusinternalservererror, "internal server error", nil)
        }
        fmt.println(events) // this does work and prints the data from the external api
       
        // and finally, this never happens if it runs after getevents runs.
        sendjson(w, http.statusok, "here's the data!", events)

这是 mylib 中的 getevents 方法

func New(token string, secret string) *API {
        return &API{
            client: &http.Client{
                Timeout: 30 * time.Second,
            },
            token: token,
            secret: secret,
        }
    }

    func (o *API) GetEvents(account string, startDate string, endDate string) ([]Event, error) {
        BaseUrl := "http://external-api.com"
        url := fmt.Sprintf("%s/v2/client/%s/event?startDate=%s&endDate=%s", BaseUrl, account, startDate, endDate)
        req, _ := http.NewRequest("GET", url, nil)
        req.Header.Add("token", o.Token)
        req.Header.Add("secret", o.Secret)

        // The line that breaks it all:
        resp, err := o.client.Do(req)
        fmt.Println(resp) // This prints the data from the API successfully

        // For simplicity sake in this code sample I'm just returning an empty array here.
        return []Event{}, err
    }

正确答案

需要将响应解组到 map/json 中，并在发出第三方 api 请求时在标头中添加内容类型。 注意：-（标头取决于第三方 api 是否需要 json/form/url-encoded/...）

对于响应，使用 json.newencoder() 返回一个写入 w 的新编码器

尝试下面的代码

package main

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



func handlepostrequest(w http.responsewriter, r *http.request) {
    
    client := &http.client{}
    method := "get"

    url := "https://some/api/path"
    req, err := http.newrequest(method, url, nil)

    if err != nil {
        fmt.println(err)
    }
    req.header.add("content-type", "application/json")

    res, err := client.do(req)
    if err != nil {
        fmt.println(err)
    }
    defer res.body.close()

    body, err := ioutil.readall(res.body)
    if err != nil {
        fmt.println(err)
        
    }
    
    jsonmap := make(map[string]interface{})
    _ = json.unmarshal(body, &jsonmap)
    json.newencoder(w).encode(jsonmap)
}

func main() {

    http.handlefunc("/post", handlepostrequest)
    fmt.println("hii")
    if err := http.listenandserve(":9090", nil); err != nil {
        log.fatal(err)
    }
}

第二个建议：-

使用超时上下文和通信响应通道。

package main

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

func makeReq(w http.ResponseWriter, r *http.Request, res chan<- string) {

    client := &http.Client{}
    url := "https://some/api/path"
    req, _ := http.NewRequest("GET", url, nil)
    resp, err := client.Do(req)
    if err != nil || resp.StatusCode != 200 {
        fmt.Println("error")
        res <- "error"
        return
    }
    defer resp.Body.Close()
    // w.Write([]byte("hello"))
    res <- "hello"
    return

}
func handlePostRequest(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
    defer cancel()
    respChannel := make(chan string, 1)
    defer close(respChannel)
    go makeReq(w, r, respChannel)
    select {
    case <-time.After(2 * time.Second):
        w.Write([]byte("Process Timeout"))
        return
    case <-ctx.Done():
        w.Write([]byte("Process Timeout"))
        return
    default:
        w.Write([]byte(<-respChannel))
        return
    }

}

func main() {

    http.HandleFunc("/post", handlePostRequest)
    fmt.Println("hii")
    if err := http.ListenAndServe(":9090", nil); err != nil {
        log.Fatal(err)
    }
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。