Go网络编程

概述

网络协议

从应用的角度出发，协议可理解为“规则”，是数据传输和数据的解释的规则。假设，a、b双方欲传输文件。规定：

• 第一次，传输文件名，接收方接收到文件名，应答ok给传输方；
• 第二次，发送文件的尺寸，接收方接收到该数据再次应答一个ok；
• 第三次，传输文件内容。同样，接收方接收数据完成后应答ok表示文件内容接收成功。

由此，无论a、b之间传递何种文件，都是通过三次数据传输来完成。a、b之间形成了一个最简单的数据传输规则。双方都按此规则发送、接收数据。a、b之间达成的这个相互遵守的规则即为协议。

这种仅在a、b之间被遵守的协议称之为原始协议。

当此协议被更多的人采用，不断的增加、改进、维护、完善。最终形成一个稳定的、完整的文件传输协议，被广泛应用于各种文件传输过程中。该协议就成为一个标准协议。最早的ftp协议就是由此衍生而来。

典型协议

应用层: 常见的协议有http协议，ftp协议。

传输层: 常见协议有tcp/udp协议。

网络层: 常见协议有ip协议、icmp协议、igmp协议。

网络接口层: 常见协议有arp协议、rarp协议。

各个协议用途简述:

ip协议是因特网互联协议（internet protocol）

tcp传输控制协议（transmission control protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。

udp用户数据报协议（user datagram protocol）是osi参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务。

icmp协议是internet控制协议（internet control message protocol）它是tcp/ip协议族的一个子协议，用于在ip、器之间传递控制消息。

igmp协议是 internet 组管理协议（internet group management protocol），是因特网协议家族中的一个组播协议。该协议运行在主机和组播路由器之间。

arp协议是正向（address resolution protocol），通过已知的ip，寻找对应主机的mac地址。

rarp是反向地址转换协议，通过mac地址确定ip地址。

分层模型

网络分层架构

为了减少协议设计的复杂性，大多数网络模型均采用分层的方式来组织。每一层都有自己的功能，就像建筑物一样，每一层都靠下一层支持。每一层利用下一层提供的服务来为上一层提供服务，本层服务的实现细节对上层屏蔽。

造车比喻(协议分层)

减少复杂度，解耦

越下面的层，越靠近硬件；越上面的层，越靠近用户。至于每一层叫什么名字，对应编程而言不重要，但面试的时候，面试官可能会问每一层的名字。

业内普遍的分层方式有两种。osi七层模型 和tcp/ip四层模型。可以通过背诵两个口诀来快速记忆：

osi七层模型: 应、表、会、传、网、数、物

tcp/ip四层模型: 应、传、网、链

物理层: 主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输，到达目的地后再转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。

数据链路层： 定义了如何让格式化数据以帧为单位进行传输，以及如何让控制对物理介质的访问。这一层通常还提供错误检测和纠正，以确保数据的可靠传输。如：串口通信中使用到的115200、8、n、1

网络层: 在位于不同地理位置的网络中的两个主机系统之间提供连接和路径选择。internet的发展使得从世界各站点访问信息的用户数大大增加，而网络层正是管理这种连接的层。

传输层: 定义了一些传输数据的协议和端口号（www端口80等），如：tcp（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），udp（用户数据报协议，与tcp特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如qq聊天数据就是通过这种方式传输的）。 主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。

会话层: 通过传输层(端口号：传输端口与接收端口)建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是ip也可以是mac或者是主机名）。

应用层: 是最靠近用户的osi层。这一层为用户的应用程序（例如电子邮件、文件传输和终端仿真）提供网络服务。

层与协议

每一层都是为了完成一种功能，为了实现这些功能，就需要大家都遵守共同的规则。大家都遵守这规则，就叫做“协议”（protocol）。

网络的每一层，都定义了很多协议。这些协议的总称，叫“tcp/ip协议”。tcp/ip协议是一个大家族，不仅仅只有tcp和ip协议，它还包括其它的协议，如下图：

协议功能

链路层

