go语言提升（四）：tcp/udp，命令行参数

最新推荐文章于 2023-06-30 11:36:33 发布
最新推荐文章于 2023-06-30 11:36:33 发布
阅读量350 收藏 1
点赞数
分类专栏： go 文章标签： go语言 tcpip udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41775886/article/details/112641169
版权

go语言提升（四）：tcp/udp，命令行参数

1.TCP函数原型及服务器实现

  1. Listen函数
func Listen(net, laddr string) (Listener, error)
  • 参数1：协议类型：tcp、upd(必须小写)
  • 参数2：服务器端的IP:port(192.168.31.11:8000)
  • 返回值：成功创建的监听器
type Listener interface{
    Addr() addr
    Accept() (c Conn, err error)
    Close() error
}

type Addr interface {
    Network() string // 网络名
    String() string  // 字符串格式的地址
}
  1. Accept函数–阻塞等待客户端连接
(listener *Listener) Accpt() (c Conn, err error)
  • 返回值：成功与客户端建立的连接(socket)
type Conn interface {
    // Read从连接中读取数据
    // Read方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
    Read(b []byte) (n int, err error)
    // Write从连接中写入数据
    // Write方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
    Write(b []byte) (n int, err error)
    // Close方法关闭该连接
    // 并会导致任何阻塞中的Read或Write方法不再阻塞并返回错误
    Close() error
    // 返回本地网络地址
    LocalAddr() Addr
    // 返回远端网络地址
    RemoteAddr() Addr
    // 设定该连接的读写deadline，等价于同时调用SetReadDeadline和SetWriteDeadline
    // deadline是一个绝对时间，超过该时间后I/O操作就会直接因超时失败返回而不会阻塞
    // deadline对之后的所有I/O操作都起效，而不仅仅是下一次的读或写操作
    // 参数t为零值表示不设置期限
    SetDeadline(t time.Time) error
    // 设定该连接的读操作deadline，参数t为零值表示不设置期限
    SetReadDeadline(t time.Time) error
    // 设定该连接的写操作deadline，参数t为零值表示不设置期限
    // 即使写入超时，返回值n也可能>0，说明成功写入了部分数据
    SetWriteDeadline(t time.Time) error
}

test

package main

import (
	"bytes"
	"fmt"
	"net"
)

func main() {
	// 1. 创建监听器
	listener, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("Listen error:", err)
		return
	}
	defer listener.Close()

	fmt.Println("-----------1")

	// 2. 阻塞等待客户端连接
	conn, err := listener.Accept()
	if err != nil {
		fmt.Println("Accept error:", err)
		return
	}
	defer conn.Close()

	fmt.Println("-----------2")

	// 创建buffer 存储读取到的客户端数据
	buf := make([]byte, 4096)

	for {
		// 3. 读取客户端发送的数据
		n, err := conn.Read(buf)
		if err != nil {
			fmt.Println("Read err:", err)
			return
		}

		fmt.Printf("服务器读到, 客户端数据%s\n", string(buf[:n]))
		// 4. 处理客户端数据
		// 小写转大写
		buf = bytes.ToUpper(buf)

		// 5. 回发数据给客户端
		conn.Write(buf)
	}

	fmt.Println("通信结束!")
	// 6. 创建客户端进行测试, 使用nc命令
}

在这里插入图片描述

2. 客户端实现

  • Dial方法

    func Dial(network, address string) (Conn, error)
    • 参数1：使用的协议：udp/tcp(注意一定是小写)
    • 参数2：指定服务器的ip:port(127.0.0.1:8000)
    • 返回值：用于进行通信的socket
    type Conn interface {
    // Read从连接中读取数据
    // Read方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
    Read(b []byte) (n int, err error)
    // Write从连接中写入数据
    // Write方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
    Write(b []byte) (n int, err error)
    // Close方法关闭该连接
    // 并会导致任何阻塞中的Read或Write方法不再阻塞并返回错误
    Close() error
    // 返回本地网络地址
    LocalAddr() Addr
    // 返回远端网络地址
    RemoteAddr() Addr
    // 设定该连接的读写deadline，等价于同时调用SetReadDeadline和SetWriteDeadline
    // deadline是一个绝对时间，超过该时间后I/O操作就会直接因超时失败返回而不会阻塞
    // deadline对之后的所有I/O操作都起效，而不仅仅是下一次的读或写操作
    // 参数t为零值表示不设置期限
    SetDeadline(t time.Time) error
    // 设定该连接的读操作deadline，参数t为零值表示不设置期限
    SetReadDeadline(t time.Time) error
    // 设定该连接的写操作deadline，参数t为零值表示不设置期限
    // 即使写入超时，返回值n也可能>0，说明成功写入了部分数据
    SetWriteDeadline(t time.Time) error
}

  • test

    package main

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

