golang socket tcp udp

最新推荐文章于 2023-09-08 15:51:46 发布
最新推荐文章于 2023-09-08 15:51:46 发布
阅读量571 收藏 1
点赞数
分类专栏： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Waller_/article/details/119301226
版权

TCP

TCP server

package main

import (
	"fmt"
	"net"
)

func main() {
	// 一. 创建套接字socket
	// 指定server端使用的通信协议, 并绑定ip 和 port
	listener, err := net.Listen("tcp", "127.0.0.1:8384")
	if err != nil{
		fmt.Println("server start err :", err)
		return
	}
	fmt.Println("server start success...")
	// 二. 创建用于连接和通信的socket
	// 调用 Accept 监听连接,此时会阻塞server端,直到有客户端发送连接, server端每收到一个连接,都会创建一个conn 套接字(socket)
	conn, err:= listener.Accept()  // 等待连接
	if err != nil{
		fmt.Println("server accept err :", err)
		return
	}
	// 三. 向client收发数据
	// 1.读取客户端发送的数据
	// 创建用于保存收到的数据大小的切片
	buf := make([]byte, 4096)
	n, err := conn.Read(buf)  // 返回的是所收到数据的字节数
	if err != nil{
		fmt.Println("server read err :", err)
		return
	}
	// 处理收到的数据后,如打印
	fmt.Println("server 收到数据:", string(buf[:n]))  // 将收到的数据,按照收到的字节数从头切到 n,即:读多少打印多少

	// 2.向client发送数据
	_, err = conn.Write([]byte("Im ok!"))
	if err != nil{
		fmt.Println("server write err :", err)
		return
	}

	// 四. 关闭socker , 包括监听socket 和 通信socket
	defer listener.Close()
	defer conn.Close()
}

TCP client

package main

import (
	"fmt"
	"net"
)

func main() {
	// 一. 客户端创建用于通信的socket
	// 指定通信协议,并指定server端 IP PORT
	conn, err := net.Dial("tcp", "127.0.0.1:8384")
	if err != nil{
		fmt.Println("client start err :", err)
		return
	}
	// 二. 收发server端数据
	// 1.主动向server端发送数据
	msg := "Are you ok?"
	_, err = conn.Write([]byte(msg))
	if err != nil{
		fmt.Println("client write err :", err)
		return
	}
	// 2.接收server端的数据
	buf := make([]byte, 4096)
	n, err := conn.Read(buf)
	if err != nil{
		fmt.Println("client read err :", err)
		return
	}
	fmt.Println("client 收到数据:", string(buf[:n]))
    // 三. 关闭socker
	defer conn.Close()
}

 并发版server

package main

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

func HandlerConnent(conn net.Conn) {
	defer conn.Close()  // 注意完成数据通信后关闭conn
	// server可以做一些事情,如处理数据
	addr := conn.RemoteAddr()  // 获取client addr
	fmt.Println(addr.Network())  // 获取socket协议 : tcp
	fmt.Println(addr.String())  // 获取client IP PORT :   127.0.0.1:54331
	// 三. 循环读取客户端发送的数据
	// 创建用于保存收到的数据大小的切片
	buf := make([]byte, 4096)
	for{
		n, err := conn.Read(buf)  // 返回的是所收到数据的字节数
		// server 与 client 之间的 Read, Write 类似channel的读写端, 
		// 当写端主动关闭后,读端可以继续读数据,但读到的是0, 所以可以通过是否为0来判断client是否关闭连接
		if n == 0{
			fmt.Println("client stop..., 断开连接")
			return
		}
        if "exit\n" == string(buf[:n]) || "exit\r\n" == string(buf[:n]){
			fmt.Println("client stop..., 断开连接")
			return
		}
		if err != nil{
			fmt.Println("server read err :", err)  // 注意: 当客户端关闭后,n 等于 0 , err 等于 EOF
			return
		}
		msg :=  string(buf[:n])  // 将收到的数据,按照收到的字节数从头切到 n,即:读多少打印多少
		fmt.Println("server 收到数据:", msg)
		// 将客户端发送的数据转大写并返回给client端
		_, err = conn.Write([]byte(strings.ToUpper(msg)))
		if err != nil{
			fmt.Println("server write err :", err)
			return
		}
	}
}