以太网规定，连入网络的所有设备，都必须具有“网卡”接口。数据包必须是从一块网卡，传送到另一块网卡。通过网卡能够使不同的计算机之间连接，从而完成数据通信等功能。网卡的地址——mac 地址，就是数据包的物理发送地址和物理接收地址。

网卡对应到协议里面就是与链路层arp协议相关的

每个网卡有自己唯一的mac地址

arp可以帮助借助ip获取mac地址

rarp可以借助mac地址获取ip。

网络层

网络层的作用是引进一套新的地址，使得我们能够区分不同的计算机是否属于同一个子网络。这套地址就叫做“网络地址”，这是我们平时所说的ip地址。这个ip地址好比我们的手机号码，通过手机号码可以得到用户所在的归属地。

网络地址帮助我们确定计算机所在的子网络，mac 地址则将数据包送到该子网络中的目标网卡。网络层协议包含的主要信息是源ip和目的ip。

于是，“网络层”出现以后，每台计算机有了两种地址，一种是 mac 地址，另一种是网络地址。两种地址之间没有任何联系，mac 地址是绑定在网卡上的，网络地址则是管理员分配的，它们只是随机组合在一起。

网络地址帮助我们确定计算机所在的子网络，mac 地址则将数据包送到该子网络中的目标网卡。因此，从逻辑上可以推断，必定是先处理网络地址，然后再处理 mac 地址。

ip地址本质:2进制数。----点分十进制ip地址（string)

传输层

当我们一边聊qq，一边聊微信，当一个数据包从互联网上发来的时候，我们怎么知道，它是来自qq的内容，还是来自微信的内容？

也就是说，我们还需要一个参数，表示这个数据包到底供哪个程序（进程）使用。这个参数就叫做“端口”（port），它其实是每一个使用网卡的程序的编号。每个数据包都发到主机的特定端口，所以不同的程序就能取到自己所需要的数据。

端口就是在传输层指定的。

port -- 在一台主机上唯一标识一个进程

端口特点:

• 对于同一个端口，在不同系统中对应着不同的进程
• 对于同一个系统，一个端口只能被一个进程拥有

常用协议:tcp、udp

应用层

应用程序收到“传输层”的数据，接下来就要进行解读。由于互联网是开放架构，数据来源五花八门，必须事先规定好格式，否则根本无法解读。“应用层”的作用，就是规定应用程序的数据格式。

ftp、http、或自定义协议
对数据进行封装、解封装

通信过程

数据通信过程

封装: 应用层 ----------------- 传输层 ---------------- 网络层 ----------- 链路层

解封装: 链路层 ------------- 网路层 ------------- 传输层 ------------ 应用层

socket编程

什么是socket

socket，英文含义是【插座、插孔】，一般称之为套接字，用于描述ip地址和端口。可以实现不同程序间的数据通信。

socket起源于unix，而unix基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。socket就是该模式的一个实现，网络的socket数据传输是一种特殊的i/o，socket也是一种文件描述符。socket也具有一个类似于打开文件的函数调用：socket()，该函数返回一个整型的socket描述符，随后的连接建立、数据传输等操作都是通过该socket实现的。

套接字的内核实现较为复杂，不宜在学习初期深入学习，了解到如下结构足矣。

在tcp/ip协议中，“ip地址+tcp或udp端口号”唯一标识网络通讯中的一个进程。“ip地址+端口号”就对应一个socket。欲建立连接的两个进程各自有一个socket来标识，那么这两个socket组成的socket pair就唯一标识一个连接。因此可以用socket来描述网络连接的一对一关系。

常用的socket类型有两种：流式socket（sock_stream）和数据报式socket（sock_dgram）。流式是一种面向连接的socket，针对于面向连接的tcp服务应用；数据报式socket是一种无连接的socket，对应于无连接的udp服务应用。

socket是典型的双向全双工

网络应用程序设计模式

c/s模式

传统的网络应用设计模式，客户机(client)/服务器(server)模式。需要在通讯两端各自部署客户机和服务器来完成数据通信。

b/s模式

浏览器(browser)/服务器(server)模式。只需在一端部署服务器，而另外一端使用每台pc都默认配置的浏览器即可完成数据的传输。

优缺点

