golang network library usage

Golang is an efficient and reliable programming language, and its network library is also one of its powerful features. In the development of modern web applications and large-scale distributed systems, network communication is an integral part. Golang's network library provides some powerful components that allow developers to easily create network applications, including communication protocols such as TCP, UDP, HTTP, and WebSocket. In this article, we will focus on the usage methods and techniques of Golang's network library.

TCP communication

To perform TCP communication in Golang, you need to use the net package. The following is a simple TCP server implementation example:

package main

import (
    "fmt"
    "net"
)

func handleConnection(conn net.Conn) {
    // do something with connection
}

func main() {
    listener, err := net.Listen("tcp", "localhost:8080")
    if err != nil {
        panic(err)
    }
    defer listener.Close()

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting connection:", err.Error())
            continue
        }
        go handleConnection(conn)
    }
}

In the above code, we first create a TCP listener and accept connection requests in a loop. When a new connection request arrives, we will call the handleConnection function to handle the connection. In the handleConnection function, various operations can be performed on the connection. For example, you can read and write data, close connections, etc.

On the client side, we can use the Dial function to establish a connection:

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    // do something with connection
}

In the above code, we use the Dial function to establish a connection with the server. After the connection is successful, the connection can be operated like the server side.

UDP communication

Golang’s UDP communication is also implemented through the net package. The following is a simple UDP server implementation example:

package main

import (
    "fmt"
    "net"
)

func handleUDPConnection(conn *net.UDPConn, addr *net.UDPAddr, buf []byte) {
    // do something with connection
}

func main() {
    udpAddr, err := net.ResolveUDPAddr("udp", ":8080")
    if err != nil {
        panic(err)
    }

    conn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    for {
        buf := make([]byte, 1024)
        numBytes, addr, err := conn.ReadFromUDP(buf)
        if err != nil {
            fmt.Println("Error reading data:", err.Error())
            continue
        }
        go handleUDPConnection(conn, addr, buf[:numBytes])
    }
}

In the above code, we first create a UDP listener and accept connection requests in a loop. When a new connection request arrives, we will call the handleUDPConnection function to handle the connection. In the handleUDPConnection function, various operations can be performed on the connection. For example, you can read and write data, close connections, etc.

On the client side, we can also use the functions in the net package to communicate with the server:

package main

import (
    "fmt"
    "net"
)

func main() {
    udpAddr, err := net.ResolveUDPAddr("udp", "localhost:8080")
    if err != nil {
        panic(err)
    }

    conn, err := net.DialUDP("udp", nil, udpAddr)
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    // do something with connection
}

In the above code, we use the DialUDP function to establish a connection with the server. After the connection is successful, the connection can be operated like the server side.

HTTP communication

Golang’s standard library supports both http and https protocols. The following is a simple HTTP server implementation example:

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Through the above code, we have implemented a simple HTTP server. In it, we use the HandleFunc function in the http package to handle HTTP requests, and use ListenAndServe to start an HTTP server. In a production environment, we can use the TLS (HTTPS) protocol to ensure communication security.

On the client side, we can use the Client in the http package to send HTTP requests:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("http://localhost:8080")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(body))
}

In the above code, we use the Get function in the http package to send HTTP requests, and The response body was read. Of course, in actual applications, we can also use http.Client to customize HTTP requests.

WebSocket Communication

WebSocket is a full-duplex protocol commonly used in real-time applications (such as chat rooms, games, etc.). The net/http package of the Golang standard library also supports WebSocket communication. The following is a simple WebSocket server implementation example:

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/websocket"
)

func handleWebSocket(conn *websocket.Conn) {
    // do something with websocket connection
}

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        upgrader := websocket.Upgrader{}
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            fmt.Println(err.Error())
            return
        }
        go handleWebSocket(conn)
    })

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

In the above code, we create a WebSocket server and upgrade the request to a WebSocket connection. Moreover, the handleWebSocket function will be called for processing when each connection request arrives.

On the client side, we can use the standard WebSocket API to implement WebSocket communication:

package main

import (
    "fmt"
    "net/url"
    "time"

    "github.com/gorilla/websocket"
)

func main() {
    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/"}
    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    for {
        err = conn.WriteMessage(websocket.TextMessage, []byte("hello world"))
        if err != nil {
            panic(err)
        }

        time.Sleep(time.Second)
    }
}

In the above code, we use the gorilla/websocket library to implement WebSocket communication. After the connection is successfully established, we can send WebSocket messages and wait for WebSocket messages to be received. In practical applications, we can define various types of WebSocket messages as needed.

Through the above code, we can see that using the network library of the Golang standard library, we can easily implement communication with protocols such as TCP, UDP, HTTP and WebSocket. Moreover, through various standard library functions and goroutines, we can quickly handle various types of network requests and implement high-performance network applications.

The above is the detailed content of golang network library usage. For more information, please follow other related articles on the PHP Chinese website!