Go package http

Le package net/http de la bibliothèque standard Go est excellent, fournissant une implémentation très complète du client et du serveur HTTP. Il permet de créer un serveur HTTP très simple avec seulement quelques lignes de code.

Presque tous les frameworks web en Go sont des encapsulations et modifications du package http existant. Il est donc fortement recommandé de maîtriser d'abord le package http avant d'apprendre d'autres frameworks.

Exemple Get

Les connaissances relatives à HTTP ne seront pas abordées ici. Pour en savoir plus, vous pouvez faire une recherche sur 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))
}

En appelant directement les fonctions du package HTTP, vous pouvez lancer des requêtes simples. Cela renvoie un pointeur et une erreur, et vous devez le fermer manuellement après l'appel.

Exemple 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

En général, nous n'utilisons pas directement les méthodes ci-dessus, mais nous configurons notre propre client pour des besoins plus précis. Cela utilisera la structure http.Client{}, qui offre quatre options de configuration :

• Transport : configuration liée au transfert de données du client HTTP, utilise la stratégie par défaut si non spécifié
• Timeout : configuration du délai d'expiration de la requête
• Jar : configuration liée aux cookies
• CheckRedirect : configuration de redirection

Exemple simple

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

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

Les configurations détaillées ne seront pas abordées ici, veuillez vous renseigner par vous-même.

Serveur

Pour Go, créer un serveur HTTP ne nécessite qu'une seule ligne de code.

Le premier paramètre est l'adresse d'écoute, le second est le gestionnaire. Si vide, le gestionnaire par défaut est utilisé. Dans la plupart des cas, le gestionnaire par défaut DefaultServeMux est suffisant.

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

Personnalisation

Bien sûr, vous pouvez également configurer un serveur personnalisé

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

Veuillez vous renseigner par vous-même pour les configurations détaillées.

Routage

D'abord, vous devez créer une structure personnalisée qui implémente la méthode ServeHTTP(ResponseWriter, *Request) de l'interface Handler, puis appeler la fonction 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")
}

Cependant, créer une structure personnalisée à chaque fois sera fastidieux. Vous pouvez également utiliser directement la fonction http.handlerFunc, nous avons juste besoin d'écrire la fonction de traitement, sans créer de structure. En interne, elle utilise le type adaptateur HandlerFunc. Le type HandlerFunc est un adaptateur qui permet d'utiliser des fonctions ordinaires comme gestionnaires HTTP. Si f est une fonction avec la signature appropriée, HandlerFunc(f) est un Handler qui appelle f.

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

ServerMux est la structure centrale qui implémente les méthodes de base. DefaultServeMux est l'instance par défaut.

Proxy inverse

Le package http fournit une fonctionnalité de proxy inverse prête à l'emploi

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

Le code ci-dessus transférera toutes les requêtes vers https://golang.org/index.