Pacchetto http di Go

Il pacchetto net/http della libreria standard di Go è eccellente, fornisce un'implementazione completa di client e server HTTP, e consente di creare un server HTTP molto semplice con solo poche righe di codice.

Quasi tutti i framework web nel linguaggio Go sono realizzati incapsulando e modificando il pacchetto http esistente, quindi è altamente consigliato imparare il pacchetto http prima di studiare altri framework.

Esempio Get

Qui non si approfondiranno le conoscenze relative a Http. Per saperne di più, si può cercare su Baidu.

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))
}

Chiamando direttamente le funzioni sotto il pacchetto Http si possono effettuare richieste semplici, verrà restituito un puntatore e un errore, e dopo la chiamata è necessario chiuderlo manualmente.

Esempio Post

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

In generale, non si utilizzano direttamente i metodi sopra menzionati, ma si configura un client per soddisfare esigenze più dettagliate. Questo richiederà l'utilizzo della struct http.Client{}, le opzioni di configurazione disponibili sono quattro:

• Transport: Configura le opzioni relative alla trasmissione dei dati del client Http, se non presente adotta la strategia predefinita
• Timeout: Configurazione del tempo di timeout della richiesta
• Jar: Configurazione relativa ai Cookie
• CheckRedirect: Configurazione del reindirizzamento

Esempio Semplice

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

Aggiungere Header

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()
}

Qui non si approfondiranno troppo le configurazioni dettagliate, si consiglia di informarsi autonomamente.

Server

Per Go, creare un server http richiede solo una riga di codice.

Il primo parametro è l'indirizzo di ascolto, il secondo è il gestore, se vuoto viene utilizzato il gestore predefinito. Nella maggior parte dei casi è sufficiente utilizzare il gestore predefinito DefaultServeMux.

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

Personalizzato

Naturalmente è possibile configurare manualmente un server

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()
}

Si consiglia di informarsi autonomamente sulle configurazioni dettagliate.

Routing

Per prima cosa è necessario definire una struct che implementi il metodo ServeHTTP(ResponseWriter, *Request) dell'interfaccia Handler, quindi chiamare la funzione http.handle().

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")
}

Tuttavia, dover definire ogni volta una struct sarà molto macchinoso, si può anche utilizzare direttamente la funzione http.handlerFunc, dobbiamo solo scrivere la funzione di gestione, senza dover creare una struct. Internamente utilizza il tipo adattatore HandlerFunc, il tipo HandlerFunc è un adattatore che consente di utilizzare funzioni ordinarie come gestori HTTP. Se f è una funzione con la firma appropriata, HandlerFunc(f) è un Handler che chiama f.

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

ServerMux è la struct centrale, implementa i metodi di base, DefaultServeMux è l'istanza predefinita.

Proxy Inverso

Il pacchetto http fornisce funzionalità di proxy inverso pronte all'uso

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)
}

Il codice sopra inoltrerà tutte le richieste a https://golang.org/index.