Go http Paket

Das net/http Paket der Go-Standardbibliothek ist hervorragend und bietet eine sehr vollständige Implementierung von HTTP-Client und -Server. Mit nur wenigen Zeilen Code kann ein sehr einfacher HTTP-Server erstellt werden.

Fast alle Web-Frameworks in Go sind Kapselungen und Modifikationen des vorhandenen http-Pakets. Daher wird dringend empfohlen, das http-Paket zu beherrschen, bevor man andere Frameworks lernt.

Get Beispiel

Wissen über HTTP wird hier nicht wiederholt. Für weitere Informationen können Sie bei Baidu nachschlagen.

func main() {
  resp, err := http.Get("https://baidu.com")
  if err != nil {
    fmt.Println(err)
    return
  }
  defer resp.Body.Close()
  content, err := io.ReadAll(resp.Body)
  fmt.Println(string(content))
}

Durch direkten Aufruf der Funktionen im http-Paket können einfache Anfragen gestellt werden. Es wird ein Zeiger und ein Fehler zurückgegeben. Nach dem Aufruf muss dieser manuell geschlossen werden.

Post Beispiel

func main() {
   person := Person{
      UserId:   "120",
      Username: "jack",
      Age:      18,
      Address:  "usa",
   }

   json, _ := json.Marshal(person)
   reader := bytes.NewReader(json)

   resp, err := http.Post("https://golang.org", "application/json;charset=utf-8", reader)
   if err != nil {
      fmt.Println(err)
   }
   defer resp.Body.Close()
}

Client

Normalerweise verwenden wir die oben genannten Methoden nicht direkt, sondern konfigurieren einen eigenen Client für detailliertere Anforderungen. Dazu wird die http.Client{} Struktur verwendet. Es gibt insgesamt vier Konfigurationsmöglichkeiten:

• Transport: Konfiguration der HTTP-Client-Datenübertragung. Wenn nicht angegeben, wird die Standardstrategie verwendet
• Timeout: Konfiguration der Anfrage-Timeout-Zeit
• Jar: Cookie-bezogene Konfiguration
• CheckRedirect: Umleitungskonfiguration

Einfaches Beispiel

func main() {
  client := &http.Client{}
  request, _ := http.NewRequest("GET", "https://golang.org", nil)
  resp, _ := client.Do(request)
  defer resp.Body.Close()
}

Header hinzufügen

func main() {
   client := &http.Client{}
   request, _ := http.NewRequest("GET", "https://golang.org", nil)
   request.Header.Add("Authorization","123456")
   resp, _ := client.Do(request)
   defer resp.Body.Close()
}

Detaillierte Konfigurationen werden hier nicht weiter erläutert. Bitte informieren Sie sich selbstständig.

Server

In Go genügt eine Zeile Code, um einen HTTP-Server zu erstellen.

Der erste Parameter ist die abzuhörende Adresse, der zweite Parameter ist der Handler. Wenn dieser leer ist, wird der Standard-Handler verwendet. In den meisten Fällen reicht der Standard-Handler DefaultServeMux aus.

http.ListenAndServe("localhost:8080", nil)

Anpassung

Natürlich können Sie auch einen Server selbst konfigurieren

func main() {
   server := &http.Server{
      Addr:              ":8080",
      Handler:           nil,
      TLSConfig:         nil,
      ReadTimeout:       0,
      ReadHeaderTimeout: 0,
      WriteTimeout:      0,
      IdleTimeout:       0,
      MaxHeaderBytes:    0,
      TLSNextProto:      nil,
      ConnState:         nil,
      ErrorLog:          nil,
      BaseContext:       nil,
      ConnContext:       nil,
   }
   server.ListenAndServe()
}

Detaillierte Konfigurationen bitte selbst nachschlagen.

Routing

Zuerst müssen Sie eine eigene Struktur definieren, die die ServeHTTP(ResponseWriter, *Request) Methode aus dem Handler Interface implementiert. Rufen Sie dann die http.handle() Funktion auf.

func main() {
   http.Handle("/index", &MyHandler{})
   http.ListenAndServe(":8080", nil)
}

type MyHandler struct {
}

func (h *MyHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
   fmt.Println("my implement")
}

Jedes Mal eine eigene Struktur zu definieren ist jedoch sehr umständlich. Sie können auch direkt die http.HandleFunc Funktion verwenden. Sie müssen nur die Handler-Funktion schreiben, ohne eine Struktur zu erstellen. Intern wird der Adapter-Typ HandlerFunc verwendet. Der HandlerFunc-Typ ist ein Adapter, der normale Funktionen als HTTP-Handler verwendet. Wenn f eine Funktion mit der entsprechenden Signatur ist, ist HandlerFunc(f) ein Handler, der f aufruft.

func main() {
   http.HandleFunc("/index", func(responseWriter http.ResponseWriter, request *http.Request) {
      fmt.Println(responseWriter, "index")
   })
   http.ListenAndServe(":8080", nil)
}

ServerMux ist die Kernstruktur, die die grundlegenden Methoden implementiert. DefaultServeMux ist die Standardinstanz.

Reverse Proxy

Das http-Paket bietet eine sofort einsatzbereite Reverse-Proxy-Funktion

func main() {
   http.HandleFunc("/forward", func(writer http.ResponseWriter, request *http.Request) {
      director := func(request *http.Request) {
         request.URL.Scheme = "https"
         request.URL.Host = "golang.org"
         request.URL.Path = "index"
      }

      proxy := httputil.ReverseProxy{Director: director}
      proxy.ServeHTTP(writer, request)

   })

   http.ListenAndServe(":8080", nil)
}

Der obige Code leitet alle Anfragen an https://golang.org/index weiter.