文章目录
前言
本文介绍的不是http.net包,仅仅介绍传统的网络通信（后期会单独进行http.net包的更新）
一、互联网的层次结构
大致分为四层,细分的话可以分为7层
1.应用层
应用层、表示层、会话层
2.传输层
传输层
3.网络层
网络层
4.网络接口层
数据链路层、 物理层
5.图解
其中socket层是为我们准备的,我们可以在这一层进行一些功能的实现达到用户的需求
二、tcp协议概述
1.三次握手
第一次握手
客户端发送一个TCP的SYN标志位置1的包指明客户打算连接的服务器的端口， 以及初始序号X,保存在包头的序列号(Sequence Number)字段里。
第二次握手
服务器发回确认包(ACK)应答。即SYN标志位和ACK标志位均为1同 时，将确认序号(Acknowledgement Number)设置为客户的I S N加1以.即X+1。
第三次握手
客户端再次发送确认包(ACK) SYN标志位为0,ACK标志位为1.并且把服 务器发来ACK的序号字段+1,放在确定字段中发送给对方.并且在数据段放写ISN的+1
2.tcp通常用来做什么？
- 由于tcp通信数据包传输精确可以用来传输文件图片,等重要的数据
- tcp传输准确率高但效率低,不易传数据量大重要程度不高的数据
3.代码实现tcp通信
客户端代码如下：
package main import ( "bufio" "fmt" "net" "os" "strings" "time" ) // tcp/client/main.go // 接收数据 func getMsg(conn net.Conn) { for { buf := [512]byte{} // n为获取到的数据长度 n, err := conn.Read(buf[:]) if err != nil { fmt.Println("recv failed, err:", err) return } fmt.Println(string(buf[:n])) } } // 发送数据 func sendMsg(conn net.Conn) { for { // 创建一个缓冲区阅读器 inputReader := bufio.NewReader(os.Stdin) // 接收用户输入,以\n为终结符 input, _ := inputReader.ReadString('\n') // 读取用户输入 // 去掉获取到的\n inputInfo := strings.Trim(input, "\r\n") // 判断是否满足退出条件 if strings.ToUpper(inputInfo) == "Q" { // 对服务器发送退出请求 _, _ = conn.Write([]byte("q")) return } // 给服务端写入数据（数据在两端之间以字节的形式传输） _, err := conn.Write([]byte(inputInfo)) if err != nil { return } } } // 客户端 func main() { // 使用tcp的方式去连接127.0.0.1:20000 conn, err := net.Dial("tcp", "127.0.0.1:20000") if err != nil { fmt.Println("err :", err) return } // 在函数执行到末端的时候进行关闭连接 defer conn.Close() go getMsg(conn) go sendMsg(conn) time.Sleep(time.Hour) }
服务端代码如下：
package main import ( "bufio" "fmt" "net" "os" "strings" ) // TCP server端 func sendMsg(conn net.Conn) { for { inputer := bufio.NewReader(os.Stdin) input, _ := inputer.ReadString('\n') input = strings.Trim(input, "\r\n") conn.Write([]byte(input)) } } // 接收处理函数 func process(conn net.Conn) { fmt.Println("线路:", conn, "连接成功!") defer conn.Close() // 关闭连接 for { reader := bufio.NewReader(conn) var buf [128]byte n, err := reader.Read(buf[:]) // 读取数据 if err != nil { fmt.Println("read from client failed, err:", err) break } recvStr := string(buf[:n]) if recvStr == "q" { fmt.Println(conn, "断开了连接!") return } fmt.Println(conn, ":", recvStr) fmt.Printf("请输入:") } } func main() { // 绑定网关的127.0.0.1:20000，以tcp的形式进行数据传输 listen, err := net.Listen("tcp", "127.0.0.1:20000") if err != nil { fmt.Println("listen failed, err:", err) return } for { // 等待客户端进行连接 conn, err := listen.Accept() // 建立连接 if err != nil { fmt.Println("accept failed, err:", err) continue } // 将接受到的连接添加到后台进程 go process(conn) go sendMsg(conn) } }
三、udp协议概述
1.udp通常用来做什么?
- udp传输效率高,但容易丢失数据
- 可用来进行网络直播,视频通话
- 保留重要的信息,对可有可无的信息尽力保存
2.代码实现
客户端代码如下：
package main import ( "bufio" "fmt" "net" "os" ) // UDP client func main() { socket, err := net.DialUDP("udp", nil, &net.UDPAddr{ IP: net.IPv4(127, 0, 0, 1), Port: 40000, }) if err != nil { fmt.Println("连接服务端失败，err:", err) return } defer socket.Close() var reply [1024]byte reader := bufio.NewReader(os.Stdin) for { fmt.Print("请输入内容：") msg, _ := reader.ReadString('\n') socket.Write([]byte(msg)) // 收回复的数据 n, _, err := socket.ReadFromUDP(reply[:]) if err != nil { fmt.Println("redv reply msg failed,err:", err) return } fmt.Println("收到回复信息：", string(reply[:n])) } }
服务端代码如下：
package main import ( "fmt" "net" "strings" ) // UDP server func main() { // 建立UDP服务端,不需要使用accept方法 conn, err := net.ListenUDP("udp", &net.UDPAddr{ IP: net.IPv4(127, 0, 0, 1), Port: 40000, }) if err != nil { fmt.Println("listen UDP failed,err:", err) return } defer conn.Close() // 不需要建立连接，直接收发数据 var data [1024]byte for { n, addr, err := conn.ReadFromUDP(data[:]) if err != nil { fmt.Println("read from UDP failed,err:", err) return } fmt.Println(data[:n]) reply := strings.ToUpper(string(data[:n])) // 发送数据 conn.WriteToUDP([]byte(reply), addr) } }
四、粘包问题【及解决方法】
1.为什么会粘包？
由于频繁的进行数据的收发,底层为了提高收发效率，在发送消息前会检查一下是否还有需要发送的其他数据
如果发送过于频繁,上一次数据包将与夏下一次的数据报粘在一起,导致数据非常乱
由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，若有则会一次把这两段数据发送出去
/* 在服务端接收客户端发送来的20次Tomhello并打印 在粘包下的打印效果（各个信息有可能会直接相连） hello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tomhello Tom -------------- hello Tomhello Tomhello Tom -------------- 正常的打印结果为： -------------- hello Tomhello -------------- hello Tomhello -------------- hello Tomhello -------------- hello Tomhello -------------- hello Tomhello -------------- hello Tomhello -------------- hello Tomhello -------------- hello Tomhello -------------- ...... */
2.解决方案
- 将每一个数据包大小进行保存,数据包写一表头用于存储数据包的大小,每次进行数据的读取时先
- 进行数据包大小的读取,在进行数据信息实体的读取
- 降低发送数据的频率
3.编码解码函数
编码解码函数代码如下：
package edcode import ( "bufio" "bytes" "encoding/binary" ) /* 小端低低：低地址存低位 大端高低：高地址存低位 对需要发送的信息进行编码解码（打包处理） 其中包内的前四个字节用于存储包的大小,后面用于存储信息的主要内容 */ // 解码 // 取出bytes前四个字节,转化为int32类型,然后再将剩余的消息体取出 func Mydecode(reader *bufio.Reader) (string, error) { Size, _ := reader.Peek(4) lenthbuff := bytes.NewBuffer(Size) var lenth int32 // 读取lenthbuff内的内容,读取完将数据放在lenth内,读取的方式是小端方式 err := binary.Read(lenthbuff, binary.LittleEndian, &lenth) // 判断一下是否出错,长度不够包头指定的长度就抛异常 if err != nil || int32(reader.Buffered()) < lenth+4 { return "", err } // pack := make([]byte, int(lenth+4)) // read读取之后缓冲区就少一部分数据 _, err = reader.Read(pack) if err != nil { return "", err } return string(pack[4:]), nil } // 编码 // 先计算出字符串的长度,再进行打包 func MyEncode(message string) ([]byte, error) { // 读取消息的长度，转换成int32类型（占4个字节） var length = int32(len(message)) var pkg = new(bytes.Buffer) // 写入消息头 err := binary.Write(pkg, binary.LittleEndian, length) if err != nil { return nil, err } // 写入消息实体 err = binary.Write(pkg, binary.LittleEndian, []byte(message)) if err != nil { return nil, err } return pkg.Bytes(), nil }
客户端代码如下：
package main import ( "fmt" "net" ed "aCorePackage/edcode" ) func main() { conn, err := net.Dial("tcp", "127.0.0.1:20000") if err != nil { fmt.Println(err) } // 快速发送信息还是会黏在一起,只不过通过一定的编码解码方式可以使信息很好的分离 for i := 0; i < 20; i++ { str := "hello Tom" mybtys, err := ed.MyEncode(str) if err != nil { fmt.Println(err) } conn.Write(mybtys) fmt.Println("-------------------") } }
服务端代码如下：
package main import ( ed "aCorePackage/edcode" "bufio" "fmt" "io" "net" ) func readMsd(conn net.Conn) { defer conn.Close() reader := bufio.NewReader(conn) for { str, err := ed.Mydecode(reader) if err == io.EOF { return } if err != nil { fmt.Println(err) return } fmt.Println(str) fmt.Println("--------------") } } func main() { listener, err := net.Listen("tcp", "127.0.0.1:20000") if err != nil { fmt.Println(err) } for { conn, err := listener.Accept() if err != nil { fmt.Println(err) return } go readMsd(conn) } }
总结
TCP 需要连接，UDP 是无连接的，发送数据之前不需要建立连接, TCP 提供可靠的服务，通过 TCP 连接传送的数据，无差错，不丢失 TCP 逻辑通信信道是全双工的可靠信道，UDP 则是不可靠信道,两者各有所长,对他们进行各取所需。
