在 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 服务器。
本章节的代码
