当前位置： 首页 > article >正文

go语言网络编程

article 2024/11/16 4:18:04
  • 网络编程
  • Go语言网络编程相关API
  • Go语言网络编程架构
  • Go语言的网络编程实现基于以下几个关键原理：
  • bufio
  • bufio 包的主要功能和使用场景
  • 主要类型
  • 示例 tcp通信
  • 解决粘包
  • 粘包和拆包的产生原因
  • 解决方法
  • 示例

网络编程

Go语言网络编程相关API

1.1 net包
    net.Listen(network, address string): 创建一个网络监听器，等待进入的连接。它的第一个参数是网络类型（如"tcp"、"udp"等），第二个参数是要监听的地址。
    
    net.Dial(network, address string): 连接到指定的地址，返回一个连接对象。
    
    net.Conn接口: 提供了与网络连接相关的方法，包括：
    
    Read(b []byte) (n int, err error): 从连接中读取数据。
    Write(b []byte) (n int, err error): 向连接写入数据。
    Close() error: 关闭连接。
    net.Listener接口: 用于接受传入连接的接口，包含方法：
    
    Accept() (Conn, error): 接受一个连接请求。


1.2 net/http包
    http.HandleFunc(pattern string, handler func(ResponseWriter, *Request)): 注册处理函数，当请求的URL匹配指定模式时，执行该处理函数。
    
    http.ListenAndServe(addr string, handler Handler) error: 启动HTTP服务器并监听指定地址上的请求。
    
    http.Request结构体: 包含请求的各种信息，如方法、URL、头部信息等。
    
    http.ResponseWriter接口: 用于构造HTTP响应，包含方法来设置响应头和写入响应体。
    
    http.Get(url string): 发起一个GET请求并返回响应。

Go语言网络编程架构

Go的网络编程架构主要基于事件驱动和goroutine的并发模型。

每当一个新的连接被接受时，服务器会为其启动一个新的goroutine来处理该连接。

因此，Go语言能够轻松地处理大量的并发连接，而无需使用复杂的线程管理。

服务器架构：

监听端口：服务器通过net.Listen监听指定端口。
接受连接：使用listener.Accept()接收连接。
处理连接：为每个连接创建goroutine，执行自定义的处理逻辑。
关闭连接：在处理完成后，关闭连接释放资源。

客户端架构：

创建连接：通过net.Dial或http.Get创建连接。
发送请求：向服务器发送请求或数据。
接收响应：获取服务器的响应数据。
关闭连接：处理完成后，关闭连接。

Go语言的网络编程实现基于以下几个关键原理：

Goroutine和通道： Go的并发模型建立在轻量级goroutine之上。
每一个网络连接都可以在单独的goroutine中处理，这样可以有效利用系统资源，提高并发处理能力。
通道（channel）用于在多个goroutine之间传递数据，保证数据的安全和同步。

I/O多路复用： Go使用操作系统的I/O多路复用机制，如epoll（Linux）或kqueue（BSD），
来处理大量连接的读写事件，从而减少线程上下文切换的开销。

封装性和易用性： Go的net和net/http包提供了高层次的抽象，简化了网络编程的复杂性。
开发者不需要深入底层的socket编程，只需调用简单的API即可实现复杂的网络操作。

bufio

bufio 是 Go 语言标准库中的一个包，用于提供 buffered I/O（缓冲输入/输出）功能。

它通过对输入和输出操作进行缓冲处理，从而提高程序的性能，

减少系统调用的次数。bufio 常用于处理文件、网络连接等 I/O 操作。

bufio 包的主要功能和使用场景

提高效率：

bufio 使用内存中的缓冲区来存储数据，从而减少直接的系统调用次数（如读写磁盘或网络），提高了读写效率。

简单的接口：

bufio 提供了简单易用的接口，让开发者能够更方便地处理文本和二进制数据。

处理文本数据：

bufio 特别适合处理行或单词输入输出，可以方便地读取和写入文本数据。

主要类型

以下是 bufio 包中几个重要的类型：

Reader：

