首页 > 编程笔记 > Go语言笔记

Go语言TCP网络程序设计

TCP 工作在网络的传输层，它属于一种面向连接的可靠的通信协议。TCP 网络程序设计属于 C-S 模式，一般要设计一个服务器程序，一个或多个客户机程序。另外，TCP 是面向连接的通信协议，所以客户机要和服务器进行通信，首先要在通信双方之间建立通信连接。本节将详细讲解 TCP 网络编程服务器、客户机的设计原理和设计过程。

TCPAddr 地址结构体

在进行 TCP 网络编程时，服务器或客户机的地址使用 TCPAddr 地址结构体表示，TCPAddr 包含两个字段：IP 和 Port，形式如下：

type TCPAddr struct {
    IP IP
    Port int
}

函数 ResolveTCPAddr() 可以把网络地址转换为 TCPAddr 地址结构，该函数原型定义如下：

func ResolveTCPAddr(net, addr string) (*TCPAddr, error)

在调用函数 ResolveTCPAddr() 时，参数 net 是网络协议名，可以是“tcp”、“tcp4”或“tcp6”。参数 addr 是 IP 地址或域名，如果是 IPv6 地址则必须使用“[]”括起来。另外，端口号以“:”的形式跟随在 IP 地址或域名的后而，端口是可选的。例如：“www.google.com：80”或“127.0.0.1：21”。

还有一种特例，就是对于 HTTP 服务器，当主机地址为本地测试地址时 (127.0.0.1)，可以直接使用端口号作为 TCP 连接地址，形如“:80”。

函数 ResolveTCPAddr() 调用成功后返回一个指向 TCPAddr 结构体的指针，否则返回一个错误类型。

另外，TCPAddr 地址对象还有两个方法：Network() 和 String()，Network() 方法用于返回 TCPAddr 地址对象的网络协议名，比如“tcp”；String() 方法可以将 TCPAddr 地址转换成字符串形式。这两个方法原型定义如下：

func (a *TCPAddr) Network() string
func (a *TCPAddr) String() string

【示例 1】TCP 连接地址。
import(
    "fmt"
    "net"
    "os"
)
func main() {
    if len(os.Args) != 3 {
        fmt.Fprintf(os.Stderr, "Usage: %s networkType addr\n", os.Args[0])
        os.Exit(1)
    }
    networkType := os.Args[1]
    addr := os.Args[2]
    tcpAddr, err := net.ResolveTCPAddr(networkType, addr)
    if err != nil {
        fmt.Println("ResolveTCPAddr error: ", err.Error())
        os.Exit(1)
    }
    fmt.Println("The network type is: ", tcpAddr.Network())
    fmt.Println("The IP address is: ", tcpAddr.String())
    os.Exit(0)
}
编译并运行该程序，测试过程如下：

PS D:\code> go run .\main.go tcp www.xinbaoku.com:80
                     The network type is:  tcp
                     The IP address is:  61.240.154.115:80

TCPConn 对象

在进行 TCP 网络编程时，客户机和服务器之间是通过 TCPConn 对象实现连接的，TCPConn 是 Conn 接口的实现。TCPConn 对象绑定了服务器的网络协议和地址信息，TCPConn 对象定义如下：

type TCPConn struct {
    //空结构
)

通过 TCPConn 连接对象，可以实现客户机和服务器间的全双工通信。可以通过 TCPConn 对象的 Read() 方法和 Write() 方法，在服务器和客户机之间发送和接收数据。Read() 方法和 Write() 方法的原型定义如下：

func (c *TCPConn) Read(b []byte) (n int, err error)
func (c *TCPConn) Write(b []byte) (n int, err error)

Read() 方法调用成功后会返回接收到的字节数，调用失败返回一个错误类型；Write() 方法调用成功后会返回正确发送的字节数，调用失败返回一个错误类型。另外，这两个方法的执行都会引起阻塞。

TCP 服务器设计

