API端点在超时情况下是否会被重复调用？

大家好，今天本人给大家带来文章《API端点在超时情况下是否会被重复调用？》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

我有一个 go post api 端点，处理程序中的任务有些耗时（当我在本地运行它时，时间甚至可能是 2 分钟）。

在我的 fe 中，我调用 api 一次，它仅触发一次（在网络选项卡中，没有多个请求）(1)。 api 调用的运行时间有所不同，因为它根据一些动态数据运行。 但在 api 端，调用需要一些时间并成功，但不发送响应（在 fe 端仍然待处理）。然后处理程序立即再次运行（在 fe 端仍然待处理）并且逻辑再次运行。因此，由于逻辑原因，由于它已经运行，所以它失败了。然后该响应将作为 fe (1) 请求的响应返回。所以，逻辑是成功的，数据库被更新，但响应发送错误。

这是由于超时问题吗？如果是这样，我该如何解决这个问题？

我使用 go-chi 作为 go 框架，并针对 fe 做出反应。

r := chi.NewRouter()

r = helpers.AttachLoggerMiddleware(r, pretty)
r.Route("/apps", func(r chi.Router) {
    r.Post("/{id}/clone", service.Clone)
}


func (s *Service) Clone(w http.ResponseWriter, r *http.Request) {     
    fmt.Println("Calling Clone !!")
    //logic
}

这是 api 方法配置方式的示例

正确答案

您应该重新设计您的方法以使用 Long polling 机制，使用 WebSosket 或 JSON streaming 也将是一个选项。

一点解释：

您有一项耗时的任务（需要 2 分钟，如果您的应用程序有更多负载，则很确定可能需要更多时间）。因此，如果您使用简单的请求-响应方法，则会因超时问题而出现错误。

因此，使用建议的方法将更适合您的情况。

让我们看一下 websocket 示例：

在你的go代码中，你会有类似的东西（这只是一个赶上想法的例子，我不知道chi并使用github.com/gorilla/websocket和vanilla net/http，但我很确定你可以用 chi 做同样的事情）：

package main

import (
    "fmt"
    "github.com/gorilla/websocket"
    "log"
    "net/http"
    "time"
)

var upgrader = websocket.upgrader{
    readbuffersize:  1024,
    writebuffersize: 1024,
}

func main() {
    http.handlefunc("/ws", wshandler)
    
    panic(http.listenandserve(":8080", nil))
}

func wshandler(w http.responsewriter, r *http.request) {
    conn, err := upgrader.upgrade(w, r, nil)
    if err != nil {
        log.println(err)
        return
    }
    
    if err != nil {
        http.error(w, "could not open websocket connection", http.statusbadrequest)
    }
    
    go echo(conn)
}

func echo(conn *websocket.conn) {
    defer conn.close()
    m := ""
    
    err := conn.readjson(&m)
    if err != nil {
        fmt.println("error reading json", err)
    }
    
    // receive some data from your reactjs
    fmt.printf("got message: %#v\n", m)
    
    om := struct {
        mes string
    }{
        mes: "send to client",
    }
    
    // send some data
    if err = conn.writejson(om); err != nil {
        fmt.println(err)
    }
    
    // do some work in 2 min
    time.sleep(120 * time.second)
    
    // send some data
    if err = conn.writejson(om); err != nil {
        fmt.println(err)
    }
}

在您的 react js 应用程序中，您将拥有类似以下内容的内容：

import React, { useState } from "react";

function  App() {
  let isDone = false;
  const messages = []
  const ws = new WebSocket("wss://localhost:8080/ws");

  const apiCall = {
    mes: "Your json for server" 
  };

  ws.onopen = (event) => {
    ws.send(JSON.stringify(apiCall));
  };

  ws.onmessage = function (event) {
    const json = JSON.parse(event.data);
    messages.push(json)
    } catch (err) {
      console.log(err);
    }
  };
  
  ws.onclose = function (event) {
    isDone = true
  };



  const mess = messages.map((item) => {
    return (
      

        
 {item}
      
    );
  });

  return (
       

           
{mess}
           
 is work done?: {isDone}
 
       
 
   );
}

export default  App;

在此示例中，我们向服务器发送一些信息，并在工作完成时开始等待（当 ws 关闭时，isdone = true），同时接收一些消息（也许您的情况不需要）。

使用长轮询和 json 流来实现这个想法也是如此（我想你很容易在互联网上找到一些东西:)）

今天关于《API端点在超时情况下是否会被重复调用？》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！