bufio.Reader 是一个结构体，用于缓存输入。通过 Read() 方法，可以从底层的 io.Reader 中读取数据，使用缓冲可以减少调用次数。
常用方法：
    Read(p []byte) (n int, err error): 从缓冲区读取数据到切片 p 中。
    ReadString(delim byte) (string, error): 读取直到遇到分隔符 delim 的数据，并返回作为字符串。
    ReadBytes(delim byte) ([]byte, error): 与 ReadString 类似，但返回字节切片。
    
示例：
    reader := bufio.NewReader(conn)
    message, err := reader.ReadString('\n') // 读取一行数据

            
Writer：

bufio.Writer 是一个结构体，用于缓存输出。可以将数据写入缓冲区，并在缓冲区填满后再一次性写入到底层的 io.Writer。
常用方法：
    Write(p []byte) (n int, err error): 将数据写入缓冲区。
    Flush() error: 将缓冲区中的数据写入到底层的 io.Writer。
示例：
    writer := bufio.NewWriter(conn)
    writer.Write([]byte("Hello, Client!\n")) // 写入数据到缓冲区
    writer.Flush() // 确保将数据写入连接
    
    
Scanner：

bufio.Scanner 提供了一个方便的方式来逐行读取输入，常用于处理文本数据。
常用方法：
    Scan() bool: 读取下一个 token，返回 true 表示成功。
    Text() string: 返回上一个 token 作为字符串。
示例：
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        line := scanner.Text() // 得到输入的一行
        fmt.Println(line)
    }

示例 tcp通信

这段代码实现了一个简单的聊天服务器，能够接收并广播消息到所有连接的客户端。
使用了 goroutines 来处理每个客户端的连接，
确保服务器能够同时处理多个连接。
通过 sync.Mutex 来保护对共享数据结构 clients 的并发访问。

package main

import (
	"bufio"      // 导入 bufio 包，用于读取输入
	"fmt"        // 导入 fmt 包，用于格式化输出
	"net"        // 导入 net 包，用于网络操作
	"sync"       // 导入 sync 包，用于同步操作
)

// 定义全局变量
var (
	// 保存所有连接的客户端，使用 map 结构
	clients    = make(map[net.Conn]bool)
	clientsMux sync.Mutex // 保护 clients 的并发访问，防止数据竞态
)

func main() {
	// 监听指定的端口（8080）
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		// 如果监听失败，打印错误信息并返回
		fmt.Println("Error starting server:", err)
		return
	}
	defer listener.Close() // 在 main 函数结束时关闭监听器

	fmt.Println("Chat server started on :8080") // 服务器启动成功提示

	for {
		// 接受新的连接
		conn, err := listener.Accept()
		if err != nil {
			// 如果接受连接失败，打印错误信息并继续下一次循环
			fmt.Println("Error accepting connection:", err)
			continue
		}

		// 将新客户端添加到客户端列表
		clientsMux.Lock() // 加锁以保护 clients 的并发访问
		clients[conn] = true // 将连接添加到 clients
		clientsMux.Unlock() // 解锁

		// 启动一个 goroutine 来处理该连接
		go handleConnection(conn)
	}
}

// 处理连接的函数
func handleConnection(conn net.Conn) {
	defer func() {
		// 关闭连接，并从 clients 中移除
		conn.Close() // 关闭连接
		clientsMux.Lock() // 加锁以保护 clients
		delete(clients, conn) // 从 clients 中移除该连接
		clientsMux.Unlock() // 解锁
	}()

	// 创建一个读取器
	reader := bufio.NewReader(conn)
	for {
		// 读取客户端发送的消息直到换行符
		message, err := reader.ReadString('\n')
		if err != nil {
			// 如果读取失败，打印错误信息并返回
			fmt.Println("Error reading from connection:", err)
			return
		}

		// 打印接收到的消息
		fmt.Printf("Received: %s", message)
		// 广播消息到所有其他客户端
		broadcastMessage(message, conn) // 调用广播函数
	}
}

// 广播消息给所有连接的客户端
func broadcastMessage(message string, sender net.Conn) {
	clientsMux.Lock() // 加锁以保护 clients 的并发访问
	defer clientsMux.Unlock() // 在函数结束时解锁

	// 遍历所有连接的客户端
	for client := range clients {
		// 不向发送消息的客户端发送消息
		if client != sender {
			_, _ = client.Write([]byte(message)) // 发送消息
		}
	}
}