func main() {
	// 一. 创建套接字socket
	// 指定server端使用的通信协议, 并绑定ip 和 port
	listener, err := net.Listen("tcp", "127.0.0.1:8384")
	defer listener.Close()
	if err != nil{
		fmt.Println("server start err :", err)
		return
	}
	fmt.Println("server start success...")
	// 二. 创建用于连接通信的socket
	// 调用 Accept 监听连接,此时会阻塞server端,直到有客户端发送连接,, server端每收到一个连接,都会创建一个conn
	for  {  // 循环等待创建连接,实现可以接收多个client的连接功能
		conn, err:= listener.Accept()  // 阻塞等待连接
		if err != nil{
			fmt.Println("server accept err :", err)
			return
		}
		// 并发创建用于完成server 与 client 数据通信的函数
		go HandlerConnent(conn)  // 将conn socket传入
	}
}

并发版client

package main

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

func main() {
	// 一. 客户端创建用于通信的socket
	// 指定通信协议,并指定server端 IP PORT
	conn, err := net.Dial("tcp", "127.0.0.1:8384")
	if err != nil{
		fmt.Println("client start err :", err)
		return
	}
	// 创建go程, 用来获取键盘输入
	go func() {
		str := make([]byte, 4096)
		for{
			n, err := os.Stdin.Read(str)  // 获取键盘输入
			if err != nil{
				fmt.Println("client os.Stdin.Read err :", err)
				continue
			}
			_, err = conn.Write(str[:n])
			if err != nil{
				fmt.Println("client write err :", err)
				return
			}
		}
	}()
	// 打印server 返回的数据
	buf := make([]byte, 4096)
	for{
		n, err := conn.Read(buf)
		if err != nil{
			fmt.Println("client read err :", n, err)  // 当server断开与client的连接后 client read err : 0 EOF
			return
		}
		fmt.Println("client 收到数据:", string(buf[:n]))
	}
}

UDP

UCP server

package main

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

func main() {
	// 一. 组织一个udp地址结构,绑定IP PORT
	serverAddr, err:= net.ResolveUDPAddr("udp","127.0.0.1:8001")
	if err != nil{
		fmt.Println("server band IP err :", err)  // 当server断开与client的连接后 client read err : 0 EOF
		return
	}
	// 二. 创建用于通信的socket  注意:UDP 只有一个套接字socket
	udpConn, err := net.ListenUDP("udp", serverAddr)
	if err != nil{
		fmt.Println("server ListenUDP err :", err)  // 当server断开与client的连接后 client read err : 0 EOF
		return
	}
	fmt.Println("server start success...")
	defer udpConn.Close()
	// 三. 读取client发送的数据
	buf := make([]byte, 4096)
	n, clientAddr, err := udpConn.ReadFromUDP(buf)  // n:读到的字节数 clientAddr:客户端地址 err:错误信息
	if err != nil{
		fmt.Println("server ReadFromUDP err :", err)  // 当server断开与client的连接后 client read err : 0 EOF
		return
	}
	// 四. 处理数据
	fmt.Println(clientAddr)
	fmt.Println(string(buf[:n]))
	// 会写数据给client
	nowTime := time.Now().String()
	n, err = udpConn.WriteToUDP([]byte(nowTime),clientAddr)
	if err != nil{
		fmt.Println("server WriteToUDP err :", err)
		return
	}
}

并发版 server

package main

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

func main() {
	// 一. 组织一个udp地址结构,绑定IP PORT
	serverAddr, err:= net.ResolveUDPAddr("udp","127.0.0.1:8001")
	if err != nil{
		fmt.Println("server band IP err :", err)  // 当server断开与client的连接后 client read err : 0 EOF
		return
	}
	// 二. 创建用于通信的socket
	udpConn, err := net.ListenUDP("udp", serverAddr)
	if err != nil{
		fmt.Println("server ListenUDP err :", err)  // 当server断开与client的连接后 client read err : 0 EOF
		return
	}
	fmt.Println("server start success...")
	defer udpConn.Close()
	for{
		// 三. 读取client发送的数据
		buf := make([]byte, 4096)
		n, clientAddr, err := udpConn.ReadFromUDP(buf)  // n:读到的字节数 clientAddr:客户端地址 err:错误信息
		if err != nil{
			fmt.Println("server ReadFromUDP err :", err)  // 当server断开与client的连接后 client read err : 0 EOF
			return
		}
		// 四. 处理数据
		fmt.Println(clientAddr)
		fmt.Println(string(buf[:n]))
		
		go func() {
			// 回写数据交给go程,udp socket 将写好的数据发送给目标IP
			nowTime := time.Now().String()
			n, err = udpConn.WriteToUDP([]byte(nowTime),clientAddr)
			if err != nil{
				fmt.Println("server WriteToUDP err :", err)
				return
			}
		}()
	}
}

