Go语言中TCP/IP网络编程的深入讲解

前言

大家可能乍一看，通过tcp/ip层连接两个进程会感觉可怕， 但是在go语言中可能比你想象的要简单的多。下面话不多说了，来一起看看详细的介绍吧。

tcp/ip层发送数据的应用场景

当然很多情况下，不是大多数情况下，使用更高级别的网络协议毫无疑问会更好，因为可以使用华丽的api, 它们隐藏了很多技术细节。现在根据不同的需求，有很多选择，比如消息队列协议, grpc, protobuf, flatbuffers, restful网站api, websocket等等。

然而在一些特殊的场景下，特别是小型项目，选择任何其他方式都会感觉太臃肿了，更不用说你需要引入额外的依赖包了。

幸运的是，使用标准库的net包来创建简单的网络通信不比你所见到的要困难。

因为go语言中有下面两点简化。

简化1: 连接就是io流

net.conn接口实现了io.reader, io.writer和io.closer接口。 因此可以像对待其他io流一样对待tcp连接。

你可能会认为:"好，我能在tcp中发送字符串或字节分片，非常不错，但是遇到复杂的数据结构怎么办? 例如我们遇到的是结构体类型的数据?"

简化2: go语言知道如何有效的解码复杂的类型

当说到通过网络发送编码的结构化数据，首先想到的就是json。 不过先稍等一下 - go语言的标准库encoding/gob包提供了一种序列化和发序列话go数据类型的方法，它无需给结构体、go语言不兼容的json添加字符串标签, 或者等待使用json.unmarshal来费劲的将文本解析为二进制数据。

gob编码解码可以直接操作io流，这一点很完美的匹配第一条简化。

下面我们就通过这两条简化规则一起实现一个简单的app。

这个简单app的目标

这个app应该做两件事情:

• 发送和接收简单的字符串消息。
• 通过gob发送和接收结构体。

第一部分，发送简单字符串，将演示无需借助高级协议的情况下，通过tcp/ip网络发送数据是多么简单。

第二部分，稍微深入一点，通过网络发送完整的结构体，这些结构体使用字符串、分片、映射、甚至包含到自身的递归指针。

辛亏有gob包，要做到这些不费吹灰之力。

客户端                                        服务端

待发送结构体                                解码后结构体
teststruct结构体                            teststruct结构体
    |                                             ^
    v                                             |
gob编码       ---------------------------->     gob解码
    |                                             ^
    v                                             |  
   发送     ============网络=================    接收

通过tcp发送字符串数据的基本要素

发送端上

发送字符串需要三个简单的步骤:

• 打开对应接收进程的连接。
• 写字符串。
• 关闭连接。

net包提供了一对实现这个功能的方法。

• resolvetcpaddr(): 该函数返回tcp终端地址。
• dialtcp(): 类似于tcp网络的拨号。

这两个方法都是在go源码的src/net/tcpsock.go文件中定义的。

func resolvetcpaddr(network, address string) (*tcpaddr, error) {
 switch network {
 case "tcp", "tcp4", "tcp6":
 case "": // a hint wildcard for go 1.0 undocumented behavior
 network = "tcp"
 default:
 return nil, unknownnetworkerror(network)
 }
 addrs, err := defaultresolver.internetaddrlist(context.background(), network, address)
 if err != nil {
 return nil, err
 }
 return addrs.forresolve(network, address).(*tcpaddr), nil
}

resolvetcpaddr()接收两个字符串参数。

• network: 必须是tcp网络名，比如tcp, tcp4, tcp6。
• address: tcp地址字符串，如果它不是字面量的ip地址或者端口号不是字面量的端口号， resolvetcpaddr会将传入的地址解决成tcp终端的地址。否则传入一对字面量ip地址和端口数字作为地址。address参数可以使用host名称，但是不推荐这样做，因为它最多会返回host名字的一个ip地址。

resolvetcpaddr()接收的代表tcp地址的字符串(例如localhost:80, 127.0.0.1:80, 或[::1]:80, 都是代表本机的80端口), 返回(net.tcpaddr指针, nil)(如果字符串不能被解析成有效的tcp地址会返回(nil, error))。