这段代码实现了一个简单的聊天客户端，能够连接到服务器并发送消息，同时也会接收并显示服务器发来的消息。
通过 goroutines 来异步处理接收消息和发送消息，确保用户可以一边发送消息一边接收来自服务器的消息。
使用 bufio.Scanner 和 bufio.Reader 来处理输入和输出的读取。
package main

import (
	"bufio" // 导入 bufio 包，用于读取输入
	"fmt"   // 导入 fmt 包，用于格式化输出
	"net"   // 导入 net 包，用于网络操作
	"os"    // 导入 os 包，用于与操作系统交互
)

func main() {
	// 连接到聊天服务器，指定服务器地址（localhost:8080）
	conn, err := net.Dial("tcp", "localhost:8080")
	if err != nil {
		// 如果连接失败，打印错误信息并返回
		fmt.Println("Error connecting to server:", err)
		return
	}
	defer conn.Close() // 在 main 函数结束时关闭连接

	// 启动一个 goroutine 来读取服务器的消息
	go readMessages(conn)

	// 从标准输入读取消息并发送给服务器
	sendMessages(conn)
}

// 从连接中读取消息
func readMessages(conn net.Conn) {
	reader := bufio.NewReader(conn) // 创建一个读取器
	for {
		// 读取服务器发送的消息直到换行符
		message, err := reader.ReadString('\n')
		if err != nil {
			// 如果读取失败，打印错误信息并返回
			fmt.Println("Error reading from server:", err)
			return
		}
		// 打印接收到的消息
		fmt.Print("Received: ", message)
	}
}

// 发送消息到服务器
func sendMessages(conn net.Conn) {
	scanner := bufio.NewScanner(os.Stdin) // 创建一个扫描器来读取标准输入
	fmt.Println("消息发送中:")                 // 提示用户开始输入消息
	for scanner.Scan() {
		// 从输入中读取一行消息
		message := scanner.Text()
		// 发送消息到服务器，并在结尾加上换行符
		_, err := conn.Write([]byte(message + "\n"))
		if err != nil {
			// 如果发送失败，打印错误信息并返回
			fmt.Println("Error sending message:", err)
			return
		}
	}
}

解决粘包

在网络编程中，尤其是使用TCP进行通信时，常会遇到“粘包”与“拆包”现象。这是因为TCP是一个流式协议，

数据在传输过程中可能会被合并成一个大的数据包，或者一个大的数据包可能被分割成多个小的数据包，从而导致接收方无法正确解析消息。

粘包和拆包的产生原因

粘包：发送方可能连续发送多个消息，而TCP将这些消息合并为一个包，接收方收到的数据中包含多个消息。

拆包：发送方发送一个较大的消息，TCP将其分成多个小包发送，接收方在一次读取中只获取到部分消息。

解决方法

为了防止粘包和拆包现象，通常采用以下几种策略来处理：

  1. 使用固定长度的消息
    在这种方法中，每个消息都使用固定的字节长度来进行编码。这样接收方可以根据固定的长度来读取数据。

    优点：实现简单。
    缺点：不适用于消息长度不一致的情形，浪费带宽（如果消息较短）。

  2. 使用分隔符
    在每个消息的末尾加入一个特定的分隔符，比如换行符、特定字符等，接收方在读取数据时，可以根据分隔符进行解析。

    优点：可以处理可变长度的消息。
    缺点：需要确保分隔符不会出现在消息内容中。

  3. 消息头部长度
    在每个消息前添加一个固定大小的头部，头部包含消息的长度信息，接收方首先读取头部，获取消息长度，再按长度读取数据。

    优点：适用于任意长度的消息。
    缺点：稍显复杂，需处理头部。

示例

此代码实现了一个聊天服务器，能够接受多个客户端连接，

接收消息并将其广播给所有连接的客户端。

它通过使用二进制数据处理来确保消息的完整性和准确性，使用协程来并发处理每个连接，

