大白话 golang 教程-17-网络编程和服务器

在 OSI 七层网络模型中，HTTP、DNS、FTP 等协议属于应用层的，往下 TCP、UDP 属于传输层协议，再往下是 IP、ICMP 等协议，通常说的网络编程主要基于 TCP、UDP 以及基于上层协议的应用。

在网络中依靠 IP 地址可以识别到一台主机，要定位都进程还需要加上端口号，两个不同主机上的进程要通讯还得语言互通，这就是协议。这种通讯在编程里经常成为 socket 编程，翻译为套接字编程，它把应用层和传输层中间做了一个抽象，把 TCP/IP 的复杂概念抽象成几个函数接口定义，实现了不同主机之间的进程通讯。这个 socket 套接字首先是在伯克利 BSD 系统里发扬光大，socket 本意是插座，有人觉得翻译为套接口更合适，既然是抽象的接口，也就是你不管使用哪个编程语言，都是一样的编程套路。

下面的代码演示了如何建一个 tcp 的服务端，它的作用是为客户端提供时间查询服务。

func handleClient(conn net.Conn) {  
  defer conn.Close()
  str := fmt.Sprintf("%s\n", time.Now().Format("2006-01-02 15:04:05"))
  conn.Write([]byte(str))
}

func startTcpServer() {
  listener, _ := net.Listen("tcp", "127.0.0.1:3000")
  defer listener.Close()
  for {
    conn, _ := listener.Accept()
    go handleClient(conn)
  }
}

为了简化代码，没有进行错误判断，startTcpServer 执行后开始 listen 监听本地的 3000 端口，然后陷入死循环等待客户端来连接，特别要注意的是 listen.Accept() 的调用将会等待连接，当有客户端连接的会后被系统唤醒，这时候将获得一个 net.Conn 对象，然后启动了一个协程去为客户端服务，因为 go 关键字的便利性，它已经可以和多个客户端通讯了，把当前时间通过 net.Conn 写入到套接字数据缓冲区后，它主动的关闭了 tcp 连接。

怎么测试呢? 不用着急写一个客户端，我们先用 telnet 命令来测试一下:

Desktop  telnet 127.0.0.1 3000
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
2021-01-09 17:09:00Connection closed by foreign host.

打印时间后，telnet 提示 "Connection closed by foreign host"，说明的确远程 server 主动把连接 close 掉了。

net.Listen 返回的是 net.Listener 接口对象，它定义了三个方法:

type Listener interface {
  Accept() (Conn, error)
  Close() error
  Addr() Addr
}

Accept 函数执行后得到 net.Conn 接口对象，它定义了如下方法:

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
}

总结一下编写 Tcp Server 的套路:

1. 获得一个 Listener 监听对象

2. 调用 Accept 等待客户端来连接

3. 连接建立后后往 Conn 对象里读和写数据

4. 不需要的时候可主动关闭连接

相对于 server 编写 client 则更加简单:

func startTcpClient() {
  conn, _ := net.Dial("tcp", "127.0.0.1:3000")
  buf := make([]byte, 100)
  conn.Read(buf)
  fmt.Println(string(buf))
}

使用 net.Dial 函数，请求与本机 3000 端口建立套接字连接，成功后获得 net.TCPConn 对象，接着从里面读取数据显示出来。

不过这两个例子太过于简单，真实的 tcp 通讯程序面临很多问题:

1. 服务端开启等待时候，可能端口被占用了或者被防火墙阻止，造成启动服务端失败

2. 由于 Server 端的负载能力或者网络不稳定，可能客户端请求建立连接会失败

3. 建立连接后，网络不稳定 Read 和 Write 函数可能不会按预期那样工作

4. tcp 是面向连接的协议，往往需要多次读写，但是每次读写的数据不一定是完整的业务内容(粘包、丢包)

5. 建立好的连接也可能因为网络因素被断开，需要实现心跳和自动重连机制保证软件的可用性

上面的代码看起来是顺序编程，很多语言编写高性能的网络程序，需要多进程+多线程+非阻塞 I/O 多路复用来实现，但在 go 运行时这一层，通过对 goroutine 和非阻塞 I/O 多路复用机制的抽象，真实的底层 socket 对象是非阻塞的，go 运行时拦截了底层的 socket 调用，通过调度 goroutine 来简化了用户层的代码编写，比如对 socket 发起 read 读数据操作，如果对应的 socket 文件描述符并没有数据可读，go 运行时把 socket 文件描述符加入监听器，同时 goroutine 也会被挂起，当 go 运行时收到了 socket 文件描述符 ready 的通知后，会立刻唤醒挂起的 goroutine，这个过程在读取 goroutine 的角度来看，好像自己被阻塞住了。

加一个循环来测试一下多客户端的情况:

func startTcpClient2() {
  for i := 0; i < 1024; i++ {
    conn, _ := net.Dial("tcp", "127.0.0.1:3000")
    log.Println(conn.LocalAddr().String() + " dial at " + time.Now().Format("15:04:05"))
  }
}

