Golang-网络编程

最新推荐文章于 2024-07-25 23:17:13 发布
最新推荐文章于 2024-07-25 23:17:13 发布
阅读量532 收藏 3
点赞数 1
分类专栏： Golang 文章标签： golang 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NINE_world/article/details/124808820
版权

TCP

服务端

package main

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

// TCP server端

func process(conn net.Conn) {
	defer conn.Close() // 关闭连接
	for {
		reader := bufio.NewReader(conn)
		var buf [128]byte
		// 使用切片接收
		n, err := reader.Read(buf[:]) // 读数据
		if err != nil {
			fmt.Println("read from client failed,err:", err)
			break
		}
		// 读切片
		recvStr := string(buf[:n])
		fmt.Println("收到client端发来的数据:", recvStr)
		conn.Write([]byte(recvStr)) // 回射数据
	}
}

func main() {
	listen, err := net.Listen("tcp", "127.0.0.1:1226")
	if err != nil {
		fmt.Println("listen failed, err:", err)
		return
	}
	for {
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println("accept failed, err:", err)
			continue
		}
		// 启动一个goroutine处理连接
		go process(conn)
	}
}

客户端：

package main

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

// TCP client端

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:1226")
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	defer conn.Close()
	// 获取标准输入的对象
	inputReader := bufio.NewReader(os.Stdin)
	for {
		// 读取字符，知道遇到换行，并包含换行
		input, _ := inputReader.ReadString('\n')
		// 去掉换行回车
		inputInfo := strings.Trim(input, "\r\n")
		if strings.ToUpper(inputInfo) == "Q" {
			return
		}
		// 把字符串转换成字节流切片[]byte
		// 因为TCP是基于字节流的传输
		_, err = conn.Write([]byte(inputInfo)) // 发送数据
		if err != nil {
			return
		}
		// var buf [512]byte 等价
		buf := [512]byte{}
		n, err := conn.Read(buf[:])
		if err != nil {
			fmt.Println("recv failed,err:", err)
			return
		}
		fmt.Println(string(buf[:n]))
	}
}

UDP

服务端

// UDP server端
package main

import (
	"fmt"
	"net"
)

func main() {
	// 绑定IP地址
	listen, err := net.ListenUDP("udp", &net.UDPAddr{
		IP:   net.IPv4(0, 0, 0, 0),
		Port: 1227,
	})
	if err != nil {
		fmt.Println("listen failed, err:", err)
		return
	}
	defer listen.Close()
	for {
		var data [1024]byte
		// 接收数据，用字节数组接收，转换成string输出
		n, addr, err := listen.ReadFromUDP(data[:])
		if err != nil {
			fmt.Println("read udp failed, err:", err)
			continue
		}
		fmt.Printf("data:%v  addr:%v  count:%v\n", string(data[:n]), addr, n)
		// 用字节数组发送
		_, err = listen.WriteToUDP(data[:n], addr)
		if err != nil {
			fmt.Println("write to udp failed, err:", err)
			continue
		}
	}
}

客户端

// 客户端
package main

import (
	"fmt"
	"net"
)

func main() {
	// 连接
	socket, err := net.DialUDP("udp", nil, &net.UDPAddr{
		IP:   net.IPv4(0, 0, 0, 0),
		Port: 1227,
	})
	if err != nil {
		fmt.Println("连接服务器失败,err:", err)
		return
	}
	defer socket.Close()
	// 初始化一个切片
	sendData := []byte("Hello server")
	// 发送切片
	_, err = socket.Write(sendData)
	if err != nil {
		fmt.Println("发送数据失败,err:", err)
		return
	}
	// 构建一个最大容量为4096的切片
	data := make([]byte, 4096)
	// 将数据接收在切片里
	n, remoteAddr, err := socket.ReadFromUDP(data)
	if err != nil {
		fmt.Println("接收数据失败,err:", err)
		return
	}
	fmt.Printf("recv:%v  addr:%v  count:%v\n", string(data[:n]), remoteAddr, n)
}

TCP 粘包

粘包的代码：
服务端

// 服务端
package main

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

func process(conn net.Conn) {
	defer conn.Close()
	// buf在循环外面，共用一个buf
	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:1226")
	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)
		fmt.Println("for")
	}
}

客户端：

// 客户端
package main

import (
	"fmt"
	"net"
)

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


1.由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP并不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，若有则会一次把这两段数据发送出去。
2.接收端接收不及时造成的接收端粘包：TCP会把接收到的数据存在自己的缓冲区中，然后通知应用层取数据。当应用层由于某些原因不能及时的把TCP的数据取出来，就会造成TCP缓冲区中存放了几段数据。

协议：

package proto

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

