type request struct {
 method string
 url    string
 value  string
 ps     *params
}

type params struct {
 timeout     int //超時(shí)時(shí)間
 retry       int //重試次數(shù)
 headers     map[string]string
 contentType string
}

func (req *request) Do(result interface{}) ([]byte, error) {
 res, err := asyncCall(doRequest, req)
 if err != nil {
  return nil, err
 }

 if result == nil {
  return res, nil
 }

 switch req.ps.contentType {
 case "application/xml":
  if err := xml.Unmarshal(res, result); err != nil {
   return nil, err
  }
 default:
  if err := json.Unmarshal(res, result); err != nil {
   return nil, err
  }
 }

 return res, nil
}
type timeout struct {
 data []byte
 err  error
}


func doRequest(request *request) ([]byte, error) {
 var (
  req    *http.Request
  errReq error
 )
 if request.value != "null" {
  buf := strings.NewReader(request.value)
  req, errReq = http.NewRequest(request.method, request.url, buf)
  if errReq != nil {
   return nil, errReq
  }
 } else {
  req, errReq = http.NewRequest(request.method, request.url, nil)
  if errReq != nil {
   return nil, errReq
  }
 }
 // 這里的client沒(méi)有設(shè)置超時(shí)時(shí)間
 // 所以當(dāng)下面檢測(cè)到一次超時(shí)的時(shí)候，會(huì)重新又發(fā)起一次請(qǐng)求
 // 但是老的請(qǐng)求其實(shí)沒(méi)有被關(guān)閉，一直在執(zhí)行
 client := http.Client{}
 res, err := client.Do(req)
 ...
}

// 重試調(diào)用請(qǐng)求
// 當(dāng)超時(shí)的時(shí)候發(fā)起一次新的請(qǐng)求
func asyncCall(f func(request *request) ([]byte, error), req *request) ([]byte, error) {
 p := req.ps
 ctx := context.Background()
 done := make(chan *timeout, 1)

 for i := 0; i < p.retry; i++ {
  go func(ctx context.Context) {
   // 發(fā)送HTTP請(qǐng)求
   res, err := f(req)
   done <- &timeout{
    data: res,
    err:  err,
   }
  }(ctx)
  // 錯(cuò)誤主要在這里
  // 如果超時(shí)重試為3，第一次超時(shí)了，馬上又發(fā)起了一次新的請(qǐng)求，但是這里錯(cuò)誤使用了超時(shí)的退出
  // 具體看上面
  select {
  case res := <-done:
   return res.data, res.err
  case <-time.After(time.Duration(p.timeout) * time.Millisecond):
  }
 }
 return nil, ecode.TimeoutErr
}

func doRequest(request *request) ([]byte, error) {
 var (
  req    *http.Request
  errReq error
 )
 if request.value != "null" {
  buf := strings.NewReader(request.value)
  req, errReq = http.NewRequest(request.method, request.url, buf)
  if errReq != nil {
   return nil, errReq
  }
 } else {
  req, errReq = http.NewRequest(request.method, request.url, nil)
  if errReq != nil {
   return nil, errReq
  }
 }

 // 這里通過(guò)http.Client設(shè)置超時(shí)時(shí)間
 client := http.Client{
  Timeout: time.Duration(request.ps.timeout) * time.Millisecond,
 }
 res, err := client.Do(req)
 ...
}

func asyncCall(f func(request *request) ([]byte, error), req *request) ([]byte, error) {
 p := req.ps
 // 重試的時(shí)候只有上一個(gè)http請(qǐng)求真的超時(shí)了，之后才會(huì)發(fā)起一次新的請(qǐng)求
 for i := 0; i < p.retry; i++ {
  // 發(fā)送HTTP請(qǐng)求
  res, err := f(req)
  // 判斷超時(shí)
  if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
   continue
  }

  return res, err

 }
 return nil, ecode.TimeoutErr
}

srv := &http.Server{  
    ReadTimeout: 5 * time.Second,
    WriteTimeout: 10 * time.Second,
}

 
srv.ListenAndServe()

func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler

func handler(w http.ResponseWriter, r *http.Request) {
 time.Sleep(3 * time.Second)
 fmt.Println("測(cè)試超時(shí)")

 w.Write([]byte("hello world"))
}

func server() {
 srv := http.Server{
  Addr:         ":8081",
  WriteTimeout: 1 * time.Second,
  Handler:      http.TimeoutHandler(http.HandlerFunc(handler), 5*time.Second, "Timeout!\n"),
 }
 if err := srv.ListenAndServe(); err != nil {
  os.Exit(1)
 }
}

func httpClientTimeout() {
 c := &http.Client{
  Timeout: 3 * time.Second,
 }

 resp, err := c.Get("http://127.0.0.1:8081/test")
 fmt.Println(resp)
 fmt.Println(err)
}

func contextTimeout() {
 ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 defer cancel()

 req, err := http.NewRequest("GET", "http://127.0.0.1:8081/test", nil)
 if err != nil {
  log.Fatal(err)
 }

 resp, err := http.DefaultClient.Do(req.WithContext(ctx))
 fmt.Println(resp)
 fmt.Println(err)
}

func transportTimeout() {
 transport := &http.Transport{
  DialContext:           (&net.Dialer{}).DialContext,
  ResponseHeaderTimeout: 3 * time.Second,
 }

 c := http.Client{Transport: transport}

 resp, err := c.Get("http://127.0.0.1:8081/test")
 fmt.Println(resp)
 fmt.Println(err)
}