前面讲了 Go语言网络编程和传统 Socket 网络编程有所不同，TCP 服务器的工作过程如下：

1) TCP 服务器首先注册一个公知端口，然后调用 ListenTCP() 函数在这个端口上创建一个 TCPListener 监听对象，并在该对象上监听客户机的连接请求。

2) 启用 TCPListener 对象的 Accept() 方法接收客户机的连接请求，并返回一个协议相关的 Conn 对象，这里就是 TCPConn 对象。

3) 如果返回了一个新的 TCPConn 对象，服务器就可以调用该对象的 Read() 方法接收客户机发来的数据，或者调用 Write() 方法向客户机发送数据了。

TCPListener 对象、ListenTCP() 函数的原型定义如下：

type TCPListener struct {
    //contains filtered or unexported fields
}
func ListenTCP(net string, laddr *TCPAddr) (*TCPListener, error)

在调用函数 ListenTCP() 时，参数 net 是网络协议名，可以是“tcp”、“tcp4”或“tcp6”。参数 laddr 是服务器本地地址，可以是任意活动的主机地址，或者是内部测试地址“127.0.0.1”。该函数调用成功，返回一个 TCPListener 对象；调用失败，返回一个错误类型。

TCPListener 对象的 Accept() 方法原型定义如下：       

func (l *TCPListener) Accept() (c Conn, err error)

Accept() 方法调用成功后，返回 TCPConn 对象；否则，返回一个错误类型。

服务器和客户机的通信连接建立成功后，就可以使用 Read() 和 Write() 方法收发数据。在通信过程中，如果还想获取通信双方的地址信息，可以使用 LocalAddr() 方法和 RemoteAddr() 方法来完成，这两个方法原型定义如下：

func (c *TCPConn) LocalAddr() Addr
func (c *TCPConn) RemoteAddr() Addr

LocalAddr() 方法会返回本地主机地址，RemoteAddr() 方法返回远端主机地址。

【示例 2】TCP Server 端设计，服务器使用本地地址，服务端口号为 5000。服务器设计工作模式采用循环服务器，对每一个连接请求调用线程 handleClient 来处理。
// TCP Server 端设计
package main

import(
    "fmt"
    "net"
    "os"
)
func main() {
    service := ":5000"
    tcpAddr, err := net.ResolveTCPAddr("tcp", service)
    checkError(err)
    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)
    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        handleClient(conn)
        conn.Close()
    }
}
func handleClient(conn net.Conn) {
    var buf [512]byte
    for {
        n, err := conn.Read(buf[0:])
        if err != nil {
            return
        }
        rAddr := conn.RemoteAddr()
    fmt.Println("Receive from client", rAddr.String(), string(buf[0:n]))
        _, err2 := conn.Write([]byte("Welcome client"))
        if err2 != nil {
            return
        }
    }
}
func checkError(err error) {
    if err != nil {
        fmt.Fprintf(os.Stderr, "Fatal error %s", err.Error())
        os.Exit(1)
    }
}

TCP 客户机设计

在 TCP 网络编程中，客户机的工作过程如下：

1) TCP 客户机在获取了服务器的服务端口号和服务地址之后，可以调用 DialTCP() 函数向服务器发出连接请求，如果请求成功会返回 TCPConn 对象。

2) 客户机调用 TCPConn 对象的 Read() 或 Write() 方法，与服务器进行通信活动。

3) 通信完成后，客户机调用 Close() 方法关闭连接，断开通信链路。

DialTCP() 函数原型定义如下：

Func DialTCP(net string, laddr, raddr *TCPAddr) (*TCPConn, error)

在调用函数 DialTCP() 时，参数 net 是网络协议名，可以是“tcp”、“tcp4”或“tcp6”。参数 laddr 是本地主机地址，可以设为 nil。参数 raddr 是对方主机地址，必须指定不能省略。函数调用成功后，返回 TCPConn 对象；调用失败，返回一个错误类型。

方法 Close() 的原型定义如下：

func (c *TCPConn) Close() error