对于c/s模式来说，其优点明显。客户端位于目标主机上可以保证性能，将数据缓存至客户端本地，从而提高数据传输效率。且，一般来说客户端和服务器程序由一个开发团队创作，所以他们之间所采用的协议相对灵活。可以在标准协议的基础上根据需求裁剪及定制。例如，腾讯所采用的通信协议，即为ftp协议的修改剪裁版。

​ 因此，传统的网络应用程序及较大型的网络应用程序都首选c/s模式进行开发。如，知名的网络游戏魔兽世界。3d画面，数据量庞大，使用c/s模式可以提前在本地进行大量数据的缓存处理，从而提高观感。

​ c/s模式的缺点也较突出。由于客户端和服务器都需要有一个开发团队来完成开发。工作量将成倍提升，开发周期较长。另外，从用户角度出发，需要将客户端安插至用户主机上，对用户主机的安全性构成威胁。这也是很多用户不愿使用c/s模式应用程序的重要原因。

​ b/s模式相比c/s模式而言，由于它没有独立的客户端，使用标准浏览器作为客户端，其工作开发量较小。只需开发服务器端即可。另外由于其采用浏览器显示数据，因此移植性非常好，不受平台限制。如早期的偷菜游戏，在各个平台上都可以完美运行。

​ b/s模式的缺点也较明显。由于使用第三方浏览器，因此网络应用支持受限。另外，没有客户端放到对方主机上，缓存数据不尽如人意，从而传输数据量受到限制。应用的观感大打折扣。第三，必须与浏览器一样，采用标准http协议进行通信，协议选择不灵活。

​ 因此在开发过程中，模式的选择由上述各自的特点决定。根据实际需求选择应用程序设计模式。

tcp的c/s架构

服务器首先启动一个net.listen()，这个net.listen()从名字上看好像是启动一个监听，实际上这是由于套接字socket最早期设计的原因，在go语言设计的时候还是沿用了unix当初设计的思想，直接把函数名拿过来了，这个函数初学的同学都会有一个误解，认为它是监听，实际上它不是，这个listen()函数不是真正的监听客户端，要监听的话监听什么？要监听客户端和我的连接，但是这个listen不是监听客户端，而是我设置服务器监听的资源(ip、端口)，accept()才是真正监听的，那言外之意，监听嘛，我等着你对我进行访问吧，那就是说，你没访问我之前是不是应该一直处于等待状态，一会儿我们写程序看一下，是在listen()的时候等着还是在accept的时候等着，所以accept是表示接受的意思，当它accpet调用起来以后，它就等着客户端和我建立连接，比方说，图示上已经说了，它会阻塞等待用户建立连接，那言外之意，我没有用户建立连接之前它就一直阻塞在那里等待着，实际上监听是在accept的时候才发起的，当然accept不是无源之水，它必要listen设置好了连接方式(tcp还是udp)、ip地址以及端口以后才能阻塞去监听，当有一个客户端和服务器发起请求之后，我调accept()函数完成了，那就说明我服务器和客户端之间的连接建立好了，接来下干什么呢？进行数据传输，我建立好连接的目的就是为了进行数据传递，我们这里假定那一般实际上也是这样，客户端主动找服务器建立连接，连接建立好了，客户端先发送数据给服务器，服务器被动的接受客户端发来的请求，被动接受客户端请求数据，接受到了请求以后，服务器进行相应的分析处理，处理完以后把你要请求的数据回写回去，服务端read()是读取客户端发送过来的请求，write()是我把你的请求处理完之后再给你写回去，当这些都做完了，说明我们跟客户端的一次通信就完成了，那这个时候我们就可以关闭连接。当然如果你还想后续继续通信的话，这个close()关闭就要延迟。

客户端这个流程很简单，因为服务器先要站出来在那儿等着客户端和我建立连接，所以说，服务器就得先启动，客户端相当于是我得等你服务器启动起来以后你都准备好了，我在给你发送访问请求，客户端发送访问请求，也是调用一个函数，叫做net.dail()函数，这个dail()函数会对阻塞的accept()发送一个请求，如果服务器准备好，accept()返回的时候，dail也返回，咱们就说客户端和服务器建立好了连接，客户端先发送数据，所以客户端先是一个写操作，发送完数据，服务器那边读到客户端请求进行处理，处理完之后写回来，客户端再read()读取服务器写回来的数据，读完以后客户端也可以做简单处理，比方说我读到了以后，打印显示，完成了写，完成了读，一次跟网络端的通信也就完成了，客户端可以关闭连接，大致的流程就是这样。

