How to program with TCP in Go?

Go language is a powerful programming language that provides numerous network programming libraries, including TCP/IP sockets. This article mainly introduces how to use Go language for TCP programming.

1. TCP/IP

TCP/IP is a protocol suite, which is the basis of network communication and the core protocol of the Internet. It is responsible for the transmission of data in the network. It includes two protocols, TCP and IP. TCP provides the reliability of datagram transmission, and IP is responsible for the forwarding of datagram transmission.

2. TCP Programming in Go

The net package in Go language provides related APIs for TCP programming, mainly including the following functions:

1. net .DialTCP(): Create a TCP connection;
2. net.ListenTCP(): Listen to a TCP port;
3. net.TCPConn(): Represent a TCP connection.

Below we will introduce how to use these functions for TCP programming.

1. Establishing a TCP connection

The client can use the net.DialTCP() function to establish a TCP connection to the server. The following is a sample code:

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    fmt.Println("Connected!")
}

In the above code, the first parameter of the DialTCP() function is the string "tcp" representing the network protocol type, and the second parameter is an address structure, using to the specified connection destination. Here we specify a connection to port 9999 on the local IP address 127.0.0.1. If the connection is successful, "Connected!" will be output.

2. Listen on TCP port

The server can use the net.ListenTCP() function to listen on a specific TCP port. The following is a sample code:

package main

import (
    "fmt"
    "net"
)

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()
    // TODO: 处理客户端请求
}

In the above code, the first parameter of the ListenTCP() function is the string "tcp" representing the network protocol type, and the second parameter is an address structure, using To specify the listening IP address and port number. Here we specify port 9999 to listen on all IP addresses. If the listening is successful, "Listening on port 9999" will be output.

Then, we call the AcceptTCP() function in an infinite loop to wait for the client to connect. When a client is connected, a new goroutine will be created to handle the client request, and "New client connected." will be output to the console.

3. TCP connection processing

The code for processing TCP connections is often more complex. Generally speaking, we need to use the bufio.NewReader() function to read the client's request data, and then use the bufio.NewWriter() function to write the response data.

The following is a sample code for handling TCP connections:

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

In the above code, we first create a bufio.NewReader() object to read the client request. After reading the data, we create a bufio.NewWriter() object to write the response data. Note that using the bufio.NewWriter() function to create a writer can cache output data and improve performance.

Finally, we use the WriteString() function to write the response data into the writer, and call the Flush() function to send the buffer data out.

3. Complete example

Finally, we demonstrate a complete TCP programming example, including client and server:

Server code:

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

Client code:

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    // 发送请求数据
    writer := bufio.NewWriter(conn)
    req := "Hello, server!
"
    _, err = writer.WriteString(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()

    // 接收响应数据
    reader := bufio.NewReader(conn)
    resp, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received response:", resp)
}

In the above code, the server first listens to port 9999, and then waits for the client to connect. When the client connects, the server reads the client request and then sends response data.

The client first establishes a TCP connection to the server, and then sends request data to the server. After sending the request, the client waits to receive response data from the server.

4. Summary

This article introduces how to use Go language for TCP programming. We learned the basics of the TCP/IP protocol, and then introduced how to implement TCP programming in the Go language using the API provided by the net package. At the same time, this article provides a complete example, I hope it will be helpful to readers.

The above is the detailed content of How to program with TCP in Go?. For more information, please follow other related articles on the PHP Chinese website!