确保服务器在处理多个客户端时的高效性。

通过使用 sync.Mutex 来避免对共享数据结构 clients 的竞争访问。

package main

import (
	"encoding/binary" // 导入 encoding/binary 包，用于在网络中进行字节序转换
	"fmt"            // 导入 fmt 包，用于格式化输出
	"net"            // 导入 net 包，用于网络操作
	"sync"           // 导入 sync 包，用于同步操作
)

// 定义全局变量
var (
	clients    = make(map[net.Conn]bool) // 用于保存所有连接的客户端
	clientsMux sync.Mutex                 // 保护 clients 的并发访问
)

func main() {
	// 监听指定的端口（8080）
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		// 如果启动失败，打印错误信息并返回
		fmt.Println("Error starting server:", err)
		return
	}
	defer listener.Close() // 在 main 函数结束时关闭监听器

	fmt.Println("Chat server started on :8080") // 服务器启动成功提示

	for {
		// 接受新的连接
		conn, err := listener.Accept()
		if err != nil {
			// 如果接受连接失败，打印错误信息并继续下一次循环
			fmt.Println("Error accepting connection:", err)
			continue
		}

		// 将新客户端添加到客户端列表
		clientsMux.Lock() // 加锁以保护 clients 的并发访问
		clients[conn] = true // 将连接添加到 clients
		clientsMux.Unlock() // 解锁

		// 启动一个 goroutine 来处理该连接
		go handleConnection(conn)
	}
}

// 处理连接的函数
func handleConnection(conn net.Conn) {
	defer func() {
		// 关闭连接，并从 clients 中移除
		conn.Close() // 关闭连接
		clientsMux.Lock() // 加锁以保护 clients
		delete(clients, conn) // 从 clients 中移除该连接
		clientsMux.Unlock() // 解锁
	}()

	for {
		// 读取消息长度（前4个字节）
		lengthBuffer := make([]byte, 4) // 创建一个4字节的缓冲区
		_, err := conn.Read(lengthBuffer) // 从连接中读取消息长度
		if err != nil {
			// 如果读取长度失败，打印错误信息并返回
			fmt.Println("Error reading length:", err)
			return
		}

		// 根据读取到的长度转换成整型
		msgLength := int(binary.BigEndian.Uint32(lengthBuffer))
		messageBuffer := make([]byte, msgLength) // 根据长度创建消息缓冲区
		// 读取消息
		/* 
		@param messageBuffer 接收消息的缓冲区 
		@param conn 客户端连接 
		@return 返回读取的字节数和错误信息
		*/
		_, err = conn.Read(messageBuffer) // 从连接中读取消息
		if err != nil {
			// 如果读取消息失败，打印错误信息并返回
			fmt.Println("Error reading message:", err)
			return
		}

		// 打印接收到的消息
		fmt.Printf("Received message: %s\n", string(messageBuffer))
		// 将接收到的消息广播给所有其他客户端
		broadcastMessage(messageBuffer, conn)
	}
}

// 广播消息给所有连接的客户端
func broadcastMessage(message []byte, sender net.Conn) {
	clientsMux.Lock() // 加锁以保护 clients 的并发访问
	defer clientsMux.Unlock() // 在函数结束时解锁

	// 获取消息长度
	msgLength := uint32(len(message))
	lengthBuffer := make([]byte, 4) // 创建一个4字节的缓冲区
	binary.BigEndian.PutUint32(lengthBuffer, msgLength) // 将消息长度转换为大端字节序

	// 遍历所有连接的客户端
	for client := range clients {
		// 不向发送者发送消息
		if client != sender {
			// 首先发送消息长度
			_, _ = client.Write(lengthBuffer) // 发送长度
			_, _ = client.Write(message) // 然后发送消息
		}
	}
}

此代码实现了一个简单的聊天客户端，能够连接到服务器、发送消息并接收服务器的消息。
通过二进制传输消息长度，确保了消息的完整性。


package main

import (
	"bufio"      // 导入 bufio 包，用于读取输入
	"encoding/binary" // 导入 encoding/binary 包，用于字节序转换
	"fmt"        // 导入 fmt 包，用于格式化输出
	"net"        // 导入 net 包，用于网络操作
	"os"         // 导入 os 包，用于与操作系统交互
)