前面说过，socket通信，既然要通信，至少得是一对，如上图所示，accpet()和dail()成功后都会返回一个socket。

其实listen()的时候也会创建一个socket，但是这个socket不是用于通信的，只是创建用于通信的socket,绑定ip地址和端口设置监听的

简单的c/s模型通信

server端

listen函数:

network: 选用的协议:tcp、udp 如: "tcp"或"udp"

address：ip地址+端口号 如: "127.0.0.1:8000"或":8000"

listener接口:

conn接口:

参看 中文帮助文档中的demo：

tcp服务器端代码:

package main

import (
    "fmt"
    "net"
)

func main() {
    //指定服务器 通信协议,ip地址,port. 创建一个用户监听的socket
    listener, err := net.listen("tcp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("服务器设置监听失败,原因是:%v\n", err)
        return
    }
    defer listener.close()

    fmt.println("服务器等待客户端建立连接...")
    //阻塞监听客户端连接请求,成功建立连接,返回用于通信的socket
    conn, err := listener.accept()
    if err != nil {
        fmt.printf("服务器监听失败,原因是:%v\n", err)
    }
    defer conn.close()

    fmt.println("服务器与客户端成功建立连接!!!")
    //读取客户端发送的数据
    buf := make([]byte, 1024)
    n, err := conn.read(buf)
    if err != nil {
        fmt.printf("conn read()错误,原因是:%v\n", err)
    }

    //处理数据 -- 打印
    fmt.println("服务器读到数据:", string(buf[:n]))
}

运行代码

利用nc模式客户端请求

再次查看运行的终端，可以发现已经成功建立了连接

我们用nc连接后，还可以发送数据

再次查看运行的终端

如图，在整个通信过程中，服务器端有两个socket参与进来，但用于通信的只有 conn 这个socket。它是由 listener创建的。隶属于服务器端。

client端

dial函数:

network: 选用的协议:tcp、udp 如: "tcp"或"udp"

address：ip地址+端口号 如: "127.0.0.1:8000"或":8000"

conn接口:

客户端代码:

package main

import (
    "fmt"
    "net"
)

func main() {

    //指定服务器ip+port创建 通信套接字
    conn, err := net.dial("tcp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("net.dial err:%v\n", err)
        return
    }
    defer conn.close()

    //主动写数据给服务器
    _, err = conn.write([]byte("are you ready?"))
    if err != nil {
        fmt.printf("conn.write err:%v\n", err)
        return
    }

    buf := make([]byte, 1024)
    //接受服务器回发的数据
    n, err := conn.read(buf)
    if err != nil {
        fmt.printf("conn.read err:%v\n", err)
        return
    }

    fmt.printf("服务器回发的数据为:%v\n", string(buf[:n]))
}

由于我们想要服务器端回写内容，所以需要修改一下之前的服务端代码

更新服务器端代码:

package main

import (
    "fmt"
    "net"
)

func main() {
    //指定服务器 通信协议,ip地址,port. 创建一个用户监听的socket
    listener, err := net.listen("tcp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("服务器设置监听失败,原因是:%v\n", err)
        return
    }
    defer listener.close()

    fmt.println("服务器等待客户端建立连接...")
    //阻塞监听客户端连接请求,成功建立连接,返回用于通信的socket
    conn, err := listener.accept()
    if err != nil {
        fmt.printf("服务器监听失败,原因是:%v\n", err)
    }
    defer conn.close()

    fmt.println("服务器与客户端成功建立连接!!!")
    //读取客户端发送的数据
    buf := make([]byte, 1024)
    n, err := conn.read(buf)
    if err != nil {
        fmt.printf("conn read()错误,原因是:%v\n", err)
    }

    //处理数据 -- 回写给客户端
    if string(buf[:n]) == "are you ready?" {
        conn.write([]byte("i am ready!!!"))
    } else {
        conn.write([]byte("i don`t know what you say!!!"))
    }
}

