【Go语言学习】——网络编程

最新推荐文章于 2024-09-22 19:10:04 发布
原创 最新推荐文章于 2024-09-22 19:10:04 发布 · 640 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络 #学习 #golang

本文介绍了Go语言中的网络编程，包括TCP通信中的黏包问题及其原因：发送端的Nagle算法和接收端的缓冲区机制。解决黏包的方法是自定义协议，通过包头指示数据长度。此外，还提及了UDP服务端的简单使用，它无需建立连接即可进行数据交换。

网络编程

参考博客

  • TCP通信

    服务器：

    package main

import (
	"fmt"
	"net"
)

// tcp server端

func processConn(conn net.Conn) {
	// 3.与客户端通信,通过循环一直接受连接
	for {
		var tmp [128]byte
		// 参数为切片
		n, err := conn.Read(tmp[:])
		if err != nil {
			fmt.Println("read from conn failed,err:", err)
			return
		}
		// 切片转换为字符串,不然读出来的是一串ASCLL码
		fmt.Println(string(tmp[:n]))
	}
}

func main() {
	// 1.本地端口启动服务
	listener, err := net.Listen("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Println("start tcp on 127.0.0.1:20000 failed,err:", err)
		return
	}
	// 2.等待客户端建立连接
	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("accept failed,err", err)
			return
		}
		go processConn(conn)
	}
}

    客户端：

    package main

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

// tcp client

func main() {
	// 1.与server端建立连接
	conn, err := net.Dial("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Println("dial 127.0.0.1:20000 failed,err:", err)
		return
	}
	// 2.发送数据
	reader := bufio.NewReader(os.Stdin)
	var msg string
	for {
		fmt.Print("请输入内容：")
		msg, _ = reader.ReadString('\n') //读到换行
		msg = strings.TrimSpace(msg)
		if msg == "exit" {
			break
		}
		conn.Write([]byte(msg))
	}
	// 通过命令行输入参数
	// if len(os.Args) < 2 {
	// 	msg = "hello world"
	// } else {
	// 	msg = os.Args[1]
	// }
	// conn.Write([]byte(msg))
	conn.Close()
}

  • TCP黏包

    TCP数据传输模式是流模式，保持长时间的连接和多次的收发数据，但这也导致会出现“黏包” 的情况，在客户端和服务器都有可能发生。

    发送端的黏包：由于Nagle算法为了改善网络传输的效率，TCP收到收到数据后不会立即发送，而是会等待一段时间看是否还有需要发送的数据，再一起发送。

    接收端的黏包：TCP接受到数据不会立即读取，而是会把数据放在缓冲区中，再通知应用层取数据。而如果应用取出数据不及时就会导致缓冲区放了好几段数据。

    package main


// TCP黏包服务器端

import (
	"bufio"
	"fmt"
	"io"
	"net"
)

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	var buf [1024]byte
	for {
		n, err := reader.Read(buf[:])
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("read from client failed, err:", err)
			break
		}
		recvStr := string(buf[:n])
		fmt.Println("收到client发来的数据：", recvStr)
	}
}

func main() {

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


    package main

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

// TCP黏包客户端

// socket_stick/client/main.go

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:30000")
	if err != nil {
		fmt.Println("dial failed, err", err)
		return
	}
	defer conn.Close()
	for i := 0; i < 20; i++ {
		msg := `Hello, Hello. How are you?`
		conn.Write([]byte(msg))
		time.Sleep(time.Second)
	}
}

    解决方法就是自定义协议，为数据加上包头，确认每一次发送的数据的长度。接受方收到数据先查看长度，然后接受对应长度的数据。

    package protocol

import (
	"bufio"
	"bytes"
	"encoding/binary"
)

// Encode 将消息编码
func Encode(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
}

// Decode 解码消息
func Decode(reader *bufio.Reader) (string, error) {
	// 读取消息的长度
	lengthByte, _ := reader.Peek(4) // 读取前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[4:]), nil
}


    package main

import (
	"fmt"
	"net"

	"github.com/studygo/tcpsticky_solve/protocol"
)

// TCP解决黏包的客户端

// socket_stick/client/main.go

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:30000")
	if err != nil {
		fmt.Println("dial failed, err", err)
		return
	}
	defer conn.Close()
	for i := 0; i < 20; i++ {
		msg := `Hello, Hello. How are you?`
		b, err := protocol.Encode(msg)
		if err != nil {
			fmt.Println("Encode failed,err:", err)
			return
		}
		conn.Write(b)
	}
}


    package main