func main() {
	// 1. 创建用于通信的套接字
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Println("Dial error:", err)
		return
	}
	defer conn.Close()

	buf := make([]byte, 4096)

	for {
		// 2. 发送数据给服务器
		conn.Write([]byte("abcde"))

		// 3. 接收服务器回发数据
		n, err := conn.Read(buf)
		if err != nil {
			fmt.Println("Read error:", err)
		}
		fmt.Println("客户端收到:", string(buf[:n]))
		time.Sleep(time.Second*2)
	}

	// 4. 关闭连接(已defer)
}

3. 并发服务器

主go程：负责监听客户端的连接事件并且创建出conn

子go程：负责与客户端进行实时的交互和信息通信

业务流程

  1. 常见监听器Listener
  2. 使用for监听listener – Accept()
  3. 当有客户端连接上来，创建子go程，使用conn与客户端进行数据通信
  4. 封装、实现函数：完成单个子go程与客户端的read、write – handleConnect(conn)
    1. 读取客户端的数据 conn.read()
    2. 处理数据 小 – 大 toUpper()
    3. 写回大写数据到客户端
package main

import (
	"bytes"
	"fmt"
	"io"
	"net"
	"runtime"
)

func handleConnect(conn net.Conn) {
	defer conn.Close()

	fmt.Println("当前ip:", conn.RemoteAddr())

	// 创建buffer 存储读取到的客户端数据
	buf := make([]byte, 4096)

	for {
		// 读取客户端发送的数据
		n, err := conn.Read(buf)

		// 当读到exit就退出
		if string(buf[:n-1]) == "exit" {
			fmt.Println("服务器收到客户端[", conn.RemoteAddr().String(), "]关闭，关闭本端")
			runtime.Goexit()
		}

		if n == 0 {
			fmt.Println("服务器检测到客户端退出")
			runtime.Goexit()
		}
		if err != nil && err != io.EOF {
			fmt.Println("Read err:", err)
			return
		}

		fmt.Printf("服务器读到, 客户端数据%s\n", string(buf[:n-1]))
		// 处理客户端数据
		// 小写转大写
		buf = bytes.ToUpper(buf)

		// 回发数据给客户端
		_, err = conn.Write(buf[:n])
		if err != nil {
			fmt.Println("Write error:", err)
			return
		}
	}
}

func main() {
	// 1. 创建监听器
	listener, err := net.Listen("tcp", "127.0.0.1:8001")
	if err != nil {
		fmt.Println("Listen error:", err)
		return
	}
	defer listener.Close()

	// 2. 使用for监听，每有一次连接创建一个go程
	for {
		// 2. 阻塞等待客户端连接
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Accept error:", err)
			continue
		}
		go handleConnect(conn)
	}
}

4. 实现nc命令

package main

import (
	"fmt"
	"io"
	"net"
	"os"
	"runtime"
)

func getFromKeyBoard(conn net.Conn, buf []byte) {
	n, err := os.Stdin.Read(buf)
	if err != nil {
		fmt.Println("Dial error:", err)
		return
	}

	// 3. 将buf中的数据写给服务器
	_, err = conn.Write(buf[:n])
	if err != nil {
		fmt.Println("Write error:", err)
		return
	}

	if string(buf[:n-1]) == "exit" {
		fmt.Println("客户端结束退出")
		os.Exit(1)
	}
}

func readConn(conn net.Conn, buf []byte) {
	n, err := conn.Read(buf)
	if n == 0 {
		fmt.Println("服务器关闭")
		runtime.Goexit()
	}
	if err != nil && err != io.EOF {
		fmt.Println("Read error:", err)
		return
	}
	// 5. 应用数据/打印
	fmt.Println("从服务器读到：", string(buf[:n-1]))
}