并发的c/s模型通信

并发server

现在已经完成了客户端与服务端的通信，但是服务端只能接收一个用户发送过来的数据，怎样接收多个客户端发送过来的数据，实现一个高效的并发服务器呢？

accept()函数的作用是等待客户端的链接，如果客户端没有链接，该方法会阻塞。如果有客户端链接，那么该方法返回一个socket负责与客户端进行通信。所以，每来一个客户端，该方法就应该返回一个socket与其通信，因此，可以使用一个死循环，将accept()调用过程包裹起来。

需要注意的是，实现并发处理多个客户端数据的服务器，就需要针对每一个客户端连接，单独产生一个socket，并创建一个单独的goroutine与之完成通信。

func main() {

    //创建监听套接字
    listener, err := net.listen("tcp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("net.listen() err:%v\n", err)
        return
    }
    defer listener.close()

    //监听客户端连接请求
    for {
        fmt.println("服务器等待客户端连接...")
        conn, err := listener.accept()
        if err != nil {
            fmt.printf("listener.accept() err:%v\n", err)
            return
        }
        //具体完成服务器和客户端的数据通信
        go handleconnect(conn)
    }
} 

将客户端的数据处理工作封装到handleconn方法中，需将accept()返回的socket传递给该方法，变量conn的类型为：net.conn。可以使用conn.remoteaddr()来获取成功与服务器建立连接的客户端ip地址和端口号：

客户端可能持续不断的发送数据，因此接收数据的过程可以放在for循环中，服务端也持续不断的向客户端返回处理后的数据。

func handleconnect(conn net.conn) {
    defer conn.close()
    //获取连接的客户端 addr

    addr := conn.remoteaddr()
    fmt.println(addr, "客户端成功连接!")
    //循环读取客户端发送数据
    buf := make([]byte, 1024)
    for {
        //注意，read读取时，会将命令行里的换行符也给读取了，在*unix上换行符是\n,在windows上时\r\n
        n, err := conn.read(buf)
        if err != nil {
            if err == io.eof {
                fmt.println("客户端退出了!!!")
                break
            } else {
                fmt.printf("conn.read() err:%v\n", err)
                return
            }
        }
        fmt.printf("服务器读到数据:%v", string(buf[:n]))
        //小写转大写,回发给客户端
        conn.write(bytes.toupper(buf[:n]))
    }
}

并发client

客户端不仅需要持续的向服务端发送数据，同时也要接收从服务端返回的数据。因此可将发送和接收放到不同的协程中。

主协程循环接收服务器回发的数据（该数据应已转换为大写），并打印至屏幕；子协程循环从键盘读取用户输入数据，写给服务器。读取键盘输入可使用 os.stdin.read(str)。定义切片str，将读到的数据保存至str中。

这样，客户端也实现了多任务。

客户端代码:

package main

import (
    "fmt"
    "io"
    "net"
    "os"
)

func main() {

    //发起连接请求
    conn, err := net.dial("tcp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("net.dial() err:%v\n", err)
        return
    }
    defer conn.close()

    //获取用户键盘输入(os.stdin),并将输入数据发送给服务器
    go func() {
        str := make([]byte, 1024)
        for {
            n, err := os.stdin.read(str)
            if err != nil {
                fmt.printf("os.stdin.read() err:%v\n", err)
                continue
            }
            //写给服务器,读多少,写多少
            conn.write(str[:n])
        }
    }()

    for {
        buf := make([]byte, 1024)
        n, err := conn.read(buf)
        if err != nil {
            if err == io.eof {
                fmt.println("服务端退出了!!!")
                return
            } else {
                fmt.printf("conn.read() err:%v\n", err)
                continue
            }
        }
        fmt.printf("客户端读到服务器回发数据:%s",buf[:n])
    }
}

tcp通信

下图是一次tcp通讯的时序图。tcp连接建立断开。包含大家熟知的三次握手和四次挥手。