// Encode 将消息编码
func Encode(message string) ([]byte, error) {
	// 读取消息的长度，转换成int32类型
	var length = int32(len(message))
	// 新建一个字节流buf
	var pkg = new(bytes.Buffer)
	// 写入消息头,小端编码
	err := binary.Write(pkg, binary.LittleEndian, length)
	if err != nil {
		return nil, err
	}

	// 写入消息体，要把string转换成字节切片
	err = binary.Write(pkg, binary.LittleEndian, []byte(message))
	if err != nil {
		return nil, err
	}
	// 返回字节切片和err
	return pkg.Bytes(), nil
}

// Decode 解码消息
func Decode(reader *bufio.Reader) (string, error) {
	// 读取消息的长度,但是不从流中取出来
	lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
	// 创建一个新的缓冲区，内容是lengthByte
	lengthBuff := bytes.NewBuffer(lengthByte)
	var length int32
	// 把byte切片转换为int32这么费劲？
	// binary二进制操作类似内存拷贝，把缓冲区的内容拷贝的length的地址空间去
	err := binary.Read(lengthBuff, binary.LittleEndian, &length)
	if err != nil {
		return "", err
	}

	// Buffered返回缓冲中现有的可读取的字节数 总字节数=length+4
	if int32(reader.Buffered()) < length+4 {
		return "", err
	}

	// 读取真正的数据
	pack := make([]byte, int(4+length))
	_, err = reader.Read(pack)
	if err != nil {
		return "", err
	}

	// 最后返回将字节切片转换成字符串
	// 从第四个字节开始取，说明peek确实没有把前四个字节拿走
	return string(pack[4:]), nil
}

服务端：

package main

import (
	"bufio"
	"fmt"
	"go-test/11-tcp/proto"
	"io"
	"net"
)

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		msg, err := proto.Decode(reader)
		if err == io.EOF {
			return
		}
		if err != nil {
			fmt.Println("decode msg failed,err:", err)
			return
		}
		fmt.Println("收到client发来的数据:", msg)
	}
}

func main() {
	listen, err := net.Listen("tcp", "127.0.0.1:3000")
	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"
	"go-test/11-tcp/proto"
	"net"
)

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

HTTP

客户端：

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	// resp, _ := http.Get("http://www.baidu.com")
	// fmt.Println(resp)
	resp, _ := http.Get("http://127.0.0.1:8000/go")
	defer resp.Body.Close()
	// 200 OK
	fmt.Println(resp.Status)
	fmt.Println(resp.Header)

	buf := make([]byte, 1024)
	for {
		// 接收服务端信息
		n, err := resp.Body.Read(buf)
		if err != nil && err != io.EOF {
			fmt.Println(err)
			return
		} else {
			fmt.Println("读取完毕")
			res := string(buf[:n])
			fmt.Println(res)
			break
		}
	}
}

服务端：

package main

import (
	"fmt"
	"net/http"
)

func main() {
	// http://127.0.0.1:8000/go
	// 单独写回调函数,有连接过来就调用这个函数？
	http.HandleFunc("/go", myHandler)
	// addr:监听的地址
	// handler：回调函数
	http.ListenAndServe("127.0.0.1:8000", nil)
}

func myHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Println(r.RemoteAddr, "连接成功")
	fmt.Println("method:", r.Method)
	fmt.Println("url:", r.URL.Path)
	fmt.Println("header:", r.Header)
	fmt.Println("body:", r.Body)

	// 回复
	w.Write([]byte("www.51mh.com"))
}
橙子砰砰枪
关注
专栏目录
golang-网络编程
weixin_43867700的博客
11-01 235
网络包发送解析基本过程： osi七层在编程中可以简化为四层分别为： 应用层 传输层 ip网络层 链路层 小知识： netstat -anb 查看本机监听端口 实例： 标准输入代表键盘输入： server.go // net包提供了可移植的网络I/O接口， // 包括TCP/IP、UDP、域名解析和Unix域socket package main i...
桫哥-GOlang-10网络编程
06-12
基础部分带你从零到一，打牢语法基础； 进阶部分包含实战案例和框架封装； 绝不浅尝辄止！ 风格依旧水煮，依旧不拘一格脑洞大开；
Golang的网络编程
qq_53267860的博客
02-08 2430
Golang 网络编程 以及 客户端对服务端进行对话
golang网络编程- WebSocket编程
最新发布
北桥源木
07-25 320
运行之后执行local.html文件。在同一级目录下新建四个go文件。
golang 网络编程
云满笔记
06-29 225
golang 网络编程
golang中的网络编程
任性的白菜
02-28 711
1、网络编程 1.1、网络编程基本介绍 1.2、OSI与Tcp/Ip参考模型 1.3、Ip地址 1.4、端口（port）介绍 1.4.1、端口分类 1.4.2、端口（port）使用注意 1.5、tcp socket编程的客户端和服务器端 2、tcp socket编程快速入门 2.1、服务端的处理流程 2.2、客户端的处理流程 2.3、简单的程序示意图 2.4、代码实现 pa...
golang--网络编程
zerozhuxiaozhu的博客
06-21 571
beego安装环境： 环境变量： export PATH=$PATH:/usr/local/go/bin export GOPATH=$HOME/workspace export PATH=$PATH:$GOPATH/bin source /etc/profile #是环境变量生效 go get github.com/astaxie/beego #beego安装 go get gi...
golang-win32:Golang包装器函数可调用Windows API
05-28
在编程领域，Go语言（Golang）以其简洁的语法、高效的性能和强大的并发特性而备受开发者喜爱。然而，尽管Go自带了丰富的标准库，但在某些特定场景下，可能需要调用操作系统底层的API来实现更复杂的功能。对于Windows...
桫哥-GOlang-13并发编程
06-12
"桫哥-GOlang-13并发编程"的主题深入探讨了Go语言的并发编程这一关键特性，这对于理解和编写高效、可扩展的Go程序至关重要。 并发编程是现代软件开发中的一个核心概念，它允许程序同时执行多个任务，从而提高系统...
golang-playground:玩转Golang并发现编程语言功能
04-01
6. **标准库实践**：Go的标准库非常强大，包含大量实用的包，如net/http用于网络编程，io/ioutil用于读写文件，encoding/json用于JSON序列化和反序列化。在游乐场，你可以直接导入并使用这些库，实践各种功能。 7. ...
golang-grows-with-grace:Golang - 优雅增长的代码 - 谈话 2012 Andrew Gerrand
07-04
在2012年的这场谈话中，Andrew Gerrand可能还讨论了Go语言的其他方面，如其标准库的强大功能，包括网络编程、文本处理、JSON编码等。Go的标准库是其强大之处，提供了一系列高质量的模块，帮助开发者快速构建应用。 ...
Golang网络编程
阿澈不吃蒜的博客
08-30 455
Socket（套接字）是一种用于实现网络通信的编程接口；它允许不同的计算机通过网络互相传递数据；Socket提供了一种标准的编程接口，使得开发者可以使用通用的网络协议（如TCP/IP）进行网络通信。下面举生活中的例子：Socket是应用层与传输层之间的接口，它基于计算机网络原理，将网络传输分为两个角色：服务器（Server）和客户端（Client）CS架构- 服务器端（Server）：服务器端监听特定的网络端口，等待客户端的连接请求。
Golang 网络编程
冷月醉雪的博客
02-23 552
TCP服务器 package main import ( "fmt" "log" "net" ) func main() { // net 包提供方便的工具用于 network I/O 开发，包括TCP/IP, UDP 协议等。 // Listen 函数会监听来自 8080 端口的连接，返回一个 net.Listener 对象。 li, er...
深入理解 Golang: 网络编程
不定期更新 Web 开发及机器学习相关博客
07-02 1071
在 Go 中，内部采用结合阻塞模型和多路复用的方法。在这里就不再是线程操作 Socket，而是 Goroutine 协程。每个协程关心一个 Socket 连接：1.在底层使用操作系统的多路复用 IO；2.在协程层次使用阻塞模型。3.阻塞协程时，休眠协程。
Golang-互联网协议&TCP协议
木子阳的工作记录站
05-18 424
OSI七层模型 互联网的逻辑实现被分为好几层。每一层都有自己的功能，就像建筑物一样，每一层都靠下一层支持。用户接触到的只是最上面的那一层，根本不会感觉到下面的几层。要理解互联网就需要自下而上理解每一层的实现的功能。 四层 五层 ...
golang学习十:网络编程
浅弋、璃鱼的博客
05-23 2262
文章目录一、网络协议:1. 典型协议:2.分层模型:2.1 网络分层架构:2.2 层与协议:2.3 通信过程2.4 总结通信过程：二、Socket编程:1.什么是Socket:2. 网络应用程序设计模式:2.1 模式:2.2 TCP的C/S架构:2.3 简单的C/S模型通信:a.Server端:b.Client 端:2.4 并发的C/S模型通信:a.并发server:b.并发Client3. TCP通信3.1 三次握手:3.2 四次挥手:4. UDP:4.1 UDP服务器4.2 UDP客户端:4.3 UDP
Golang实现简单的Socket网络编程（代码+详细注释）
u014285914的博客
06-15 2601
Golang实现简单的Socket网络编程（代码+详细注释）
Golang 初识网络编程
chunqizhi
05-28 307
本文通过 Go 语言写几个简单的通信示例，从 TCP 服务器过渡到 HTTP 开发，从而简单介绍 net 包的运用。TCP 服务器首先来看一个 TCP 服务器例子package main import ( "fmt" "log" "net" ) func main() { // net 包提供方便的工具用于 network I/O 开发，包括TCP/IP, UD...
golang的网络编程
08-24
下面是一个简单的Golang网络编程的示例： ```go package main import ( "fmt" "net" ) func main() { // 监听一个端口 listener, err := net.Listen("tcp", "localhost:8080") if err != nil { fmt....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橙子砰砰枪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值