golang net request external

Golang is a powerful and reliable programming language that is favored by more and more developers. Among them, processing network requests is one of Golang's strengths. This article will discuss how Golang requests external network resources.

1. HTTP package in Golang

Golang standard library comes with HTTP package, which provides a client and a server to enable communication between them becomes very easy. The HTTP client provides an easy-to-use interface that allows users to make HTTP requests and get responses.

The following code demonstrates how to use HTTP packets to obtain the content of a web page:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("http://www.baidu.com")
    if err != nil {
        fmt.Println("Error:", err)
    }

    defer resp.Body.Close()

    fmt.Println(resp.Status)
}

In the above code, we call the http.Get() method to obtain the content of Baidu homepage, and then Assign the returned response and error to the two variables resp and err. If an access error occurs, the error message is output; if there is no error, the response body is closed and the response status code is output.

2. TCP package in Golang

If you need to do some tasks that HTTP is not capable of, the TCP package in Golang can play a role. This package provides a fully customizable network client and server, allowing users to communicate in any way they want.

The following is an example of using TCP packets to send data:

package main

import (
  "fmt"
  "net"
)

func main() {
  conn, err := net.Dial("tcp", "golang.org:80")
  if err != nil {
    fmt.Println("Error:", err)
  }

  fmt.Fprintf(conn, "GET / HTTP/1.0

")
  status, err := bufio.NewReader(conn).ReadString('
')

  fmt.Println(status)
}

In the above code, we use the net.Dial() method to create a TCP connection, specify the access protocol as HTTP, and access The address is golang.org:80. Next, we use the fmt.Fprintf() method to send the HTTP request to the established connection. Finally, we read the data from the response connection and output the response code to the terminal.

3. Third-party packages in Golang

In addition to the HTTP and TCP packages in the Golang standard library, there are many third-party packages to choose from, some of which provide A more flexible API with stronger functionality.

The following are several third-party packages worth mentioning:

3.1 Golang’s RESTful API client-----resty

resty is a light package in Golang A massive RESTful API client that supports HTTP and HTTPS and some basic authentication. Using resty makes requesting data over the HTTP network very easy. The following is an example of using resty to make HTTP requests:

package main

import (
    "fmt"
    "github.com/go-resty/resty/v2"
)

func main() {
    client := resty.New()
    resp, err := client.R().
        EnableTrace().
        Get("http://www.baidu.com")
    if err != nil {
        fmt.Println("Error:", err)
    }

    fmt.Println(resp.Body())
}

In the above code, we use the resty.New() method to create a resty client, and then use the client.R() method to send the request. Use the EnableTrace() method to turn on debugging tracing to facilitate subsequent debugging. Finally, we output the response body.

3.2 Golang’s HTTP framework-----Gin

Gin is a fast and flexible HTTP framework in Golang. Its performance is faster than other frameworks and has a middleware plug-in mechanism. , supports routing, console output, parameter parsing, form processing and other functions. The following is an example of using the Gin framework to handle HTTP requests:

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, World!")
    })

    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })

    r.Run(":8080")
}

In the above code, we use the gin.Default() method to create a predefined routing engine, and then use the r.GET() method to handle HTTP GET request. For the root route "/", we use the c.String() method to return "Hello, World!", for the route "/ping", we use the c.JSON() method to return the JSON format, and finally we use r.Run() Method to start Gin.

4. Summary

This article introduces how Golang requests external network resources, including HTTP and TCP packages and several third-party packages. Developers can choose a method that suits them according to their needs to make network requests, thereby efficiently completing the development of Golang applications.

The above is the detailed content of golang net request external. For more information, please follow other related articles on the PHP Chinese website!