func main() {
	// 1. 与服务器建立连接
	conn, err := net.Dial("tcp", "127.1:8001")
	if err != nil {
		fmt.Println("Dial error:", err)
		return
	}
	defer conn.Close()

	buf := make([]byte, 4096)

	for {
		// 2. 从键盘获取键盘输入 -- os.Stdin.Read -> buf
		getFromKeyBoard(conn, buf)

		// 4. 创建go程将读取服务器回发的数据 conn.Read
		go readConn(conn, buf)
	}
}

5. UDP服务器的实现

实现流程：

  1. 获取UDP的地址结构 – UDPAddr

    func ResolveUDPAddr(net, addr string) (*UDPAddr, error)
    • 参数1：“udp”
    • 参数2：“ip:port”
    • 返回值：UDP地址结构

  2. 绑定地址结构体， 得到通信套接字 – udpConn

    func ListenUDP(net string, laddr *UDPAddr) (*UDPConn, error)
    • 参数1：“udp”
    • 参数2：ResolveUDPAddr的返回值：UDPAddr
    • 返回值：用于通信的socket

  3. 接收客户端发生的数据 – ReadFromUDP() – n, cltAddr, err

    func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)
    • 参数：接收数据的缓冲区
    • 返回值：
      • n：读到的实际字节数
      • addr：对端的地址结构(ip+port)

  4. 写数据给客户端 – WriteToUDP(数据，cltAddr) – n, err

    func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)
    • 参数1：实际写出的数据
    • 参数2：对端的地址结构
    • 返回值：实际写出的字节数
type UDPAddr struct {
    IP   IP
    Port int
    Zone string // IPv6范围寻址域
}

Demo

package main

import (
	"bytes"
	"fmt"
	"net"
)

func main() {
	// 1. 获取UDP的地址结构
	udpAddr, err := net.ResolveUDPAddr("udp", "127.1:8002")
	if err != nil {
		fmt.Println("ResolveUDPAddr error:", err)
		return
	}

	// 2. 绑定地址结构体， 得到通信套接字
	udpConn, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		fmt.Println("ListenUDP error:", err)
		return
	}
	defer udpConn.Close()

	for {
		// 3. 接收客户端发生的数据
		buf := make([]byte, 4096)
		n, addr, err := udpConn.ReadFromUDP(buf)
		if err != nil {
			fmt.Println("ReadFromUDP error:", err)
			return
		}
		fmt.Println("UDP服务器读到:", string(buf[:n-1]))
		// 小写转大写
		buf = bytes.ToUpper(buf)

		// 4. 写数据给客户端
		_, err = udpConn.WriteToUDP(buf[:n], addr)
		if err != nil {
			fmt.Println("WriteToUDP error:", err)
			return
		}
	}
}

6. UDP客户端的实现

与TCP相同，直接用Dial创建出来的套接字通信即可

package main

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

func main() {
	conn, err := net.Dial("udp", "127.1:8002")
	if err != nil {
		fmt.Println("Dial err", err)
		return
	}
	defer conn.Close()

	go func() {
		str := make([]byte, 4096)
		for {
			n, err := os.Stdin.Read(str)
			if err != nil {
				fmt.Println("Stdin.Read error:", err)
				return
			}
			_, err = conn.Write(str[:n])
			if err != nil {
				fmt.Println("Write error:", err)
				return
			}
		}
	}()

	buf := make([]byte, 4096)
	for {
		n, err := conn.Read(buf)
		if n == 0 {
			fmt.Println("检测到服务器关闭，关闭本端")
			return
		}
		if err != nil && err != io.EOF {
			fmt.Println("Read error:", err)
			return
		}

		fmt.Println("客户端读到:", string(buf[:n-1]))
	}
}

7. 命令行参数的使用

直接看demo

func main() {
	list := os.Args
	for i, arg := range list {
		fmt.Printf("[%d]:%s\n", i, arg)
	}
}

os.Args获取命令行参数的切片

