首页 > Go语言 > Go语言网络编程 阅读:1,948

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 c.biancheng.net: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

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

爱面试的程序媛,一个分享面试经验的公众号。跟着站长一起学习,每天都有进步。

通俗易懂,深入浅出,定时分享程序员面试的那点事。

面试如何造火箭?工作如何拧螺丝?都在这个公号哦。

扫描二维码关注公众号,免费领取价值 1000 元的求职面试资料(限时免费)!

当你决定关注「爱面试的程序媛」,你已然超越了90%的程序员!

爱面试的程序媛二维码
微信扫描二维码关注