func main() {
	// 连接到聊天服务器，指定服务器地址（localhost:8080）
	conn, err := net.Dial("tcp", "localhost:8080")
	if err != nil {
		// 如果连接失败，打印错误信息并返回
		fmt.Println("Error connecting to server:", err)
		return
	}
	defer conn.Close() // 在 main 函数结束时关闭连接

	// 启动一个 goroutine 来读取服务器的消息
	go readMessages(conn)

	// 从标准输入读取消息并发送给服务器
	sendMessages(conn)
}

// 从连接中读取消息的函数
func readMessages(conn net.Conn) {
	for {
		// 创建一个4字节的缓冲区用于读取消息长度
		lengthBuffer := make([]byte, 4)
		_, err := conn.Read(lengthBuffer) // 从连接中读取消息长度
		if err != nil {
			// 如果读取长度失败，打印错误信息并返回
			fmt.Println("Error reading length:", err)
			return
		}

		// 将读取到的长度转换为整型
		msgLength := int(binary.BigEndian.Uint32(lengthBuffer))
		messageBuffer := make([]byte, msgLength) // 根据长度创建消息缓冲区
		_, err = conn.Read(messageBuffer) // 从连接中读取消息
		if err != nil {
			// 如果读取消息失败，打印错误信息并返回
			fmt.Println("Error reading message:", err)
			return
		}

		// 打印接收到的消息
		fmt.Printf("Received message: %s\n", string(messageBuffer))
	}
}

// 发送消息到服务器的函数
func sendMessages(conn net.Conn) {
	scanner := bufio.NewScanner(os.Stdin) // 创建一个扫描器来读取标准输入
	fmt.Println("Type your messages below (end with Enter):") // 提示用户开始输入消息
	for scanner.Scan() {
		// 从输入中读取一行消息
		message := scanner.Text()

		// 获取消息长度
		msgLength := uint32(len(message))
		lengthBuffer := make([]byte, 4) // 创建一个4字节的缓冲区
		binary.BigEndian.PutUint32(lengthBuffer, msgLength) // 将消息长度转换为大端字节序

		// 先发送消息长度
		_, err := conn.Write(lengthBuffer) // 发送长度
		if err != nil {
			// 如果发送失败，打印错误信息并返回
			fmt.Println("Error sending length:", err)
			return
		}

		// 再发送消息
		_, err = conn.Write([]byte(message)) // 发送消息
		if err != nil {
			// 如果发送失败，打印错误信息并返回
			fmt.Println("Error sending message:", err)
			return
		}
	}
}

http://www.kler.cn/a/321527.html

相关文章：

  • 【快捷入门笔记】mysql基本操作大全-SQL表
  • 深入探索 React Hooks：原理、用法与性能优化全解
  • 【代码审计】常见漏洞专项审计-业务逻辑漏洞审计
  • PHP反序列化_3-漏洞利用
  • C# WPF FontDialog字体对话框，ColorDialog颜色对话框 引用
  • 从swagger直接转 vue的api
  • 【Linux 从基础到进阶】Kafka消息队列配置与管理
  • C/C++中的内存管理
  • c语言200例 063 信息查询
  • 数据结构 ——— 移除元素（快慢指针）
  • io流（学习笔记03）字符集
  • 大数据时代的PDF解析：技术与挑战
  • Python：百度贴吧实现自动化签到
  • Spring是什么
  • 有源蜂鸣器（5V STM32）
  • 无人机之虚拟云台技术篇
  • LeetCode 137. 只出现一次的数字 II
  • Linux安装vim超详细教程
  • MySQL重点，面试题
  • 深入Android UI开发：从自定义View到高级布局技巧的全面学习资料
  • RestSharp简介
  • 通信工程学习：什么是SDN软件定义网络
  • 电脑如何设置代理IP：详细步骤指南
  • STM32 入门教程（江科大教材）#笔记4
  • 01.前端面试题之ts：说说如何在Vue项目中应用TypeScript？
  • 趣笔阁爬虫实验