客户端建立连接后，我们打印出了本地通讯地址和建立连接的时间，为了程序运行的慢一点，给 Server 端加一个延迟，修改如下:

func startTcpServer2() {
  listener, _ := net.Listen("tcp", "127.0.0.1:3000")
  defer listener.Close()
  for {
    time.Sleep(5 * time.Second)
    conn, _ := listener.Accept()
    log.Println("Accept at " + time.Now().Format("15:04:05"))
    go handleClient(conn)
  }
}

服务端每 5 秒钟获取到一个客户端连接，测试代码:

func Test_acceptBacklog(t *testing.T) {
  go startTcpServer2()
  startTcpClient2()
}

启动客户端以后输出类似如下:

......
2021/01/10 13:05:09 127.0.0.1:61901 dial at 13:05:09
2021/01/10 13:05:09 127.0.0.1:61902 dial at 13:05:09
2021/01/10 13:05:09 127.0.0.1:61903 dial at 13:05:09
2021/01/10 13:05:09 127.0.0.1:61904 dial at 13:05:09
2021/01/10 13:05:09 127.0.0.1:61905 dial at 13:05:09
2021/01/10 13:05:09 127.0.0.1:61906 dial at 13:05:09
2021/01/10 13:05:09 127.0.0.1:61907 dial at 13:05:09
2021/01/10 13:05:09 127.0.0.1:61908 dial at 13:05:09
2021/01/10 13:05:14 Accept at 13:05:14
2021/01/10 13:05:15 127.0.0.1:61909 dial at 13:05:15
2021/01/10 13:05:19 Accept at 13:05:19
2021/01/10 13:05:19 127.0.0.1:61917 dial at 13:05:19
2021/01/10 13:05:24 Accept at 13:05:24
......

有没有发现很奇怪，客户端的 dial 在开始的时候很快建立了连接，但是到后来每隔 5 秒钟才能建立一个新链接，很奇怪吧? 这说明客户端的 dial 建立连接的行为和服务端的 accept 行为并不是同步的。事实上 accept 只是从建立好的连接里取出一个来，而同时等待 accept 处理的连接数受到系统的限制，在 mac 是上它的值是 kern.ipc.somaxconn，默认是 128 个，也就是服务端没有被 accept 的连接数最大是 128 个，所以一开始 server 端很快收到了 client 客户端的 128 个连接，客户端 dial 几乎立即成功，但是 server 端每隔 5 秒后才 accept 取出来一个连接进行处理，处理一个后才有一个坑位挪出来，所以达到 kern.ipc.somaxconn 的限制后 client 需要隔上 5 秒才能成功建立连接。

如果服务端一直没有坑位，那么客户端 dial 会发生超时错误。

func startTcpServer3() {
  listener, _ := net.Listen("tcp", "127.0.0.1:3000")
  defer listener.Close()
  select {}
}

func startTcpClient3() {
  for i := 0; i < 1024; i++ {
    _, err := net.Dial("tcp", "127.0.0.1:3000")
    // 设置超时时间
    //_, err := net.DialTimeout("tcp", "127.0.0.1:3000", 1*time.Second)
    if err != nil {
      fmt.Println(err)
    } else {
      fmt.Println("dial at " + time.Now().Format("2006-01-02 15:04:05"))
    }
  }
}

控制超时的等待时间可以使用 net.DialTimeout 函数，没有坑位的时候 dial 开始报超时错了:

......
dial at 2021-01-10 14:47:04
dial at 2021-01-10 14:47:04
dial at 2021-01-10 14:47:04
dial tcp 127.0.0.1:3000: i/o timeout
dial tcp 127.0.0.1:3000: i/o timeout
dial tcp 127.0.0.1:3000: i/o timeout
......

同样的读写也会有时间超时的问题，读写超时的时间使用以下三个函数设置:

1. SetDeadline(t time.Time)

2. SetReadDeadline(t time.Time)

3. SetWriteDeadline(t time.Time)

参数是一个 time.Time 类型，也就是从连接被 accept 到数据被完全读取必须在这个时间点内，因为它是一个准确的时间点，所以在每次读写之前都需要为其设置新的时间点。看下面这个例子:

func startServerWithTimeout() {
  listener, _ := net.Listen("tcp", "127.0.0.1:3000")
  defer listener.Close()
  for {
    conn, _ := listener.Accept()
    conn.SetDeadline(time.Now().Add(3 * time.Second))
    c := &client{conn, 3}
    go handle(c)
  }
}

接受连接后设置读写超时的时间是 3 秒钟，看看 handle 函数的处理:

type client struct {
  conn    net.Conn
  timeout int
}

func handle(c *client) {
  buf := make([]byte, 100)
  for {
    size, err := c.conn.Read(buf)
    if err != nil || size == 0 {
      fmt.Println(err)
      c.conn.Close()
      return
    }

    c.conn.SetDeadline(time.Now().Add(3 * time.Second))
    fmt.Println(string(buf))
  }
}

