Golang function tcp, udp, http and websocket processing methods

With the continuous development of Internet technology, network communication has become an essential modern skill. In this process, function (Function), as an efficient and flexible programming method, has become a tool favored by more and more programmers. Among these functions, the processing methods based on TCP, UDP, HTTP and WebSocket protocols are particularly important. Today, this article will focus on the Golang function processing methods under these four protocols.

1. Function processing method based on TCP protocol

TCP (Transmission Control Protocol) is a connection-oriented, reliable, byte stream-based transport layer protocol. In Golang, we can create a simple TCP server through the following code:

package main

import (
    "fmt"
    "net"
)

func main() {
    listener, err := net.Listen("tcp", "127.0.0.1:8080")
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        return
    }

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

func handleRequest(conn net.Conn) {
    buf := make([]byte, 1024)
    for {
        _, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Error reading:", err.Error())
            return
        }
        conn.Write([]byte("Hello, world!"))
    }
}

In the above code, we use the net package to create a TCP listener, and then use the Accept() method to wait for the client terminal connection. Next, we handle the connection in the handleRequest() function and send our response in the connection.

2. Function processing method based on UDP protocol

UDP (User Datagram Protocol) is a non-connection and unreliable transport layer protocol. In Golang, we can also easily create a simple UDP server, the code is as follows:

package main

import (
    "fmt"
    "net"
)

func main() {
    udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8080")
    if err != nil {
        fmt.Println("Error Resolving UDP address:", err.Error())
        return
    }

    conn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        fmt.Println("Error Listening:", err.Error())
        return
    }
    defer conn.Close()

    for {
        buf := make([]byte, 1024)
        _, remoteAddr, err := conn.ReadFromUDP(buf)
        if err != nil {
            fmt.Println("Error Reading:", err.Error())
            continue
        }
        conn.WriteToUDP([]byte("Hello, world!"), remoteAddr)
    }
}

3. Function processing method based on HTTP protocol

HTTP (Hypertext Transfer Protocol) is An application layer protocol used to transfer data between web browsers and web servers. In Golang, we can use the net/http package in the standard library to create a simple HTTP server. The code is as follows:

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

In the above code, we define a handler() function to handle HTTP request, and use http.HandleFunc() in the main() function to specify our handler. Finally, we use the http.ListenAndServe() method to start our server.

4. Function processing method based on WebSocket protocol

WebSocket is a full-duplex protocol, usually used to implement instant communication functions, such as online games, instant chat, etc. In Golang, we can use the gorilla/websocket package to create a WebSocket server. The code is as follows:

package main

import (
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return
    }
    defer conn.Close()

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            return
        }
        conn.WriteMessage(websocket.TextMessage, []byte("Hello, world!"))
    }
}

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

In the above code, we use the gorilla/websocket package to create a WebSocket server and define handler( ) function to handle WebSocket connections. Finally, we use the http.HandleFunc() and http.ListenAndServe() methods to start our server.

Summary

Whether it is TCP, UDP, HTTP or WebSocket protocol, Golang provides a rich function library to help us quickly build servers and handle various network communications. By learning the above four protocols and Golang's processing methods, I believe you will be able to better understand functional programming and be able to use Golang more flexibly to implement various network applications.

The above is the detailed content of Golang function tcp, udp, http and websocket processing methods. For more information, please follow other related articles on the PHP Chinese website!