func dialtcp(network string, laddr, raddr *tcpaddr) (*tcpconn, error) {
 switch network {
 case "tcp", "tcp4", "tcp6":
 default:
 return nil, &operror{op: "dial", net: network, source: laddr.opaddr(), addr: raddr.opaddr(), err: unknownnetworkerror(network)}
 }
 if raddr == nil {
 return nil, &operror{op: "dial", net: network, source: laddr.opaddr(), addr: nil, err: errmissingaddress}
 }
 c, err := dialtcp(context.background(), network, laddr, raddr)
 if err != nil {
 return nil, &operror{op: "dial", net: network, source: laddr.opaddr(), addr: raddr.opaddr(), err: err}
 }
 return c, nil
}

dialtcp()函数接收三个参数:

• network: 这个参数和resolvetcpaddr的network参数一样，必须是tcp网络名。
• laddr: tcpaddr类型的指针, 代表本地tcp地址。
• raddr: tcpaddr类型的指针，代表的是远程tcp地址。

它会连接拨号两个tcp地址，并返回这个连接作为net.tcpconn对象返回(连接失败返回error)。如果我们不需要对dial设置有过多控制，那么我们就可以使用dial()代替。

func dial(network, address string) (conn, error) {
 var d dialer
 return d.dial(network, address)
}

dial()函数接收一个tcp地址，返回一个一般的net.conn。 这已经足够我们的测试用例了。然而如果你需要只有在tcp连接上的可用功能，可以使用tcp变体(dialtcp, tcpconn, tcpaddr等等)。

成功拨号之后，我们就可以如上所述的那样，将新的连接与其他的输入输出流同等对待了。我们甚至可以将连接包装进bufio.readwriter中，这样可以使用各种readwriter方法，例如readstring(), readbytes, writestring等等。

func open(addr string) (*bufio.readwriter, error) {
 conn, err := net.dial("tcp", addr)
 if err != nil {
 return nil, errors.wrap(err, "dialing "+addr+" failed")
 }
 // 将net.conn对象包装到bufio.readwriter中
 return bufio.newreadwriter(bufio.newreader(conn), bufio.newwriter(conn)), nil
}

记住缓冲writer在写之后需要调用flush()方法, 这样所有的数据才会刷到底层网络连接中。
最后，每个连接对象都有一个close()方法来终止通信。

微调(fine tuning)

dialer结构体定义如下:

type dialer struct {
 timeout time.duration
 deadline time.time
 localaddr addr
 dualstack bool
 fallbackdelay time.duration
 keepalive time.duration
 resolver *resolver
 cancel <-chan struct{}
}

• timeout: 拨号等待连接结束的最大时间数。如果同时设置了deadline, 可以更早失败。默认没有超时。 当使用tcp并使用多个ip地址拨号主机名，超时会在它们之间划分。使用或不使用超时，操作系统都可以强迫更早超时。例如，tcp超时一般在3分钟左右。
• deadline: 是拨号即将失败的绝对时间点。如果设置了timeout, 可能会更早失败。0值表示没有截止期限， 或者依赖操作系统或使用timeout选项。
• localaddr: 是拨号一个地址时使用的本地地址。这个地址必须是要拨号的network地址完全兼容的类型。如果为nil, 会自动选择一个本地地址。
• dualstack: 这个属性可以启用rfc 6555兼容的"欢乐眼球(happy eyeballs) "拨号，当network是tcp时，address参数中的host可以被解析被ipv4和ipv6地址。这样就允许客户端容忍(tolerate)一个地址家族的网络规定稍微打破一下。
• fallbackdelay: 当dualstack启用的时候, 指定在产生回退连接之前需要等待的时间。如果设置为0， 默认使用延时300ms。
• keepalive: 为活动网络连接指定保持活动的时间。如果设置为0，没有启用keep-alive。不支持keep-alive的网络协议会忽略掉这个字段。
• resolver: 可选项，指定使用的可替代resolver。
• cancel: 可选通道，它的闭包表示拨号应该被取消。不是所有的拨号类型都支持拨号取消。 已废弃，可使用dialcontext代替。

