网络基础知识
经典协议
TCP 为什么需要三次握手四次挥手
- 三次握手的最主要目的是保证连接是双工的，可靠更多的是通过重传机制来保证的。
- 因为连接是全双工的，双方必须都收到对方的FIN包及确认才可关闭。
为什么time_wait要等2msl
TCP为什么需要流量控制
- 由于通讯双方，网速不同。通讯方任一方发送过快都会导致对方消息处理不过来，所以就需要把数据放到缓冲区中
- 如果缓冲区满了，发送方还在疯狂发送，那接收方只能把数据包丢弃。因此我们需要控制发送速率。
- 我们缓冲区剩余大小称之为接收窗口，用变量win表示。如果的win=0，则发送方停止发送。
TCP为什么需要拥塞控制
- 流量控制与拥塞控制是两个概念，拥塞控制是调解网络的负载。
- 接收方网络资源繁忙，因未及时相应ACK导致发送方重传大量数据，这样将会导致网络更加拥堵。
- 拥塞控制是动态调整win大小，不只是依赖缓冲区大小确定窗口大小。
为什么会出现粘包/拆包？
- 应用程序写入的数据大于套接字缓冲区大小，这将会发生拆包。
- 应用程序写入数据小于套接字缓冲区大小，网卡将应用多次写入的数据发送到网络上，这将会发生粘包。
- 进行MSS（最大报文长度）大小的TCP分段，当TCP报文长度-TCP头部长度>MSS的时候将发生拆包。
- 接收方法不及时读取套接字缓冲区数据，这将发生粘包。
如何获取完整应用数据报文？
- 使用带消息头的协议，头部写入包长度，然后再读取包内容。
- 设置定长消息，每次读取定长内容，长度不够时空位补固定字符。
- 设置消息边界，服务端从网络流中按消息边界分离出消息内容，一般使用\n’。
- 更为复杂的协议，例如json、protobuf
golang的tcp小demo
解码部分
1package unpack
2
3import (
4 "encoding/binary"
5 "errors"
6 "io"
7)
8
9const MsgHeader = "12345678"
10
11// Encode 将消息编码为特定格式并写入 bytesBuffer 中。
12// 消息格式：消息头 + 消息长度 + 消息内容
13// 长度：消息头 8字节 + 消息长度 4字节 + 实际消息内容长度 contentLen
14func Encode(bytesBuffer io.Writer, content string) error {
15 // 写入消息头
16 if err := binary.Write(bytesBuffer, binary.BigEndian, []byte(MsgHeader)); err != nil {
17 return err
18 }
19 // 写入消息长度
20 contentLen := int32(len(content))
21 if err := binary.Write(bytesBuffer, binary.BigEndian, contentLen); err != nil {
22 return err
23 }
24 // 写入消息内容
25 if err := binary.Write(bytesBuffer, binary.BigEndian, []byte(content)); err != nil {
26 return err
27 }
28 return nil
29}
30
31// Decode 从 bytesBuffer 中读取并解码消息。
32// 返回消息内容的字节切片和可能的错误。
33func Decode(bytesBuffer io.Reader) (bodyBuf []byte, err error) {
34 MagicBuf := make([]byte, len(MsgHeader))
35 // 1. 读取消息头
36 if _, err = io.ReadFull(bytesBuffer, MagicBuf); err != nil {
37 return nil, err
38 }
39 // 2. 判断消息头是否正确
40 if string(MagicBuf) != MsgHeader {
41 return nil, errors.New("msg header error")
42 }
43 lengthBuf := make([]byte, 4)
44 // 3. 读取消息长度
45 if _, err = io.ReadFull(bytesBuffer, lengthBuf); err != nil {
46 return nil, err
47 }
48 // 4. 转换消息长度
49 length := binary.BigEndian.Uint32(lengthBuf)
50 bodyBuf = make([]byte, length)
51 // 5. 读取实际消息内容
52 if _, err = io.ReadFull(bytesBuffer, bodyBuf); err != nil {
53 return nil, err
54 }
55 return bodyBuf, nil
56}
客户端部分
1package main
2
3import (
4 "fmt"
5 "gatewat_demo/base/unpack/unpack"
6 "net"
7)
8
9// main 是程序的入口函数。
10// 它建立一个 TCP 连接到本地的 9090 端口，并发送编码后的消息 "hello world 0!!!"。
11func main() {
12 // 尝试建立一个 TCP 连接到本地的 9090 端口
13 conn, err := net.Dial("tcp", "localhost:9999")
14 defer conn.Close() // 在函数结束时关闭连接
15 if err != nil {
16 // 如果连接失败，打印错误信息并返回
17 fmt.Println("Error dialing", err.Error())
18 return
19 }
20 // 使用自定义的 Encode 函数将消息 "hello world 0!!!" 编码并发送
21 unpack.Encode(conn, "hello world 0!!!")
22}
服务器部分
1package main
2
3import (
4 "fmt"
5 "gatewat_demo/base/unpack/unpack"
6 "net"
7)
8
9// main 是程序的入口函数。
10// 它在本地的 9999 端口上启动一个 TCP 服务器，等待客户端连接并处理连接。
11func main() {
12 // 1. 本地端口监听 ip:port
13 listener, err := net.Listen("tcp", "localhost:9999")
14 if err != nil {
15 // 如果监听失败，打印错误信息并返回
16 fmt.Printf("listen failed, err:%v\n", err)
17 return
18 }
19 for {
20 // 2. 等待客户端建立连接
21 conn, err := listener.Accept()
22 if err != nil {
23 // 如果接受连接失败，打印错误信息并继续等待下一个连接
24 fmt.Printf("accept failed, err:%v\n", err)
25 continue
26 }
27 // 3. 启动一个单独的 goroutine 处理连接
28 go process(conn)
29 }
30}
31
32// process 处理单个客户端连接。
33// 它从连接中读取数据并解码，直到发生错误或连接关闭。
34func process(conn net.Conn) {
35 defer conn.Close() // 在函数结束时关闭连接
36 for {
37 // 从连接中解码数据
38 bt, err := unpack.Decode(conn)
39 if err != nil {
40 // 如果读取数据失败，打印错误信息并退出循环
41 fmt.Printf("read from client failed, err:%v\n", err)
42 break
43 }
44 // 打印从客户端接收到的数据
45 fmt.Printf("receive from client, data:%v\n", string(bt))
46 }
47}
运行后可以看到
golang创建udp服务器和客户端
客户端
1package main
2
3import (
4 "fmt"
5 "net"
6)
7
8func main() {
9 // 1. 本地端口监听 ip:port
10 conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
11 IP: net.IPv4(127, 0, 0, 1),
12 Port: 9999,
13 })
14 if err != nil {
15 fmt.Printf("connect failed, err:%v\n", err)
16 return
17 }
18
19 //2. 发送数据
20 for i := 0; i < 100; i++ {
21 _, err = conn.Write([]byte("hello server"))
22 if err != nil {
23 fmt.Printf("send data failed, err:%v\n", err)
24 return
25 }
26 // 3. 接收数据
27 result := make([]byte, 1024)
28 n, remoteAddr, err := conn.ReadFromUDP(result)
29 if err != nil {
30 fmt.Printf("receive data failed, err:%v\n", err)
31 return
32 }
33 fmt.Printf("receive from addr:%v data:%v count:%v\n", remoteAddr, string(result[:n]), n)
34 }
35
36}
服务端
1package main
2
3import (
4 "fmt"
5 "net"
6)
7
8// main 是程序的入口函数。
9// 它在本地的 9999 端口上启动一个 UDP 服务器，等待客户端发送消息并回复。
10func main() {
11 // 1. 本地端口监听 ip:port
12 listener, err := net.ListenUDP("udp", &net.UDPAddr{
13 IP: net.IPv4(127, 0, 0, 1),
14 Port: 9999,
15 })
16 if err != nil {
17 // 如果监听失败，打印错误信息并返回
18 fmt.Printf("listen failed, err:%v\n", err)
19 return
20 }
21 // 2. 循环读取消息
22 for {
23 var data [1024]byte
24 // 使用 ReadFromUDP 读取数据，返回数据长度 n，客户端地址 addr，错误 err
25 n, addr, err := listener.ReadFromUDP(data[:])
26 if err != nil {
27 // 如果读取数据失败，打印错误信息并退出循环
28 fmt.Printf("read from udp failed, err:%v\n", err)
29 break
30 }
31
32 // 启动一个单独的 goroutine 处理客户端请求
33 go func() {
34 // 3. 回复数据
35 fmt.Printf("data:%v addr:%v count:%v\n", string(data[:n]), addr, n)
36 _, err = listener.WriteToUDP([]byte("received success"), addr)
37 if err != nil {
38 // 如果发送数据失败，打印错误信息
39 fmt.Printf("write to udp failed, err:%v\n", err)
40 return
41 }
42 }()
43 }
44}
tcp实现
如果没有deferclose会出现什么情况
如果server端没有close，客户端会停在FIN_WAIT_2，服务器会停在CLOSE_WAIT
golang创建http服务器和客户端
1package main
2
3import (
4 "log"
5 "net/http"
6 "time"
7)
8
9const Addr = "localhost:9999"
10
11// main 是程序的入口函数。
12// 它创建一个 HTTP 服务器并在本地的 9999 端口上启动服务。
13func main() {
14
15 // 1. 创建一个 http.ServeMux 路由器
16 mux := http.NewServeMux()
17 // 2. 设置路由规则
18 mux.HandleFunc("/bye", sayBye)
19 // 3. 创建一个 http.Server
20 server := http.Server{
21 Addr: Addr,
22 Handler: mux,
23 WriteTimeout: time.Second * 3,
24 }
25 // 4. 监听端口并启动服务
26 log.Println("Starting http server at " + Addr)
27 log.Fatal(server.ListenAndServe())
28}
29
30// sayBye 处理 /bye 路由的请求。
31// 它等待 1 秒钟，然后返回 "bye bye, this is http server" 响应。
32func sayBye(w http.ResponseWriter, r *http.Request) {
33 time.Sleep(1 * time.Second)
34 w.Write([]byte("bye bye, this is http server"))
35}
测试得到
1agq@AGdeMacBook-Air tcp_client % curl -v 'http//127.0.0.1:9
2999/bye'
3* Could not resolve host: http
4* Closing connection 0
5curl: (6) Could not resolve host: http
6agq@AGdeMacBook-Air tcp_client % curl -v 'http://127.0.0.1:9999/bye'
7* Trying 127.0.0.1:9999...
8* Connected to 127.0.0.1 (127.0.0.1) port 9999 (#0)
9> GET /bye HTTP/1.1
10> Host: 127.0.0.1:9999
11> User-Agent: curl/8.1.2
12> Accept: */*
13>
14< HTTP/1.1 200 OK
15< Date: Thu, 19 Sep 2024 13:22:37 GMT
16< Content-Length: 28
17< Content-Type: text/plain; charset=utf-8
18<
19* Connection #0 to host 127.0.0.1 left intact
20bye bye, this is http server%