// TCP解决黏包服务器端

import (
	"bufio"
	"fmt"
	"io"
	"net"

	"github.com/studygo/tcpsticky_solve/protocol"
)

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		// 按照协议中定义的长度去取数据
		recvStr, err := protocol.Decode(reader)
		if err == io.EOF {
			return
		}
		if err != nil {
			fmt.Println("Decode failed,err:", err)
			return
		}
		fmt.Println("收到client发来的数据：", recvStr)
	}

}

func main() {

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

  • UDO服务端

    使用UDP通信不需要建立连接，直接向目标服务器和端口发送数据和监听接受数据就行。

    package main

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

// UDP客户端

func main() {
	socket, err := net.DialUDP("udp", nil, &net.UDPAddr{
		IP:   net.IPv4(127, 0, 0, 1),
		Port: 30000,
	})
	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("read reply msg failed，err:", err)
			return
		}
		fmt.Println("收到回复信息：", string(reply[:n]))
	}
}


    package main

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

// UDP server

func main() {
	// 第二个参数为监听的ip地址和端口号
	conn, err := net.ListenUDP("udp", &net.UDPAddr{
		IP:   net.IPv4(127, 0, 0, 1),
		Port: 30000,
	})
	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(string(data[:n]))
		reply := strings.ToUpper(string(data[:n]))
		// 发送数据
		conn.WriteToUDP([]byte(reply), addr)
	}
}
KayCh
关注
【第十讲】GO语言网络编程
earthzhang2021的博客
05-06 317
在本节课程中，我们将探讨Go语言的网络编程。Go语言具有内置的网络支持，使得开发网络应用程序变得更加容易和高效。Go语言的网络模型使用net包进行套接字编程使用http包构建Web应用程序如何编写高效、可靠的网络应用程序在本节课程中，我们探讨了Go语言的网络编程。我们学习了如何使用net包和http包执行套接字和Web编程，以及如何构建高效、可靠的网络应用程序。通过了解这些关键概念和最佳实践，我们可以编写更好的网络应用程序，并确保它们能够正常运行并满足用户需求。
Go基础：一文掌握Go语言网络编程
最新发布
数据知道的博客
10-09 2731
Go语言凭借强大的标准库和原生并发支持，非常适合网络编程开发。文章介绍了Go语言在网络编程中的核心概念和应用场景，包括TCP、UDP和HTTP等协议的具体实现方法。主要内容包括：1）网络编程核心概念（Listener、Conn、Addr等）；2）TCP服务器/客户端的实现流程与示例代码；3）UDP无连接通信的实现方式；4）利用net/http包构建HTTP服务。文章通过详细的代码示例展示了如何利用Go的Goroutine和Channel特性高效处理网络连接，并强调了连接管理的最佳实践。
GO语言使用之网络编程(TCP编程)
Science Explorer
09-13 5293
一、基本介绍 网络编程是一个复杂的学科， 协议（TCP/IP）、IP地址、端口等，推荐学习TCP-IP协议卷1-3. 下面通过一个实例来感受go中的TCP 编程。 二、TCP快速入门案例 1、服务端 服务端的处理流程： 监听端口 8888 接收客户端的tcp链接，建立客户端和服务器端的链接. 创建goroutine，处理该链接的请求(通常客户端会通过链接发送请求包) pack...
Go 语言中使用 bufio.NewReader 等函数实现快读
二哈
06-01 3698
Go 语言中如果标准输入的数据规模在 10 ^ 5 或者更大，那么如果直接使用 fmt.Scan() 和 fmt.Println() 函数读取数据和输出数据会非常慢，如果算法的时间复杂度更大一点就会超时，这个时候就需要借助于 bufio 包中的相关方法优化读取数据和输出数据的效率，可以使用 bufio.NewReader()，bufio.NewWriter()，fmt.Fscan()，fmt.Fprintln() 函数优化输入输出数据，我们可以使用 Go 语言生成一个 10 ^ 5 规模的数据简单测试一下（
go语言网络编程
gopher9511的博客
09-22 1810
TOCTOC。
Go语言网络编程
Kali与编程
03-17 1333
具体地，可以使用http.ListenAndServe函数创建HTTP服务器，使用http.Get函数和http.Post函数访问HTTP服务器，并使用http.ResponseWriter和http.Request实现HTTP请求和响应的读写操作。在Go语言中，可以使用net包实现套接字编程，具体地，可以使用net.Dial函数和net.Listen函数创建TCP连接和TCP服务器，使用net.Conn接口实现TCP连接的读写操作。在Go语言中，可以使用标准库中的net包实现TCP/IP协议的网络编程。
基于Go语言的编程学习——牛豆儿画图设计源码
09-27
而“基于Go语言的编程学习——牛豆儿画图设计源码”项目正是在这样的背景下诞生的一款儿童编程学习工具。该项目利用Go语言和JavaScript等多种编程语言，结合图形设计，为儿童提供了一个全新的编程学习平台。 牛豆儿...
Go 学习笔记——雨痕
11-28
Go语言，又称Golang，是一种静态类型的编程语言，由Google开发，于2007年首次对外公布，并在2009年进行了开源。Go语言的设计哲学是简洁、快速和安全。它支持垃圾回收，具有类型系统和一些并发控制机制。 变量的定义...
GO 语言学习辅导共220页.pdf
04-13
Go语言，又称为Golang，是由Google开发的一种静态类型的、编译型的、并发型且垃圾回收的编程语言。它设计简洁、效率高，特别适合于编写服务器端和网络应用。Go语言的语法接近C语言，但同时也引入了诸如goroutine（轻...
golang学习笔记12——Go 语言内存管理详解
GoppViper的博客
09-09 2284
Go 语言的内存管理机制使得开发者可以更加专注于业务逻辑的实现，而不必过多地关注内存管理的细节。通过合理地使用内存分配、垃圾回收和内存优化技术，可以提高程序的性能、减少内存泄漏和提高程序的稳定性。在实际开发中，开发者应该根据具体的需求选择合适的内存管理策略，以实现高效、可靠的程序。**关注我看更多有意思的文章哦！**👉👉。
go语言网络编程——UDP编程
Aaron_1997的博客
01-05 478
服务器端： package main import ( "fmt" "net" ) func main() { fmt.Println("UDP Server is listening……") listen, err := net.ListenUDP("udp", &net.UDPAddr{ IP: net.IPv4(0, 0 , 0, 0), Port: 30000, }) if err != nil { fmt.Println("listen failed, er
GO网络编程
06-30
golang网络编程，内容非常好，值得推荐，下载看看增加
Go语言基础之网络编程
aaronthon的博客
05-30 439
Go语言基础之网络编程 Go语言基础之网络编程 现在我们几乎每天都在使用互联网，我们前面已经学习了如何编写Go语言程序，但是如何才能让我们的程序通过网络互相通信呢？本章我们就一起来学习下Go语言中的网络编程。 关于网络编程其实是一个很庞大的领域，本文只是简单的演示了如何使用net包进行TCP和UDP通信。如需了解更详细的网络编...
Go语言的网络编程
DXB2021的博客
02-04 3047
一、Socket编程 很多游戏服务都是采用Socket来编写服务器端的，因为HTTP协议相对而言比较耗费性能。 对于底层网络应用开发者而言，几乎所有网络编程都是Socket，因为大部分底层网络的编程都离不开Socket编程。HTTP编程、Web开发、IM通信、视频流传输的底层都是Socket编程。 1、什么是Socket Socket编程主要是面向OSI模型的第三层和第四层协议。 Socket类型只有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。
go语言之网络编程
weixin_44706011的博客
06-21 366
现在我们几乎每天都在使用互联网，我们前面已经学习了如何编写Go语言程序，但是如何才能让我们的程序通过网络互相通信呢？本章我们就一起来学习下Go语言中的网络编程。 关于网络编程其实是一个很庞大的领域，本文只是简单的演示了如何使用net包进行TCP和UDP通信。如需了解更详细的网络编程请自行检索和阅读专业资料。 互联网协议介绍 互联网的核心是一系列协议，总称为”互联网协议”（Internet Protocol Suite），正是这一些协议规定了电脑如何连接和组网。我们理解了这些协议，就理解了互联网的原理。由于这
Go 语言网络编程
grb123的博客
10-08 362
golang 网络 TCP编程、HTTP编程、websocket编程
Python/Go语言面试笔试题集——机器学习&深度学习
- Go语言在系统编程、网络服务以及分布式系统中的优势和应用。 - Go语言与其他编程语言相比的性能优势和特点。 - Go语言的标准库和第三方库的应用，如用于并发的goroutine和channel。 这份资源提供了丰富的面试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值