Go笔记day5 | 青训营

Tcp服务端客户端go编写

服务器端（S端）代码解析：

1. process函数用于处理与客户端的通信。通过创建带有缓冲区的读取器（bufio.NewReader）来读取客户端发送的数据，并将其存储到缓冲区中。
2. 通过调用读取器的Read方法，从缓冲区中读取数据，并检查是否发生错误。如果没有错误，则将接收到的数据转换为字符串并打印出来。
3. 使用连接对象的Write方法，将接收到的数据发送回客户端。

主函数（main）负责监听客户端连接请求并创建新的处理协程。通过使用net.Listen函数监听指定的IP地址和端口号，然后在无限循环中接受客户端连接请求。 当有新的连接请求到达时，调用accept方法接受连接，并使用go关键字创建一个新的协程来处理该连接。

客户端端（C端）代码解析：

1. main函数中的net.Dial方法用于与服务器建立TCP连接。
2. 通过创建一个bufio.NewReader对象来读取用户的输入。
3. 使用一个无限循环，读取用户的输入并将其发送到服务器端。
4. 如果用户输入了字母"q"（不区分大小写），则退出循环。
5. 使用conn.Write方法将输入数据发送到服务器端，并通过conn.Read方法接收服务器的响应数据。
6. 将接收到的数据转换为字符串并打印出来。

UDP服务器和客户端代码解析： UDP服务器和客户端采用类似的方式实现消息的收发功能，使用net.ListenUDP和net.DialUDP函数创建UDP监听与连接。 服务器端通过循环调用listen.ReadFromUDP方法从UDP连接读取数据，并使用listen.WriteToUDP方法向客户端发送数据。 客户端通过调用socket.Write方法向服务器发送数据，并使用socket.ReadFromUDP方法从服务器接收数据。

TCP粘包处理代码解析： 为了处理TCP粘包问题，引入了Encode和Decode两个函数。 Encode函数将输入的消息字符串转换为字节切片，并在切片开头添加表示消息长度的4个字节。 Decode函数从给定的bufio.Reader对象中读取前4个字节，解析出消息长度，然后从缓冲区中读取完整的消息数据。 如果缓冲区中可读取的字节数不足以读取完整的消息，则等待更多数据到达。

在服务器端，使用Decode函数解析从客户端接收到的数据。 在客户端端，使用Encode函数将要发送的数据进行编码，然后通过conn.Write方法发送。

以上是对提供的代码进行的简要解析。这段代码展示了如何使用Go语言实现TCP和UDP的基本通信功能，并且包含了TCP粘包处理的逻辑。

S端
func process(conn net.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 C failed : ", err)
			break
		}
		recvstr := string(buf[:n])
		fmt.Println("收到clinet发来的数据:", recvstr)
		conn.Write([]byte(recvstr)) //发送数据
	}
}

func main() {
	listen, err := net.Listen("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Println("listen failed :", err)
		return
	}
	for {
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println("accept failed :", err)
			continue
		}
		go process(conn)
	}
}

C端
package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strings"
)

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Println("err :", err)
		return
	}
	defer conn.Close() // 关闭连接
	inputReader := bufio.NewReader(os.Stdin)
	for {
		input, _ := inputReader.ReadString('\n') // 读取用户输入
		inputInfo := strings.Trim(input, "\r\n")
		if strings.ToUpper(inputInfo) == "Q" { // 如果输入q就退出
			return
		}
		_, err = conn.Write([]byte(inputInfo)) // 发送数据 //先转换为字节数组
		if err != nil {
			return
		}
		buf := [512]byte{}
		n, err := conn.Read(buf[:])
		if err != nil {
			fmt.Println("recv failed, err:", err)
			return
		}
		fmt.Println(string(buf[:n]))
	}
}

UDP服务器客户端go编写

func main() {
	listen, err := net.ListenUDP("udp", &net.UDPAddr{
		IP:   net.IPv4(0, 0, 0, 0),
		Port: 30000,
	})
	if err != nil {
		fmt.Println("listen is failed:", err)
		return
	}
	defer listen.Close()

	for {
		var data [1024]byte                         //字节数组
		n, addr, err := listen.ReadFromUDP(data[:]) //接收数据 读取的字节数
		//数据来源的地址，可能发生的错误
		if err != nil {
			fmt.Println("read udp failed:", err)
			continue
		}
		fmt.Printf("data:%v addr:%v count:%v\n", string(data[:]), addr, n)
		_, err = listen.WriteToUDP(data[:], addr) //发送数据
		if err != nil {
			fmt.Println("write to udp failed:", err)
			continue
		}
	}
}

UDP客户端代码

func main() {
	socket, err := net.DialUDP("udp", nil, &net.UDPAddr{
		IP:   net.IPv4(0, 0, 0, 0),
		Port: 30000,
	})

	if err != nil {
		fmt.Println("连接服务器失败:", err)
		return
	}
	defer socket.Close()
	sendData := []byte("Hello Server")
	_, err = socket.Write(sendData) //发送数据
	if err != nil {
		fmt.Println("数据发送失败", err)
		return
	}
	data := make([]byte, 4000)
	n, remoteAddr, err := socket.ReadFromUDP(data) //接收数据
	if err != nil {
		fmt.Println("接收数据失败", err)
		return
	}
	fmt.Printf("recv:%v addr:%v count:%v\n", string(data[:]), remoteAddr, n)
}

TCP粘包处理

func Encode(message string) ([]byte, error) {
	var length = int32(len(message))
	var pkg = new(bytes.Buffer) //创建存储二进制的字节缓冲区

	//将给定的数据按照给定的字节序写入到缓冲区中
	err := binary.Write(pkg, binary.LittleEndian, length)
	if err != nil {
		return nil, err
	}
	return pkg.Bytes(), nil //缓冲区内容以字节数组返回
}

func Decode(reader *bufio.Reader) (string, error) {
	lengthByte, _ := reader.Peek(4) //读取前四个字节的内容
	lengthBuff := bytes.NewBuffer(lengthByte)

	var length int32
	err := binary.Read(lengthBuff, binary.LittleEndian, &length)
	if err != nil {
		return "", err
	}

	//Buffered返回缓冲区中现有的可读取的字节数
	//检查缓冲区中是否有足够的数据用于读取整个消息
	if int32(reader.Buffered()) < length+4 {
		return "", err
	}

	//读取真正的消息数据 包括长度字段本身
	pack := make([]byte, int(4+length))
	_, err = reader.Read(pack)
	if err != nil {
		return "", err
	}

	//返回去除长度字段后的消息内容
	return string(pack[:]), nil
}

针对上面的解码编码的S和C如下

S:

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		msg, err := Decode(reader)
		if err == io.EOF {
			return
		}
		if err != nil {
			fmt.Println("decode msg failed :", err)
			return
		}
		fmt.Println("收到Client端发送的数据:", msg)
	}
}

func main() {
	listen, err := net.Listen("tcp", "127.0.0.1:30000")
	if err != nil {
		fmt.Println("listen failed : ", err)
		return
	}
	defer listen.Close()

	for {
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println("accept is failed", err)
			return
		}
		go process(conn)
	}
}

c:

func main(){
	conn,err :=net.Dial("tcp","127.0.0.1:30000")
	if err!=nil{
		fmt.Println("dial failed :",err)
		return
	}
	defer conn.Close()

	for i:=0;i<20;i++{
		msg:="Hello"
		data,err:=Encode(msg)
		if err!=nil{
			fmt.Println("encode msg failed :",err)
			return
		}
		conn.Write(data)
	}
}