[网络协议]Golang——TCP、UDP实现并发（服务端与客户端）

Server端常用函数、接口：

Listen函数：
	func Listen(network, address string) (Listener, error)
		network：选用的协议：TCP、UDP， 	如：“tcp”或 “udp”
		address：IP地址+端口号, 			如：“127.0.0.1:8000”或 “:8000”
		
Listener 接口：
type Listener interface {
			Accept() (Conn, error)
			Close() error
			Addr() Addr
}

Conn 接口：
type Conn interface {
	Read(b []byte) (n int, err error)
	Write(b []byte) (n int, err error)
	Close() error
	LocalAddr() Addr
	RemoteAddr() Addr
	SetDeadline(t time.Time) error
	SetReadDeadline(t time.Time) error
	SetWriteDeadline(t time.Time) error
}

TCP-服务端实现：

func main() {
	// 指定服务器的通讯协议、ip、端口，Listen本身不做监听，这一步是创建了一个用于监听的Socket
	listen, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Listen出错：", err)
		return
	}
	defer listen.Close()

	fmt.Println("服务器启动完毕，等待客户端连接")

	// 阻塞监听客户端连接请求,成功建立连接后会返回用于通信的Socket
	accept, err := listen.Accept()
	if err != nil {
		fmt.Println("listen.Accept出错：", err)
		return
	}
	defer accept.Close()

	fmt.Println("服务器与客户端连接成功")

	// 读取客户端发动的请求
	buf := make([]byte, 4096)
	read, err := accept.Read(buf)
	if err != nil {
		fmt.Println("accept.Read出错：", err)
		return
	}

	// 接收数据后处理数据
	fmt.Println("服务器获取到：", string(buf[:read]))
}

Mac可以通过netcat进行测试：

TCP-客户端实现：

func main() {
	// 指定用户端的通讯协议、ip、端口，Listen本身不做监听，这一步是创建了一个用于监听的Socket
	dial, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Dial出错：", err)
		return
	}
	defer dial.Close()

	// 发送数据
	dial.Write([]byte("我是客户端"))

	// 接收服务器返回的数据
	buf := make([]byte, 4096)
	read, err := dial.Read(buf)
	if err != nil {
		fmt.Println("accept.Read出错：", err)
		return
	}

	// 接收数据后处理数据
	fmt.Println("客户端获取到：", string(buf[:read]))
}

TCP实现并发-服务器：

上面都是单机版的客户端通信，如果想要实现并发，需要使用Goroutine+循环实现

• 循环读取客户端发送的数据
• 如果客户端强制关闭连接需要做处理
• 客户端发送exit时

演示：

package main

import (
	"fmt"
	"net"
	"strings"
)

func main() {
	// 创建监听套接字
	listen, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Listen出错：", err)
		return
	}
	defer listen.Close()

	// 创建客户端连接请求
	fmt.Println("服务器启动成功，等待客户端连接！")
	for {
		accept, err := listen.Accept()
		if err != nil {
			fmt.Println("listen.Accept出错：", err)
			return
		}
		// 调用服务器和客户端通信的函数
		go HandlerConnect(accept)
	}
}

func HandlerConnect(accept net.Conn) {
	defer accept.Close()

	// 获取客户端发送的数据
	// 获取连接客户端的网络地址
	addr := accept.RemoteAddr()
	fmt.Println(addr, "客户端连接成功！")

	buf := make([]byte, 4096)
	for {
		read, err := accept.Read(buf)
		if err != nil {
			fmt.Println("accept.Read出错：", err)
			return
		}
		fmt.Println("服务器读到数据：", string(buf[:read]))

		// 模拟服务器收到数据后，回发给客户端，小写转大写
		data := strings.ToUpper(string(buf[:read]))
		accept.Write([]byte(data))
	}
}

TCP实现并发-客户端：

演示：

package main

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

func main() {
	//主动发送连接请求
	dial, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("et.Dial出错了", err)
		return
	}
	defer dial.Close()

	// os.Stdin()：获取用户键盘录入，
	go func() {
		str := make([]byte, 4096)
		for {
			read, err := os.Stdin.Read(str)
			if err != nil {
				fmt.Println("os.Stdin.Read出错了", err)
				continue
			}

			// 读到的数据写给服务器，读多少写多少
			dial.Write(str[:read])
		}
	}()

	buf := make([]byte, 4096)
	// 回显服务器发送的数据，转成大写
	for {
		read, err := dial.Read(buf)

		// read=0的说明对端关闭连接，如果关闭连接这里就不需要往下读数据了
		if read == 0 {
			fmt.Println("检测到服务端端已经断开连接！")
			return
		}

		if err != nil {
			fmt.Println("回显服务器发送的数据dial.Read出错了", err)
			return
		}
		fmt.Println("客户端读到服务器的回显数据", string(buf[:read]))
	}
}

UDP实现并发-服务器：

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

创建监听地址：

	func ResolveUDPAddr(network, address string) (*UDPAddr, error) 

创建监听连接：

	func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error) 

接收udp数据：

	func (c *UDPConn) ReadFromUDP(b []byte) (int, *UDPAddr, error)

写出数据到udp：

	func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

演示：

package main

import (
	"fmt"
	"net"
)

func main() {
	// 指定服务器的ip和端口，和TCP协议不一样，需要先写好再传给ListenUDP使用
	ServerAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.ResolveUDPAddr err：", err)
		return
	}

	fmt.Println("服务器启动成功！")
	// 创建用户通信的Socket
	udpConnect, err := net.ListenUDP("udp", ServerAddr)
	if err != nil {
		fmt.Println("net.ListenUDP err：", err)
		return
	}
	defer udpConnect.Close()

	fmt.Println("服务器创建Socket成功！")

	// 读写客户端的数据
	buf := make([]byte, 4096)
	count := 0
	for {
		// 返回值：n int（读到的字节数）， addr *UDPAddr（客户端的地址）， err error
		udpBytes, ConnectAddr, err := udpConnect.ReadFromUDP(buf)

		if err != nil {
			fmt.Println("udpConnect.ReadFromUDP err：", err)
			return
		}
		count++
		// 模拟处理数据
		fmt.Printf("服务器读到第%v条数据 %v ：%s\n", count, ConnectAddr, string(buf[:udpBytes]))

		go func() {
			// 回写数据到客户端
			udpConnect.WriteToUDP([]byte("回写数据到客户端\n"), ConnectAddr)
		}()
	}
}

UDP实现并发-客户端：

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
	dial, err := net.Dial("udp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("net.Dial出错：", err)
		return
	}
	defer dial.Close()

	for {
		// 发送数据
		dial.Write([]byte("我是客户端"))

		// 接收服务器返回的数据
		buf := make([]byte, 4096)
		read, err := dial.Read(buf)
		if err != nil {
			fmt.Println("accept.Read出错：", err)
			return
		}

		// 接收数据后处理数据
		fmt.Println("客户端获取到：", string(buf[:read]))
		time.Sleep(time.Second)
	}
}