在这个例子中，首先客户端主动发起连接、发送请求，然后服务器端响应请求，然后客户端主动关闭连接。两条竖线表示通讯的两端，从上到下表示时间的先后顺序。注意，数据从一端传到网络的另一端也需要时间，所以图中的箭头都是斜的。

三次握手

所谓三次握手（three-way handshake）即建立tcp连接，就是指建立一个tcp连接时，需要客户端和服务端总共发送3个包以确认连接的建立。好比两个人在打电话：

client: "喂，你能听得到吗？"

server: "我听得到，你听得到我吗？"

client: "我能听到你，今天balabala..."

建立连接(三次握手)的过程:

1. 客户端发送一个带syn标志的tcp报文到服务器。这是上图中三次握手过程中的段1。客户端发出syn位表示连接请求。序号是1000，这个序号在网络通讯中用作临时的地址，每发一个数据字节，这个序号要加1，这样在接收端可以根据序号排出数据包的正确顺序，也可以发现丢包的情况。
   另外，规定syn位和fin位也要占一个序号，这次虽然没发数据，但是由于发了syn位，因此下次再发送应该用序号1001。
   mss表示最大段尺寸，如果一个段太大，封装成帧后超过了链路层的最大长度，就必须在ip层分片，为了避免这种情况，客户端声明自己的最大段尺寸，建议服务器端发来的段不要超过这个长度。
2. 服务器端回应客户端，是三次握手中的第2个报文段，同时带ack标志和syn标志。表示对刚才客户端syn的回应；同时又发送syn给客户端，询问客户端是否准备好进行数据通讯。
   服务器发出段2，也带有syn位，同时置ack位表示确认，确认序号是1001，表示“我接收到序号1000及其以前所有的段，请你下次发送序号为1001的段”，也就是应答了客户端的连接请求，同时也给客户端发出一个连接请求，同时声明最大尺寸为1024。
3. 客户必须再次回应服务器端一个ack报文，这是报文段3。
   客户端发出段3，对服务器的连接请求进行应答，确认序号是8001。在这个过程中，客户端和服务器分别给对方发了连接请求，也应答了对方的连接请求，其中服务器的请求和应答在一个段中发出。

因此一共有三个段用于建立连接，称为“三方握手”。在建立连接的同时，双方协商了一些信息，例如，双方发送序号的初始值、最大段尺寸等。

数据传输的过程:

1. 客户端发出段4，包含从序号1001开始的20个字节数据。
2. 服务器发出段5，确认序号为1021，对序号为1001-1020的数据表示确认收到，同时请求发送序号1021开始的数据，服务器在应答的同时也向客户端发送从序号8001开始的10个字节数据。
3. 客户端发出段6，对服务器发来的序号为8001-8010的数据表示确认收到，请求发送序号8011开始的数据。

在数据传输过程中，ack和确认序号是非常重要的，应用程序交给tcp协议发送的数据会暂存在tcp层的发送缓冲区中，发出数据包给对方之后，只有收到对方应答的ack段才知道该数据包确实发到了对方，可以从发送缓冲区中释放掉了，如果因为网络故障丢失了数据包或者丢失了对方发回的ack段，经过等待超时后tcp协议自动将发送缓冲区中的数据包重发。

四次挥手

所谓四次挥手（four-way-wavehand）即终止tcp连接，就是指断开一个tcp连接时，需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中，这一过程由客户端或服务器任一方执行close来触发。好比两个人打完电话要挂断：

client: "我要说的事情都说完了，我没事了。挂啦？"

server: "等下，我还有一个事儿。balabala…"

server: "好了，我没事儿了。挂了啊。"

client: "ok！拜拜"

关闭连接(四次握手)的过程:

由于tcp连接是全双工的，因此每个方向都必须单独进行关闭。这原则是当一方完成它的数据发送任务后就能发送一个fin来终止这个方向的连接。收到一个 fin只意味着这一方向上没有数据流动，一个tcp连接在收到一个fin后仍能发送数据。首先进行关闭的一方将执行主动关闭，而另一方执行被动关闭。

