投稿
  1. 首页
  2. Golang

一文搞懂Go语言网络编程【tcp、udp】

木槿花开 • 2022-5-21 • Golang • 阅读 51

一文搞懂Go语言网络编程【tcp、udp】,第1张

文章目录 前言一、互联网的层次结构1.应用层2.传输层3.网络层4.网络接口层5.图解 二、tcp协议概述1.三次握手第一次握手第二次握手第三次握手 2.tcp通常用来做什么？3.代码实现tcp通信 三、udp协议概述1.udp通常用来做什么?2.代码实现 四、粘包问题【及解决方法】1.为什么会粘包？2.解决方案3.编码解码函数 总结GO GO GO !

前言

本文介绍的不是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 则是不可靠信道,两者各有所长,对他们进行各取所需。

GO GO GO !

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/langs/995465.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
木槿花开 木槿花开 一级用户组
0 0
上一篇 2022-05-21
下一篇 2022-05-21

发表评论

登录后才能评论

评论列表（0条）

保存