案例 TCP 聊天室

server

package main

import (
	"encoding/json"
	"fmt"
	"net"
	"strings"
	"time"
)

// 创建用户结构体类型
type Client struct {
	C chan string  // 传输用户接收的msg信息
	Name   string
	Addr   string
}

func (c *Client)setName(name string)  {
	c.Name = name
}


// 创建用于存储用户的map
var onlineMap map[string]*Client

// 创建全局 channle 用来传递用户消息
var message = make(chan string)

func Manager()  {
	// 初始化全局map
	onlineMap = make(map[string]*Client)
	for{
		// 监听全局channel是否有数据,有数据取出,无数据阻塞
		msg := <- message
		// 将数据发送个每个用户
		for _,user := range onlineMap{
			user.C <- msg
		}
	}
}

func WriteMsgToClient(cli *Client, conn net.Conn)  {
	for sendMsg := range cli.C{
		_, err := conn.Write([]byte(sendMsg + "\n"))
		if err != nil{
			fmt.Println("conn.Write err", err)
		}
	}
}

func ReadMsgFromClient(cli *Client, conn net.Conn, quit ,hasActive chan <- int)  {
	buf := make([]byte, 4096)
	flg: for{
		n, err := conn.Read(buf)
		if n == 0{
			quit <- 1
			return
		}
		if err != nil{
			fmt.Println("conn.Read err", err)
			continue flg
		}
		strList := strings.Split(string(buf[:n]), " ")
		switch strList[0] {
		case "exit":
			quit <- 1
		case "setName":
			cli.setName(strList[1])
			cli.C <- "setName success"
			continue flg
		case "getUsers":
			//usersBuf := make([]byte, 4096)
			userList := []string{}
			for _,user := range onlineMap{
				userList = append(userList, user.Name)
			}
			data, _ := json.Marshal(userList)
			cli.C <- string(data)
		}
		hasActive <- 1
		message <- cli.Name + ":" +string(buf[:n])
	}
}

func HanderConnect(conn net.Conn)  {
	defer conn.Close()
	// 获取client IP
	addr:=conn.RemoteAddr().String()
	// 创建用户
	cli := Client{make(chan string),addr,addr}
	// 将用户添加到全局map中
	onlineMap[addr]=&cli
	// 创建监听用户瑞出的channel
	quit := make(chan int)
	// 创建判断用户是否活跃的channel
	hasActive := make(chan int)
	// 创建给该用户传递消息的go程
	go WriteMsgToClient(&cli, conn)
	// 将用户上线信息写到message
	message <- "["+ addr +"] "+ cli.Name +"  login"
	// 获取用户输入,将输入信息写入message送给所有人
	go ReadMsgFromClient(&cli, conn, quit, hasActive)
	for{
		select {
		case <- quit:
			delete(onlineMap, cli.Addr)
			fmt.Printf("%s 退出, 断开连接 \n", cli.Name)
			return
		case <- time.After(time.Second*5):  // 定时器, select刷新一遍,定时器才会重新计时
			delete(onlineMap, cli.Addr)
			fmt.Printf("%s 超时退出 \n",cli.Name)
			return
		case <- hasActive:  // 这个channel的作用是判断用户若活跃,则刷新select,使计时器重新计时
		}
	}
}

func main() {
	// 创建socket
	Listener , err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil{
		fmt.Println(" net.Listen err", err)
		return
	}
	fmt.Println("server starting...")
	// 创建管理者go程,用来管理 全局map和全局channel
	go Manager()
	// 循环监听连接
	for{
		conn,err := Listener.Accept()
		if err != nil{
			fmt.Println(" Listener.Accept err", err)
			return
		}
		// 循环通信
		go HanderConnect(conn)
	}
}