有两个可用选项可以微调。

因此dialer接口提供了可以微调的两方面选项:

• deadline和timeout选项: 用于不成功拨号的超时设置。
• keepalive选项: 管理连接的使用寿命(life span)。

type conn interface {
 read(b []byte) (n int, err error)
 write(b []byte) (n int, err error)
 close() error
 localaddr() addr
 remoteaddr() addr
 setdeadline(t time.time) error
 setreaddeadline(t time.time) error
 setwritedeadline(t time.time) error
}

net.conn接口是面向流的一般的网络连接。它具有下面这些接口方法:

• read(): 从连接上读取数据。
• write(): 向连接上写入数据。
• close(): 关闭连接。
• localaddr(): 返回本地网络地址。
• remoteaddr(): 返回远程网络地址。
• setdeadline(): 设置连接相关的读写最后期限。等价于同时调用setreaddeadline()和setwritedeadline()。
• setreaddeadline(): 设置将来的读调用和当前阻塞的读调用的超时最后期限。
• setwritedeadline(): 设置将来写调用以及当前阻塞的写调用的超时最后期限。

conn接口也有deadline设置; 有对整个连接的(setdeadline())，也有特定读写调用的(setreaddeadline()和setwritedeadline())。

注意deadline是(wallclock)时间固定点。和timeout不同，它们新活动之后不会重置。因此连接上的每个活动必须设置新的deadline。

下面的样本代码没有使用deadline, 因为它足够简单，我们可以很容易看到什么时候会被卡住。ctrl-c时我们手动触发deadline的工具。

接收端上

接收端步骤如下:

• 对本地端口打开监听。
• 当请求到来时，产生(spawn)goroutine来处理请求。
• 在goroutine中，读取数据。也可以选择性的发送响应。
• 关闭连接。

监听需要指定本地监听的端口号。一般来说，监听应用程序(也叫server)宣布监听的端口号，如果提供标准服务, 那么使用这个服务对应的相关端口。例如，web服务通常监听80来伺服http, 443端口伺服https请求。 ssh守护默认监听22端口, whois服务使用端口43。

type listener interface {
 // accept waits for and returns the next connection to the listener.
 accept() (conn, error)

 // close closes the listener.
 // any blocked accept operations will be unblocked and return errors.
 close() error

 // addr returns the listener's network address.
 addr() addr
}

func listen(network, address string) (listener, error) {
 addrs, err := defaultresolver.resolveaddrlist(context.background(), "listen", network, address, nil)
 if err != nil {
 return nil, &operror{op: "listen", net: network, source: nil, addr: nil, err: err}
 }
 var l listener
 switch la := addrs.first(isipv4).(type) {
 case *tcpaddr:
 l, err = listentcp(network, la)
 case *unixaddr:
 l, err = listenunix(network, la)
 default:
 return nil, &operror{op: "listen", net: network, source: nil, addr: la, err: &addrerror{err: "unexpected address type", addr: address}}
 }
 if err != nil {
 return nil, err // l is non-nil interface containing nil pointer
 }
 return l, nil
}

net包实现服务端的核心部分是:

net.listen()在给定的本地网络地址上来创建新的监听器。如果只传端口号给它，例如":61000", 那么监听器会监听所有可用的网络接口。 这相当方便，因为计算机通常至少提供两个活动接口，回环接口和最少一个真实网卡。 这个函数成功的话返回listener。

listener接口有一个accept()方法用来等待请求进来。然后它接受请求，并给调用者返回新的连接。accept()一般来说都是在循环中调用，能够同时服务多个连接。每个连接可以由一个单独的goroutine处理，正如下面代码所示的。

代码部分

与其让代码来回推送一些字节，我更想要它演示一些更有用的东西。 我想让它能给服务器发送带有不同数据载体的不同命令。服务器应该能标识每个命令和解码命令数据。

我们代码中客户端会发送两种类型的命令: "string"和"gob"。它们都以换行符终止。

"string"命令包含一行字符串数据，可以通过bufio中的简单读写操作来处理。

"gob"命令由结构体组成，这个结构体包含一些字段，包含一个分片和映射，甚至指向自己的指针。 正如你所见，当运行这个代码时，gob包能通过我们的网络连接移动这些数据没有什么稀奇(fuss).