1. 客户端发出段7，fin位表示关闭连接的请求。
2. 服务器发出段8，应答客户端的关闭连接请求。
3. 服务器发出段9，其中也包含fin位，向客户端发送关闭连接请求。
4. 客户端发出段10，应答服务器的关闭连接请求。

建立连接的过程是三次握手，而关闭连接通常需要4个段，服务器的应答和关闭连接请求通常不合并在一个段中，因为有连接半关闭的情况，这种情况下客户端关闭连接之后就不能再发送数据给服务器了，但是服务器还可以发送数据给客户端，直到服务器也关闭连接为止。

下图是tcp状态转换图

udp通信

在之前的案例中，我们一直使用的是tcp协议来编写socket的客户端与服务端。其实也可以使用udp协议来编写socket的客户端与服务端。

udp服务器

由于udp是“无连接”的，所以，服务器端不需要额外创建监听套接字，只需要指定好ip和port，然后监听该地址，等待客户端与之建立连接，即可通信。

1. 创建监听地址

   func resolveudpaddr(network, address string) (*udpaddr, error)

   resolveudpaddr将addr作为udp地址解析并返回。参数addr格式为"host:port"或"[ipv6-host%zone]:port"，解析得到网络名和端口名；net必须是"udp"、"udp4"或"udp6"。
   ipv6地址字面值/名称必须用方括号包起来，如"[::1]:80"、"[ipv6-host]:http"或"[ipv6-host%zone]:80"。

2. 创建用于通信的socket

   func listenudp(network string, laddr *udpaddr) (*udpconn, error)

   listenudp创建一个接收目的地是本地地址laddr的udp数据包的网络连接。net必须是"udp"、"udp4"、"udp6"；如果laddr端口为0，函数将选择一个当前可用的端口，可以用listener的addr方法获得该端口。返回的*udpconn的readfrom和writeto方法可以用来发送和接收udp数据包（每个包都可获得来源地址或设置目标地址）。

3. 接受udp数据

   func (c *udpconn) readfromudp(b []byte) (n int, addr *udpaddr, err error)

   readfromudp从c读取一个udp数据包，将有效负载拷贝到b，返回拷贝字节数和数据包来源地址。

   readfromudp方法会在超过一个固定的时间点之后超时，并返回一个错误。

4. 写出数据到udp

   func (c *udpconn) writetoudp(b []byte, addr *udpaddr) (int, error)

   writetoudp通过c向地址addr发送一个数据包，b为包的有效负载，返回写入的字节。

   writetoudp方法会在超过一个固定的时间点之后超时，并返回一个错误。在面向数据包的连接上，写入超时是十分罕见的。

服务器端代码:

package main

import (
    "fmt"
    "net"
)

func main() {

    //0.本应从步骤1开始,但是在写步骤1的时候发现,步骤1还需要*udpaddr类型的参数,所以需要先创建一个*dupaddr
    //组织一个udp地址结构,指定服务器的ip+port
    udpaddr, err := net.resolveudpaddr("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("net.resolveudpaddr()函数执行出错,错误为:%v\n", err)
        return
    }
    fmt.printf("udp服务器地址结构创建完成!!!\n")

    //1.创建用户通信的socket
    //由于listenudp需要一个*udpaddr类型的参数,所以我们还需要先创建一个监听地址
    udpconn, err := net.listenudp("udp", udpaddr)
    if err != nil {
        fmt.printf("net.listenudp()函数执行出错,错误为:%v\n", err)
        return
    }
    defer udpconn.close()
    fmt.printf("udp服务器通信socket创建完成!!!\n")

    //2.读取客户端发送的数据(阻塞发生在readfromudp()方法中)
    buf := make([]byte, 4096)
    //readfromudp()方法返回三个值,分别是读取到的字节数,客户端的地址,error
    n, clientudpaddr, err := udpconn.readfromudp(buf)
    if err != nil {
        fmt.printf("*udpaddr.readfromudp()方法执行出错,错误为:%v\n", err)
        return
    }
    //3.模拟处理数据
    fmt.printf("服务器读到%v的数据:%s",clientudpaddr, buf[:n])

    //4.回写数据给客户端
    _, err = udpconn.writetoudp([]byte("i am ok!"), clientudpaddr)
    if err != nil {
        fmt.printf("*udpaddr.writetoudp()方法执行出错,错误为:%v\n", err)
        return
    }
}

