Paquete http en Go

El paquete net/http de la biblioteca estándar de Go es excelente, proporcionando una implementación completa de clientes y servidores HTTP. Solo con unas pocas líneas de código se puede construir un servidor HTTP muy simple.

Casi todos los frameworks web en Go están basados en modificaciones y encapsulaciones del paquete http existente. Por lo tanto, se recomienda aprender y dominar el paquete http antes de estudiar otros frameworks.

Ejemplo Get

No se extenderá aquí sobre el conocimiento relacionado con Http. Si desea obtener más información, puede buscar en 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))
}

Se pueden realizar solicitudes simples llamando directamente a las funciones del paquete Http, que devolverán un puntero y un error. Debe cerrarse manualmente después de llamar.

Ejemplo 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

En general, no usamos directamente los métodos anteriores, sino que configuramos un cliente para satisfacer necesidades más detalladas. Esto utilizará la estructura http.Client{}, que tiene un total de cuatro elementos de configuración disponibles:

• Transport: Configuración relacionada con la transmisión de datos del cliente HTTP; si no hay, se adopta la estrategia predeterminada
• Timeout: Configuración del tiempo de espera de la solicitud
• Jar: Configuración relacionada con Cookies
• CheckRedirect: Configuración de redirección

Ejemplo simple

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

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

No se describirán en detalle algunas configuraciones detalladas aquí, le invitamos a que las consulte por su cuenta.

Servidor

Para Go, crear un servidor http solo requiere una línea de código.

El primer parámetro es la dirección de escucha, el segundo parámetro es el procesador. Si está vacío, se usa el procesador predeterminado. En la mayoría de los casos, se puede usar el procesador predeterminado DefaultServeMux.

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

Personalizado

Por supuesto, también puede configurar un 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()
}

Le invitamos a consultar por su cuenta algunas configuraciones detalladas.

Enrutamiento

Primero, debe definir una estructura que implemente el método ServeHTTP(ResponseWriter, *Request) en la interfaz Handler, y luego llamar a la función 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("mi implementación")
}

Pero cada vez que hay que definir una estructura será muy tedioso. También se puede usar directamente la función http.handlerFunc, solo necesitamos escribir la función de manejo, sin necesidad de crear una estructura. Internamente usa el tipo de adaptador HandlerFunc. El tipo HandlerFunc es un adaptador que permite que las funciones ordinarias se usen como procesadores HTTP. Si f es una función con la firma apropiada, HandlerFunc(f) es un Handler que llama a f.

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

ServerMux es la estructura central que implementa los métodos básicos, y DefaultServeMux es la instancia predeterminada.

Proxy inverso

El paquete http proporciona funcionalidad de proxy inverso lista para usar

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

El código anterior reenviará todas las solicitudes a https://golang.org/index.