Pacote http em Go

O pacote net/http da biblioteca padrão da linguagem Go é excelente, fornecendo uma implementação completa de cliente e servidor HTTP. É possível criar um servidor HTTP muito simples com apenas algumas linhas de código.

Quase todos os frameworks web na linguagem Go são feitos com base em encapsulamentos e modificações do pacote http existente. Portanto, é altamente recomendável dominar o pacote http antes de aprender outros frameworks.

Exemplo Get

Não entrarei em detalhes sobre conhecimentos relacionados ao HTTP aqui. Se quiser saber mais, pode pesquisar no 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))
}

É possível fazer requisições simples chamando diretamente as funções do pacote Http, que retornará um ponteiro e um erro. Após chamar, é necessário fechá-lo manualmente.

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

Cliente

Geralmente, não usamos diretamente os métodos acima, mas configuramos um cliente para atender a necessidades mais detalhadas. Isso usará a struct http.Client{}, que possui quatro itens de configuração disponíveis:

• Transport: Configurações relacionadas à transmissão de dados do cliente HTTP; se não houver, usa a estratégia padrão
• Timeout: Configuração do tempo limite da requisição
• Jar: Configurações relacionadas a Cookies
• CheckRedirect: Configuração de redirecionamento

Exemplo Simples

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

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

Não entrarei em muitos detalhes sobre algumas configurações mais detalhadas aqui, sugiro que você pesquise por conta própria.

Servidor

Para Go, criar um servidor http requer apenas uma linha de código.

O primeiro parâmetro é o endereço de escuta, o segundo parâmetro é o processador. Se estiver vazio, usa o processador padrão. Na maioria dos casos, o processador padrão DefaultServeMux é suficiente.

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

Personalizado

Claro, também é possível configurar um servidor personalizado:

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

Consulte por conta própria para algumas configurações mais detalhadas.

Roteamento

Primeiro, é necessário definir uma struct personalizada que implemente o método ServeHTTP(ResponseWriter, *Request) da interface Handler, e então chamar a função 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("minha implementação")
}

No entanto, definir uma struct toda vez pode ser muito trabalhoso. Também é possível usar diretamente a função http.handlerFunc, onde só precisamos escrever a função de processamento, sem precisar criar uma struct. Internamente, usa o tipo adaptador HandlerFunc. O tipo HandlerFunc é um adaptador que permite usar funções comuns como processadores HTTP. Se f for uma função com a assinatura apropriada, HandlerFunc(f) é um Handler que chama f.

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

ServerMux é a struct central que implementa os métodos básicos, e DefaultServeMux é a instância padrão.

Proxy Reverso

O pacote http fornece funcionalidade de proxy reverso pronta para 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)
}

O código acima encaminhará todas as requisições para https://golang.org/index.