alin Wang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go语言web开发框架学习系列四：Iris框架设置操作
qfliweimin的博客
07-15 385
Iris框架设置操作 路由组的使用 在实际开发中，我们通常都是按照模块进行开发，同一模块的不同接口url往往是最后的一级url不同，具有相同的前缀url。因此，我们期望在后台开发中，可以按照模块来进行处理我们的请求，对于这种需求，iris框架也是支持的。 usersRouter := app.Party("/admin", userMiddleware) 如上述代码所示，iris框架中使用app.Party方法来对请求进行分组处理，第二个参数是处理路由组的中间件方法，通常情况下我们会在中间件中写c
在Go中构建并发TCP服务器
01-03
开发一个并发TCP服务器，该服务器仅使用大约65行GO代码生成随机数。 TCP和UDP服务器随处可见，通过TCP/IP网络为网络客户端提供服务。在本文中，我将在GO编程语言，返回随机数。对于来自TCP客户端的每个传入连接，TCP服务器将启动一个新的goroutine来处理该请求。 你可以找到这个项目，concTCP.go，在GitHub上。 处理TCP连接 程序的逻辑可以在handleConnection()职能，其实现方式如下： func handleConnection(c net.Conn) { fmt.Printf(Serving %s\n, c.RemoteAddr(
go tcp客户端自动重连_在Go中构建并发TCP服务器样例
weixin_39782573的博客
11-23 250
开发一个并发TCP服务器，只使用大约65行Go代码生成随机数。本文是Mihalis Tsoukalos的Go系列的一部分。阅读第1部分：在Go中创建随机安全密码。TCP和UDP服务器无处不在，通过TCP / IP网络为网络客户端提供服务。在本文中，我将解释如何使用Go编程语言开发一个返回随机数的并发TCP服务器。对于来自TCP客户端的每个传入连接，TCP服务器将启动一个新的goroutine来处理...
go语言网络编程TCP和UDP
.
12-12 1794
TCP和UDP属于网络七层模型中传输层 TCP协议 TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。 UDP协议 Go语言实现TCP通信 一个TCP服务端可以同时连接很多个客户端，多个客户端可以同时像服务端发送消息，go语言中我们也可以使用线程来处理模拟多个客户端
Go语言net模块TCP和UDP编程实践
最新发布
hsy12342611的专栏
06-30 1350
Go语言net模块TCP和UDP编程实践
Golang TCP客户端命令行解析，根据参数连接服务器
小李的博客
05-23 8334
main.go： flag.Parse()调取命令行解析，在init函数中解析 ip与端口，用于后面生成 tcp连接对象。 func init() { flag.StringVar(&serverIp,"ip","127.0.0.1","set server ip") flag.IntVar(&serverPort,"port",8888,"set server port") } func main() { //命令行解析 flag.Parse() clien...
go语言学习笔记28------Goland之TCP、UDP通信①
在路上
09-13 911
1网络应用程序设计模式 1.1C/S模式 传统的网络应用设计模式，客户机(client)/服务器(server)模式。需要在通讯两端各自部署客户机和服务器来完成数据通信。 1.2B/S模式 浏览器(Browser)/服务器(Server)模式。只需在一端部署服务器，而另外一端使用每台PC都默认配置的浏览器即可完成数据的传输。 1.3优缺点 对于C/S模式来说，其优点明显。客户端位...
golang TCP/UDP简单入门
wanmei002的博客
01-02 508
net 包里的一些方法 ParseIP(string) // 验证IP地址字符串 返回 IP 对象 type IPMask []byte // 子网掩码类型 func IPv4Mask(a, b, c, d byte) IPMask // 用一个四字节的IPv4地址来创建一个掩码 func (ip IP) DefaultMask() IPMask // 这是一个IP方...
Go实现TCP、UDP、HTTP通信代码示例
weixin_39218464的博客
04-20 2627
TCP通信需求 服务端： 服务端在本机的8888端口建立TCP监听 为接入的每一个客户端开辟一条独立的协程 循环接收客户端消息，不管客户端说什么，都自动回复“已阅xxx” 客户端： 如果客户端说的是“im off”，则回复“bye”并断开其连接 拨号连接服务端主机的8888端口，建立连接 循环从标准输入（命令行）读取一行用户输入，向服务端发送 接收并打印服务端消息，如果消息是“bye”，就退出程序 服务端： package main import ( "net" "fmt" "os" ) /* ·
网络编程入门
itzhuzhu的博客
10-02 956
概述： 网络编程概述 IP地址类InetAddress UDP TCP 文件上传 文件上传（多线程） 模拟网站服务器 1.网络编程概述 什么是网络编程? 编写在不同计算机之间传输数据的程序 计算机软件结构? C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构 B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。 我们要想在不同计算机...
Go语言实现TCP连接
weixin_45774311的博客
04-05 1135
服务端 package main import ( "fmt" "net" ) func process(conn net.Conn) { defer conn.Close() for { buf := make([]byte, 1024) fmt.Printf("服务器在等待客户端%s发送信息\n", conn.RemoteAddr().String()) n, err := conn.Read(buf) if err != nil { fmt.Println("客户
go测试TCP最大连接数
weixin_34195546的博客
10-27 1164
2019独角兽企业重金招聘Python工程师标准>>> ...
一文搞懂Go语言网络编程【tcp、udp】
一个非常Cool的人
01-18 3043
介绍了网络通信协议tcp、udp以及对粘包问题的解决方案,没有讲http.net包,需要看http.net包可以看本专栏其他博文。
测试TCP和UDP端口的方法
热门推荐
iw1210的专栏
06-07 14万+
测试TCP和UDP端口的方法 下面以Linux平台为例，讲述测试TCP和UDP端口的方法。 有两个命令可以用来测试端口，一个是telnet，一个是nc，但telnet只能用于测试TCP端口，而nc即可用于测试TCP端口也可用来测试UDP端口。 【telnet命令的用法】 telnet IP port 例如： [root@localhost]# telnet 192.168.0.
TCP和UDP的优缺点及区别
weixin_30719711的博客
03-09 1307
TCP的优点： 可靠，稳定 TCP的可靠体现在TCP在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源。 TCP的缺点： 慢，效率低，占用系统资源高，易被攻击 TCP在传递数据之前，要先建连接，这会消耗时间，而且在数据传递时，确认机制、重传机制、拥塞控制机制等都会消耗大量的时间，而且要在每台设备上维护所有的传输连接...
golang udp 指定本地地址和端口
云淡风轻
05-16 8176
指定本地地址为127.0.0.1 端口7770 localip := net.ParseIP("127.0.0.1") remoteip := net.ParseIP("127.0.0.1") lAddr := &net.UDPAddr{IP: localip, Port: 7770} rAddr := &net.UDPAddr{IP: remot...
go语言学习笔记29------Goland之TCP、UDP通信并发②
在路上
09-15 1581
1.TCP并发C/S模型通信 1.1并发Server 现在已经完成了客户端与服务端的通信，但是服务端只能接收一个用户发送过来的数据，怎样接收多个客户端发送过来的数据，实现一个高效的并发服务器呢？ Accept()函数的作用是等待客户端的链接，如果客户端没有链接，该方法会阻塞。如果有客户端链接，那么该方法返回一个Socket负责与客户端进行通信。所以，每来一个客户端，该方法就应该返回一个Soc...
计算机语言dial,Go语言Dial()函数：建立网络连接
weixin_34237362的博客
07-16 873
Go语言中Dial()函数的原型如下：funcDial(net,addrstring)(Conn,error)其中net参数是网络协议的名字，addr参数是IP地址或域名，而端口号以“:”的形式跟随在地址或域名的后面，端口号可选。如果连接成功，返回连接对象，否则返回error。我们来看一下几种常见协议的调用方式。1)TCP链接：conn,err:=net.Dial("tcp","192.168.0...
TCP详解之三次握手、四次挥手
每天多学一点点. 的博客
01-11 918
在互联网很多岗位的面试中TCP的三次握手、四次挥手都是不可绕过的话题，有很高的热点度.今天我就带大家来看看什么是三次握手、四次挥手. 在讲之前，我们先来了解下TCP协议是什么 1. TCP协议 TCP协议全称: 传输控制协议, 顾名思义, 就是要对数据的传输进行一定的控制. 我们来分析分析每部分的含义和作用 源端口号/目的端口号: 表示数据从哪个进程来, 到哪个进程去. 32位序号: ...
计算机语言dial,Go语言DialTCP()：网络通信【Go语言教程】
weixin_30146171的博客
07-16 677
实际上，在前面《Dial()函数》一节中介绍的 Dial() 函数其实是对 DialTCP()、DialUDP()、DialIP() 和 DialUnix() 的封装。我们也可以直接调用这些函数，它们的功能是一致的。这些函数的原型如下：func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err error)func DialUD...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值