该方法调用成功后，关闭 TCPConn 连接；调用失败，返回一个错误类型。

【示例 3】TCP Client 端设计，客户机通过内部测试地址“127.0.0.1”和端口 5000 和服务器建立通信连接。
// TCP Client端设计
package main

import(
    "fmt"
    "net"
    "os"
)
func main() {
    var buf [512]byte
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])
    }
    service := os.Args[1]
    tcpAddr, err := net.ResolveTCPAddr("tcp", service)
    checkError(err)
    conn, err := net.DialTCP("tcp", nil, tcpAddr)
    checkError(err)
    rAddr := conn.RemoteAddr()
    n, err := conn.Write([]byte("Hello server"))
    checkError(err)
    n, err = conn.Read(buf[0:])
    checkError(err)
    fmt.Println("Reply form server", rAddr.String(), string(buf[0:n]))
    conn.Close()
    os.Exit(0)
}
func checkError(err error) {
    if err != nil {
        fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
        os.Exit(1)
    }
}
编译并运行服务器端和客户端，测试过程如下：

启动服务器：go run .\main.go
客户机连接：go run .\client.go 127.0.0.1:5000
服务器响应：Receive from client 127.0.0.1:50813 Hello server
客户机接收：Reply form server 127.0.0.1:5000 Welcome client

从上述测试结果可以看出，服务器注册了一个公知端口 5000，而当客户机与服务器建立连接后，客户机会生成一个临时端口“50813”与服务器进行通信。服务器不管启动多少次端口号都是 5000，而客户机每一次重新启动端口号都不一样。

使用 Goroutine 实现并发服务器

前面的讲解中服务器设计采用循环服务器设计模式，这种服务器设计简单但缺陷明显。因为这种服务器一旦启动，就一直阻塞监听客户机的连接请求，直至服务器关闭。所以，循环服务器很耗费系统资源。

解决问题的方法是采用并发服务器模式，在这种模式中，对每一个客户机的连接请求，服务器都会创建一个新的进程、线程或者协程进行响应，而服务器还可以去处理其他任务。Goroutine 即协程是一种比线程更轻量级的任务单位，所以这里就使用 Goroutine 来实现并发服务器的设计。

【示例 4】并发服务器设计，服务器使用本地地址，服务端口号为 5000。服务器设计工作模式采用并发服务器模式，对每一个连接请求创建一个能调用 handleClient() 函数的 Goroutine 来处理。
// TCP Server 端设计
package main

import(
    "fmt"
    "net"
    "os"
)
func main() {
    service := ":5000"
    tcpAddr, err := net.ResolveTCPAddr("tcp", service)
    checkError(err)
    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)
    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        go handleClient(conn)   //创建 Goroutine
    }
}
func handleClient(conn net.Conn) {
    defer conn.Close()          //逆序调用 Close() 保证连接能正常关闭
    var buf [512]byte
    for {
        n, err := conn.Read(buf[0:])
        if err != nil {
            return
        }
        rAddr := conn.RemoteAddr()
    fmt.Println("Receive from client", rAddr.String(), string(buf[0:n]))
        _, err2 := conn.Write([]byte("Welcome client"))
        if err2 != nil {
            return
        }
    }
}
func checkError(err error) {
    if err != nil {
        fmt.Fprintf(os.Stderr, "Fatal error %s", err.Error())
        os.Exit(1)
    }
}
编译并运行服务器端和客户端，测试过程如下、：

启动服务器：go run .\main.go
客户机连接：go run .\client.go 127.0.0.1:5000
服务器响应：Receive from client 127.0.0.1:51369 Hello server
客户机接收：Reply form server 127.0.0.1:5000 Welcome client

通过测试可以发现，并发服务器可以同时响应多个客户机的连接请求，并能和多个客户机并发通信，尤其在多核心系统平台上，这种通信模式效率更高。而循环服务器只能按客户机的请求队列次序，一个一个地为客户机提供通信服务，通信效率低下。

所有教程

优秀文章