自学内容网 自学内容网
自学内容网 > 正文

go语言网络编程

🕗 发布于 2024-09-23 03:42 golang  网络  开发语言  

网络编程

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
}
}
}

原文地址：https://blog.csdn.net/gopher9511/article/details/142441619

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

  • aws云服务器：高可靠性和数据安全

    云服务器是通过虚拟化技术从物理服务器中分割出的一种虚拟化计算资源。它具备传统服务器的核心功能，但同时具备更高的弹性和灵活性。用户可以通过网络远程管理云服务器，根据需求增加或减少计算资源，并仅为实际使用

    阅读更多2024-11-17
  • i春秋-Hash

    2.通过get接收var参数，base64后进行一个正则匹配——"/[oc]:\d+:/i"是一个忽略大小写的正则表达式，用于匹配以 “o” 或 “c” 开头，接着是冒号、一个或多

    阅读更多2024-11-17
  • [Linux]多线程详解

    直接：

    阅读更多2024-11-17
  • C#自定义特性-SQL

    【代码】SQL特性。

    阅读更多2024-11-17
  • Oracle单实例静默安装

    在企业环境中，自动化和标准化是提高效率的关键。静默安装（也称为无人值守安装）是一种无需人工干预的安装方法，适用于大规模部署或需要重复安装的场景。本文将介绍如何在CentOS上静默安装Oracle数据库

    阅读更多2024-11-17
  • 【ChatGPT】提高 ChatGPT 创意输出的提示词技巧

    掌握这些技巧后，您可以在各类创意项目中更好地利用 ChatGPT，快速生成丰富、多样的创意内容。本文将介绍一些实用的技巧，帮助您通过优化提示词来提升 ChatGPT 的创意输出。给出模糊的、宽泛的指示

    阅读更多2024-11-17
  • vuetify重置样式

    vuetify中按钮的英文文字默认是大写形式的，怎么把按钮文字这种大写形式的属性给去掉呢，我们可以用scss重置这个css样式。vuetify重置scss变量。

    阅读更多2024-11-17
  • 提示词高级阶段学习day3.1什么是结构化 Prompt ？

    结构化的思想很普遍，结构化内容也很普遍，我们日常写作的文章，看到的书籍都在使用标题、子标题、段落、句子等语法结构。

    阅读更多2024-11-17
  • ChatGPT实现旅游推荐微信小程序

    开发一个AI旅游推荐小程序，基于用户输入的旅行偏好，提供个性化的旅游推荐和详细信息展示。

    阅读更多2024-11-17
  • 【ChatGPT】编写结构化 Prompt 的技巧

    结构化 Prompt是一种经过精心设计的提示方式，它以清晰的结构传递用户需求，帮助 ChatGPT 更准确地理解任务，并生成所需的结果。任务描述：明确告知 ChatGPT 所需完成的任务。背景信息：为

    阅读更多2024-11-17
自学内容网
Copyright © 2015-2024