如果读成功了，就继续续命 3 秒，如果都失败了，就把链接关闭了。启动后用 telnet 连接，如果 3 秒钟输入任何字符回车发送给 server 端，那么连接可以一直存活下去，如果 3 秒内无数据，服务端显示 i/o timeout 然后连接被强行关闭。修改一下程序，使用通道来实现类似的功能，首先为 client 对象增加一个通道成员用于通讯:

type client struct {
  conn       net.Conn
  activeChan chan struct{}
  timeout    int
}

在 handle 每次读成功后都给通道发送一个信号:

func handle(c *client) {
  for {
    buf := make([]byte, 100)
    size, err := c.conn.Read(buf)
    if err == nil || size > 0 {
      c.activeChan <- struct{}{}
      fmt.Println(string(buf))
    }
  }
}

增加一个 goroutine 专门用于检测是否收到了信号，在指定的超时时间内没有信号，则主动关闭连接:

func alive(c *client) {
  for {
    select {
    case <-c.activeChan:
      fmt.Println("keep alive")
    case <-time.After(time.Duration(c.timeout) * time.Second):
      c.conn.Write([]byte("goodbye\n"))
      c.conn.Close()
    }
  }
}

启动服务器的代码如下，每次 accept 时，启动 2 个 goroutine 来服务一个客户端:

func startServerWithTimeout() {
  listener, _ := net.Listen("tcp", "127.0.0.1:3000")
  defer listener.Close()
  for {
    conn, _ := listener.Accept()
    c := &client{conn, make(chan struct{}), 3}
    go handle(c)
    go alive(c)
  }
}

使用 telnet 测试，3 秒内输入任意字符都可续命，否则超时被关闭，在 alive 中其实可以做很多需要成功读取后要处理的业务，通道的作用其实把连接读写的细节、业务处理、连接状态维护解耦了，这个模式很有用，在 go 网络编程中很常见。

tcp 是面向连接的通讯，适用于对数据传输要求非常高的场景，但是有些业务比如聊天、视频可以忽略偶尔的传输错误，这时候使用 udp 协议更为合适，它定义了无需连接就可以发送 IP 数据包的方法，一个客户端可以向任意的不同的服务器发送数据。

定义一个 udp server 如下:

func startUdpServer() {
  listener, _ := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 3000})
  buf := make([]byte, 100)
  for {
    size, remoteAddr, err := listener.ReadFromUDP(buf)
    if err == nil && size > 0 {
      fmt.Println(remoteAddr.String())
      fmt.Println(string(buf))
    }
  }
}

由于没有事前建立连接，udp 客户端在发送数据的时候需要指明本机的地址和远端的地址:

func startUdpClient() {
  ip := net.ParseIP("127.0.0.1")
  // 自动分配
  // local := &net.UDPAddr{IP: net.IPv4zero, Port: 1110}
  local := &net.UDPAddr{IP: ip, Port: 3001}
  remote := &net.UDPAddr{IP: ip, Port: 3000}
  conn, _ := net.DialUDP("udp", local, remote)
  defer conn.Close()
  conn.Write([]byte("can you hear me?\n"))
}

创建一个 http 应用服务器则比 tcp 和 udp 更加简单，毕竟它是最上层的一个封装:

func startHttpServer() {
  http.HandleFunc("/time", func(writer http.ResponseWriter, request *http.Request) {
    writer.Write([]byte(time.Now().String()))
  })

  http.HandleFunc("/headers", func(writer http.ResponseWriter, request *http.Request) {
    for key, headers := range request.Header {
      for _, val := range headers {
        fmt.Fprintf(writer, "%v:%v\n", key, val)
      }
    }
  })

  http.ListenAndServe(":3000", nil)
}

请求的对象被抽象成 http.Request，响应对象被抽象为 http.ResponseWriter，2 个路由:

1. /time 打印当前服务器时间

2. /headers 打印请求的 http 头

下面是 http.ListenAndServe 的实现:

func ListenAndServe(addr string, handler Handler) error {
  server := &Server{Addr: addr, Handler: handler}
  return server.ListenAndServe()
}

定义了一个 http.Server 结构体，调用它的同名方法，实现如下:

func (srv *Server) ListenAndServe() error {
  if srv.shuttingDown() {
    return ErrServerClosed
  }
  addr := srv.Addr
  if addr == "" {
    addr = ":http"
  }
  ln, err := net.Listen("tcp", addr)
  if err != nil {
    return err
  }
  return srv.Serve(ln)
}

本质还是启动一个 tcp 服务器，大量的工作都是在处理 http 协议头和对客户端响应数据(http.Request 对象比 http.ResponseWriter 对象复杂的多)，根据这个原理，你可以实现一个自己的 http 服务器。

本章节的代码 https://github.com/developdeveloper/go-demo/tree/master/17-network-socket