Client

package main

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

func main() {
	// 一. 客户端创建用于通信的socket
	// 指定通信协议,并指定server端 IP PORT
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil{
		fmt.Println("client start err :", err)
		return
	}
	// 创建go程, 用来获取键盘输入
	go func() {
		str := make([]byte, 4096)
		for{
			n, err := os.Stdin.Read(str)  // 获取键盘输入
			if err != nil{
				fmt.Println("client os.Stdin.Read err :", err)
				continue
			}
			_, err = conn.Write(str[:n])
			if err != nil{
				fmt.Println("client write err :", err)
				return
			}
		}
	}()
	// 打印server 返回的数据
	buf := make([]byte, 4096)
	for{
		n, err := conn.Read(buf)
		if err != nil{
			fmt.Println("client read err :", n, err)  // 当server断开与client的连接后 client read err : 0 EOF
			return
		}
		fmt.Println(string(buf[:n]))
	}
}

i0208
关注
专栏目录
Golang socket编程
SmartShepi的博客
03-30 609
目录socket编程基本概念TCP客户端服务端UDP客户端服务端实例&常见问题构建http服务基本概念客户端服务端实例&常见问题 socket编程 基本概念 TCP 客户端 服务端 UDP 客户端 服务端 实例&常见问题 构建http服务 基本概念 客户端 服务端 实例&常见问题 ...
Go语言学习笔记—golang TCP编程
qq_39280718的博客
07-25 2355
TCP socket 编程，是网络编程的主流。之所以叫 Tcp socket 编程，是因为底层是基于 Tcp/ip 协议的.
socks5:Go中的SOCKS协议版本5库。 全面的TCPUDP和IPv4IPv6支持
05-03
袜子5 SOCKS协议版本5库。 完全的TCP / UDP和IPv4 / IPv6支持。 目标：KISS，少即是多，小型API，代码就像原始协议一样。 安装 $ go get github.com/txthinking/socks5 结构就像协议中的概念 谈判： type NegotiationRequest struct func NewNegotiationRequest(methods []byte)在客户端 func (r *NegotiationRequest) WriteTo(w io.Writer) ，客户端写入服务器 func NewNegotiationRequestFrom(r io.Reader) ，服务器从客户端读取 type NegotiationReply struct 在服务器中使用func NewNegotiationReply(method by
udp socket - golang
雨竹的博客
04-14 726
前面说了几个tcp模式下的socket新手易错点，今天就来看看udp的新手易错点。 先让我们看一段代码： l, e := net.ListenPacket("udp", ":9090") if e != nil { fmt.Println(e) } b := make([]byte, 10) for { n...
非零基础自学Golang 第19章 Socket编程 19.4 UDP编程 19.4.3 UDP服务端 & 19.5 小结 & 19.6 知识拓展
谢谢你们的关注
12-29 196
非零基础自学Golang 第19章 Socket编程 19.4 UDP编程 19.4.3 UDP服务端 & 19.5 小结 & 19.6 知识拓展
非零基础自学Golang 第19章 Socket编程 19.4 UDP编程 19.4.1 UDP简介 & 19.4.2 UDP客户端
谢谢你们的关注
12-28 271
非零基础自学Golang 第19章 Socket编程 19.4 UDP编程 19.4.1 UDP简介 & 19.4.2 UDP客户端
Go语言网络编程（socket编程）UDP
最新发布
编程技术， 日益精进
09-08 723
UDP协议（User Datagram Protocol）中文名称是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联）参考模型中一种无连接的传输层协议，不需要建立连接就能直接进行数据发送和接收，属于不可靠的、没有时序的通信，但是UDP协议的实时性比较好，通常用于视频直播相关领域。
golang如何利用原始套接字构造UDP包详解
09-21
在Golang中，原始套接字（RAW SOCKET）允许开发者直接操作网络协议栈，从而能够构建自定义的数据包，如TCP、UDP等。本篇将详细介绍如何利用原始套接字构造UDP包，这对于网络编程、协议分析或特殊场景的网络通信具有...
traceroute:golang UDP和TCP traceroute
04-19
标题中的"traceroute:golang UDP和TCP traceroute"指出，这是一个使用Golang编程语言实现的Traceroute工具，它同时支持UDP和TCP协议。Traceroute是网络诊断工具，用于跟踪数据包在网络中从源到目的地所经过的路由器...
基于raw socket的UDP数据的发送和接收
01-28
在计算机网络编程中，Raw Socket是一种底层的网络通信机制，允许程序员直接操作网络协议的细节，包括IP头、TCP头、UDP头等。本篇将深入探讨如何利用Raw Socket进行基于UDP的数据发送与接收，以及自定义这些头部信息...
golang--UDP通信
IT艺术家-rookie的博客
02-28 863
udp
Golang_14: Go语言 网络编程：TCP 与 UDP（socket 编程）
谢TS的博客
05-26 578
Go 语言的 net 包为网络 I/O 提供了可一个可移植的接口，包括 TCP/IP、UDP、域名解析 和 Unix域套接字。 尽管 net 包提供了对低级网络原语的访问，但大多数情况下只需要使用 Dial()、Listen() 和 Accept() 函数以及相关的 Conn 和 Listener 接口提供的基本方法。crypto/tls 包使用相同的接口实现了 TLS 版本的 Dial() 和 Listen() 功能。
Golang笔记：UDP基础使用与广播
Naisu的各种笔记
01-18 5819
UDP是比较基础常用的网络通讯方式，这篇文章将介绍Go语言中UDP基础使用的一些内容。
golang_day9-TCP-UDP
screenswindow的博客
10-13 106
互联网协议 OSI七层 应用层 - 表示层 - 会话层 - 传输层 - 网络层 - 数据链路层 - 物理层 OSI五层 应用层 - 传输层 - 网络层 - 数据链路层 - 物理层 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ShbQ1F5R-1602577641704)(https://www.liwenzhou.com/images/Go/socket/osi.png)] socket编程 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m5
Go语言---基于UDP的Socket编程
归子莫的博客
03-26 1050
Go语言–基于UDP的socket编程 博客说明 文章所涉及的资料来自互联网整理和个人总结，意在于个人学习和经验汇总，如有什么地方侵权，请联系本人删除，谢谢！ UDP简介 UDP协议（User Datagram Protocol）中文名称是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联）参考模型中一种无连接的传输层协议，不需要建立连接就能直接进...
服务器的socket编程UDP协议,Go socket编程实践: UDP服务器和客户端实现
weixin_39884492的博客
08-06 286
在上一篇文章Go socket编程实践: TCP服务器和客户端实现， 我们实现了一个ECHO服务器， 并且也实现了一个客户端来访问服务器。这篇文章讲解如何实现一个UDP服务器和客户端。这次我们使用的协议是 RFC 868，此协议提供了一个独立于站点的，机器可读的日期和时间信息。时间服务返回的提供了一个32位的数字，是从1900年1月1日午夜到现在的秒数。RFC 868定义时间协议使用端口37, T...
golang入门笔记—socket编程
qq_43716830的博客
04-10 712
//server端 package main //tcp server端 import ( "fmt" "net" ) func processConn(conn net.Conn) { //3.与客户端通信 var tmp [128]byte for { n, err := conn.Read(tmp[:]) if err != nil { fmt.Println("read from conn failed,err:", err) return } fmt..
go语言网络编程TCP和UDP
.
12-12 1815
TCP和UDP属于网络七层模型中传输层 TCP协议 TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。 UDP协议 Go语言实现TCP通信 一个TCP服务端可以同时连接很多个客户端，多个客户端可以同时像服务端发送消息，go语言中我们也可以使用线程来处理模拟多个客户端
go udp 简单实现
hyl999的专栏
08-04 1167
服务器端 udpserver.go// udpServer project main.go package mainimport ( "fmt" "net" )func main() { fmt.Println("udpserver") socket, err := net.ListenUDP("udp4", &net.UDPAddr{ IP: n
socket golang
08-30
Go语言中的socket编程可以使用`net`包来实现。...你可以根据自己的需要修改该示例代码，例如添加更复杂的数据处理逻辑或使用其他协议（如UDP）。希望对你有帮助！如果你还有其他问题，请继续提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值