我们这里基本上都是一些即席协议(ad-hoc protocol: 特设的、特定目的的、即席的、专案的), 客户端和服务端都遵循它，命令行后面是换行，然后是数据。对于每个命令来说，服务端必须知道数据的确切格式，知道如何处理它。

要达到这个目的，服务端代码采取两步方式实现。

• 第一步: 当listen()函数接收到新连接，它会产生一个新的goroutine来调用handlemessage()。 这个函数从连接中读取命令名, 从映射中查询合适的处理器函数，然后调用它。
• 第二步: 选择的处理器函数读取并处理命令行的数据。

package main

import (
 "bufio"
 "encoding/gob"
 "flag"
 "github.com/pkg/errors"
 "io"
 "log"
 "net"
 "strconv"
 "strings"
 "sync"
)

type complexdata struct {
 n int
 s string
 m map[string]int
 p []byte
 c *complexdata
}

const (
 port = ":61000"
)

outcoing connections(发射连接)

使用发射连接是一种快照。net.conn满足io.reader和io.writer接口，因此我们可以将tcp连接和其他任何的reader和writer一样看待。

func open(addr string) (*bufio.readwriter, error) {
 log.println("dial " + addr)
 conn, err := net.dial("tcp", addr)

 if err != nil {
  return nil, errors.wrap(err, "dialing " + addr + " failed")
 }

 return bufio.newreadwriter(bufio.newreader(conn), bufio.newwriter(conn)), nil
}

打开tcp地址的连接。它返回一个带有超时的tcp连接，并将其包装进缓冲的readwriter。拨号远程进程。注意本地端口是实时(on the fly)分配的。如果必须指定本地端口号，请使用dialtcp()方法。

进入连接

这节有点涉及到对进入数据的准备环节处理。根据我们前面介绍的ad-hoc协议，命令名+换行符+数据+换行符。自然数据是和具体命令相关的。要处理这样的情况，我们创建了一个endpoint对象，它具有下面的属性:

• 它允许注册一个或多个处理器函数，每个函数可以处理一个特殊的命令。
• 它根据命令名将具体命令调度到相关的处理器函数。

首先我们声明一个handlefunc类型，该类型为接收一个bufio.readwriter指针值的函数类型， 也就是后面我们要为每种不同命令注册的处理器函数。它接收的参数是使用readwriter接口包装的net.conn连接。

type handlefunc func(*bufio.readwriter)

然后我们声明一个endpoint结构体类型，它有三个属性:

• listener: net.listen()返回的listener对象。
• handler: 用于保存已注册的处理器函数的映射。
• m: 一个互斥锁，用于解决map的多goroutine不安全的问题。

type endpoint struct {
 listener net.listener
 handler map[string]handlefunc
 m sync.rwmutex  // maps不是线程安全的，因此需要互斥锁来控制访问。
}

func newendpoint() *endpoint {
 return &endpoint{
  handler: map[string]handlefunc{},
 }
}

func (e *endpoint) addhandlefunc(name string, f handlefunc) {
 e.m.lock()
 e.handler[name] = f
 e.m.unlock()
}

func (e *endpoint) listen() error {
 var err error
 e.listener, err = net.listen("tcp", port)
 if err != nil {
  return errors.wrap(err, "unable to listen on "+e.listener.addr().string()+"\n")
 }
 log.println("listen on", e.listener.addr().string())
 for {
  log.println("accept a connection request.")
  conn, err := e.listener.accept()
  if err != nil {
   log.println("failed accepting a connection request:", err)
   continue
  }
  log.println("handle incoming messages.")
  go e.handlemessages(conn)
 }
}

// handlemessages读取连接到第一个换行符。 基于这个字符串，它会调用恰当的handlefunc。

func (e *endpoint) handlemessages(conn net.conn) {
 // 将连接包装到缓冲reader以便于读取
 rw := bufio.newreadwrite(bufio.newreader(conn), bufio.newwriter(conn))
 defer conn.close()

 // 从连接读取直到遇到eof. 期望下一次输入是命令名。调用注册的用于该命令的处理器。

 for {
  log.print("receive command '")
  cmd, err := rw.readstring('\n')
  switch {
  case err == io.eof:
   log.println("reached eof - close this connection.\n ---")
   return
  case err != nil:
   log.println("\nerror reading command. got: '" + cmd + "'\n", err)
  }

  // 修剪请求字符串中的多余回车和空格- readstring不会去掉任何换行。

  cmd = strings.trim(cmd, "\n ")
  log.println(cmd + "'")

  // 从handler映射中获取恰当的处理器函数, 并调用它。

  e.m.lock()
  handlecommand, ok := e.handler[cmd]
  e.m.unlock()

  if !ok {
   log.println("command '" + cmd + "' is not registered.")
   return
  }

  handlecommand(rw)
 }
}

newendpoint()函数是endpoint的工厂函数。它只对handler映射进行了初始化。为了简化问题，假设我们的终端监听的端口好是固定的。

endpoint类型声明了几个方法:

• addhandlefunc(): 使用互斥锁为handler属性安全添加处理特定类型命令的处理器函数。
• listen(): 对终端端口的所有接口启动监听。 在调用listen之前，至少要通过addhandlefunc()注册一个handler函数。
• handlemessages(): 将连接用bufio包装起来，然后分两步读取，首先读取命令加换行，我们得到命令名字。 然后通过handler获取注册的该命令对应的处理器函数, 然后调度这个函数来执行数据读取和解析。

.注意：上面如何使用动态函数的。 根据命令名查找具体函数，然后这个具体函数赋值给handlecommand, 其实这个变量类型为handlefunc类型, 即前面声明的处理器函数类型。

endpoint的listen方法调用之前需要先至少注册一个处理器函数。因此我们下面定义两个类型的处理器函数: handlestrings和handlegob。

handlestrings()函数接收和处理我们即时协议中只发送字符串数据的处理器函数。handlegob()函数是接收并处理发送的gob数据的复杂结构体。handlegob稍微复杂一点，除了读取数据外，我们海需要解码数据。

我们可以看到连续两次使用rw.readstring('n'), 读取字符串，遇到换行停止, 将读到的内容保存到字符串中。注意这个字符串是包含末尾换行的。

另外对于普通字符串数据来说，我们直接用bufio包装连接后的readstring来读取。而对于复杂的gob结构体来说，我们使用gob来解码数据。

func handlestrings(rw *bufio.readwriter) {
 log.print("receive string message:")
 s, err := rw.readstring('\n')
 if err != nil {
  log.println("cannot read from connection.\n", err)
 }

 s = strings.trim(s, "\n ")
 log.println(s)

 -, err = rw.writestring("thank you.\n")
 if err != nil {
  log.println("cannot write to connection.\n", err)
 }

 err = rw.flush()
 if err != nil {
  log.println("flush failed.", err)
 }
}

func handlegob(rw *bufio.readwriter) {
 log.print("receive gob data:")
 var data complexdata
  
 dec := gob.newdecoder(rw)
 err := dec.decode(&data)

 if err != nil {
  log.println("error decoding gob data:", err)
  return
 }

 log.printf("outer complexdata struct: \n%#v\n", data)
 log.printf("inner complexdata struct: \n%#v\n", data.c)
}

客户端和服务端函数

一切就绪，我们可以准备我们的客户端和服务端函数了。

客户端函数连接到服务器并发送string和gob请求。

服务端开始监听请求并触发恰当的处理器。

// 当应用程序使用-connect=ip地址的时候被调用

func client(ip string) error {
 teststruct := complexdata{
  n: 23,
  s: "string data",
  m: map[string]int{"one": 1, "two": 2, "three": 3},
  p: []byte("abc"),
  c: &complexdata{
   n: 256,
   s: "recursive structs? piece of cake!",
   m: map[string]int{"01": "10": 2, "11": 3},
  },
 }

 rw, err := open(ip + port)
 if err != nil {
  return errors.wrap(err, "client: failed to open connection to " + ip + port)
 }

 log.println("send the string request.")

 n, err := rw.writestring("string\n")
 if err != nil {
  return errors.wrap(err, "could not send the string request (" + strconv.itoa(n) + " bytes written)")
 }

 // 发送string请求。发送请求名并发送数据。

 log.println("send the string request.")

 n, err = rw.writestring("additional data.\n")
 if err != nil {
  return errors.wrap(err, "could not send additional string data (" + strconv.itoa(n) + " bytes written)")
 }

 log.println("flush the buffer.")
 err = rw.flush()
 if err != nil {
  return errors.wrap(err, "flush failed.")
 }

 // 读取响应

 log.println("read the reply.")

 response, err := rw.readstring('\n')
 if err != nil {
  return errors.wrap(err, "client: failed to read the reply: '" + response + "'")
 }

 log.println("string request: got a response:", response)
 
 // 发送gob请求。 创建一个encoder直接将它转换为rw.send的请求名。发送gob

 log.println("send a struct as gob:")
 log.printf("outer complexdata struct: \n%#v\n", teststruct)
 log.printf("inner complexdata struct: \n%#v\n", teststruct.c)
 enc := gob.newdecoder(rw)
 n, err = rw.writestring("gob\n")
 if err != nil {
  return errors.wrap(err, "could not write gob data (" + strconv.itoa(n) + " bytes written)")
 }

 err = enc.encode(teststruct)
 if err != nil {
  return errors.wrap(err, "encode failed for struct: %#v", teststruct)
 }

 err = rw.flush()
 if err != nil {
  return errors.wrap(err, "flush failed.")
 }
 return nil
}

客户端函数在执行应用程序时指定connect标志的时候执行，这点后面的代码可以看到。

下面是服务端程序server。服务端监听进来的请求并根据请求命令名将它们调度给注册的具体相关处理器。

func server() error {
 endpoint := newendpoint()
 // 添加处理器函数
 endpoint.addhandlefunc("string", handlestrings)
 endpoint.addhandlefunc("gob", handlegob)
 // 开始监听
 return endpoint.listen()
}

main函数

下面的main函数既可以启动客户端也可以启动服务端， 依赖于是否设置connect标志。 如果没有这个标志，则以服务器启动进程， 监听进来的请求。如果有标志， 启动为客户端，并连接到这个标志指定的主机。

可以使用localhost或127.0.0.1在同一机器上运行这两个进程。

func main() {
 connect := flag.string("connect", "", "ip address of process to join. if empty, go into the listen mode.")
 flag.parse()
 // 如果设置了connect标志，进入客户端模式
 if *connect != '' {
  err := client(*connect)
  if err != nil {
   log.println("error:", errors.withstack(err))
  }
  log.println("client done.")
  return
 }
 // 否则进入服务端模式
 err := server()
 if err != nil {
  log.println("error:", errors.withstack(err))
 }
 log.println("server done.")
}

// 设置日志记录的字段标志
func init() {
 log.setflags(log.lshortfile)
}

如何获取并运行代码

第一步: 获取代码。 注意-d标志自动安装二进制到$gopath/bin目录。

go get -d github.com/appliedgo/networking

第二步: cd到源代码目录。

cd $gopath/src/github.com/appliedgo/networking

第三步: 运行服务端。

go run networking.go

第四步: 打开另外一个shell, 同样进入到源码目录(第二步), 然后运行客户端。

go run networking.go -connect localhost

tips

如果你想稍微修改下源代码，下面是一些建议:

• 在不同机器运行客户端和服务端(同一个局域网中).
• 用更多的映射和指针来增强(beef up)complexdata, 看看gob如何应对它(cope with it)。
• 同时启动多个客户端，看看服务端是否能处理它们。

2017-02-09: map不是线程安全的，因此如果在不同的goroutine中使用同一个map, 应该使用互斥锁来控制map的访问。
而上面的代码，map在goroutine启动之前已经添加好了， 因此你可以安全的修改代码，在handlemessages goroutine已经运行的时候调用addhandlefunc()。

本章所学知识点总结

• bufio的应用。
• gob的应用。
• map在多goroutine间共享时是不安全的。

参考链接

• tcp/ip网络原文
• 简单的tcp服务端和客户端

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。