运行代码

通过nc请求测试

服务端读取请求数据，并回写"i am ok!"

udp客户端

udp客户端的编写与tcp客户端的编写，基本上是一样的，只是将协议换成udp.代码如下：

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.dial("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("net.dial()函数执行出错,错误为:%v\n", err)
        return
    }
    defer conn.close()

    conn.write([]byte("hello, i`m a client in udp!"))

    buf := make([]byte, 4096)
    n, err := conn.read(buf)
    if err != nil {
        fmt.printf("conn.read()方法执行出错,错误为:%v\n", err)
        return
    }
    fmt.printf("服务器发来数据:%s\n", buf[:n])
}

并发

其实对于udp而言，服务器不需要并发，只要循环处理客户端数据即可。客户端也等同于tcp通信并发的客户端。

服务器:

package main

import (
    "fmt"
    "net"
)

func main() {

    //0.本应从步骤1开始,但是在写步骤1的时候发现,步骤1还需要*udpaddr类型的参数,所以需要先创建一个*dupaddr
    //组织一个udp地址结构,指定服务器的ip+port
    udpaddr, err := net.resolveudpaddr("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("net.resolveudpaddr()函数执行出错,错误为:%v\n", err)
        return
    }
    fmt.printf("udp服务器地址结构创建完成!!!\n")

    //1.创建用户通信的socket
    //由于listenudp需要一个*udpaddr类型的参数,所以我们还需要先创建一个监听地址
    udpconn, err := net.listenudp("udp", udpaddr)
    if err != nil {
        fmt.printf("net.listenudp()函数执行出错,错误为:%v\n", err)
        return
    }
    defer udpconn.close()
    fmt.printf("udp服务器通信socket创建完成!!!\n")

    for {
        //2.读取客户端发送的数据(阻塞发生在readfromudp()方法中)
        buf := make([]byte, 4096)
        //readfromudp()方法返回三个值,分别是读取到的字节数,客户端的地址,error
        n, clientudpaddr, err := udpconn.readfromudp(buf)
        if err != nil {
            fmt.printf("*udpaddr.readfromudp()方法执行出错,错误为:%v\n", err)
            continue
        }
        //3.模拟处理数据
        fmt.printf("服务器读到%v的数据:%s\n",clientudpaddr, buf[:n])

        //4.回写数据给客户端
        _, err = udpconn.writetoudp([]byte("i am ok!"), clientudpaddr)
        if err != nil {
            fmt.printf("*udpaddr.writetoudp()方法执行出错,错误为:%v\n", err)
            continue
        }
    }
}

客户端:

package main

import (
    "fmt"
    "net"
    "os"
)

func main() {
    conn, err := net.dial("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.printf("net.dial()函数执行出错,错误为:%v\n", err)
        return
    }
    defer conn.close()

    go func() {
        buf := make([]byte, 4096)
        for {
            //从键盘读取内容,放入buf
            n, err := os.stdin.read(buf)
            if err != nil {
                fmt.printf("os.stdin.read()执行出错,错误为:%v\n", err)
                return
            }
            //给服务器发送
            conn.write(buf[:n])
        }
    }()
    for {
        buf := make([]byte, 4096)
        n, err := conn.read(buf)
        if err != nil {
            fmt.printf("conn.read()方法执行出错,错误为:%v\n", err)
            return
        }
        fmt.printf("服务器发来数据:%s\n", buf[:n])
    }
}

udp与tcp的差异

tcp	udp
面向连接	面向无连接
要求系统资源较多	要求系统资源较少
tcp程序结构复杂	udp程序结构比较简单
使用流式	使用数据包式
保证数据准确性	不保证数据准确性
保证数据顺序	不保证数据顺序
通讯速度较慢	通讯速度较快

使用场景

tcp: 对数据传输安全性、稳定性要求高的场合。网络文件传输。下载、上传。

udp: 对数据实时传输要求较高的场合。视频直播、在线电话会议。游戏

相关文章: