Go语言的Json序列化与反序列化、Goto语法、Tcp Socket通信

最新推荐文章于 2023-11-11 19:21:21 发布
最新推荐文章于 2023-11-11 19:21:21 发布
阅读量566 收藏
点赞数
分类专栏： Go 文章标签： golang json tcp/ip 后端 go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MeiJin_/article/details/134284631
版权

目录标题

一、Json序列化与反序列化

1. 序列化

		package main
		
		import (
			"encoding/json"
			"fmt"
		)
		
		type Person struct {
			Name  string `json:"name"`
			Age   int    `json:"age"`
			Email string `json:"email"`
		}
		
		func main() {
		     person := Person{
		         Name:  "LoisMay",
		         Age:   21,
		         Email: "1711031006@qq.com",
		     }
		
			// 序列化为 JSON 字节数组
			jsonData, err := json.Marshal(person)
			if err != nil {
				fmt.Println("JSON 序列化错误:", err)
				return
			}
		
			// 打印 JSON 字符串
			fmt.Println(string(jsonData))
			
			// {"name":"LoisMay","age":21,"email":"1711031006@qq.com"}
		}

2. 反序列化

		func main() {
			Data := []byte(`{"name":"LoisMay","age":21,"email":"1711031006@qq.com"}`)
		
			// 反序列化为 Person 结构体
			var person Person
			err := json.Unmarshal(Data, &person)
			if err != nil {
				fmt.Println("JSON 反序列化错误:", err)
				return
			}
		
			// 打印反序列化后的对象
			fmt.Println(person.Name)
			fmt.Println(person.Age)
			fmt.Println(person.Email)
		}

二、Goto语法

        goto 语句可以用来实现程序的无条件跳转
        但在实际开发中，应该谨慎使用它，因为滥用 goto 可能会导致代码结构混乱和可读性降低。

        package main

        import "fmt"

        func main() {
            var n = 30
            fmt.Println("LoisMay")

            if n > 20 {
                goto func1
            }
            fmt.Println("LoisMays")
            fmt.Println("LoisMayss")
            fmt.Println("LoisMaysss")

        func1:
            fmt.Println("666")
            fmt.Println("777")
            fmt.Println("888")
        }

		//	LoisMay
		//	666
		//	777
		//	888

三、Tcp Socket

1. 单客户端发送信息到服务端

Server.go

		package main
		
		import (
			"bufio"
			"fmt"
			"net"
			"strings"
		)
		
		func process(conn net.Conn) {
			defer conn.Close()
		
			reader := bufio.NewReader(conn)
		
			for {
				fmt.Printf("Server is waiting for client message from %s:\n", conn.RemoteAddr().String())
		
				massage, err := reader.ReadString('\n')
				if err != nil {
					fmt.Printf("Client exited with error: %v\n", err)
					return
				}
				massage = strings.Trim(massage, "\r\n")
				fmt.Printf("Received message from client: %s\n", massage)
		
				// 服务端回复消息
				response := "Server received: " + massage + "\n"
				_, err = conn.Write([]byte(response))
				if err != nil {
					fmt.Printf("Error sending response to client: %v\n", err)
					return
				}
			}
		}
		
		func main() {
			fmt.Println("Server is Listen")
			listen, err := net.Listen("tcp", "0.0.0.0:8888")
			if err != nil {
				fmt.Println("Listen err=", err)
				return
			}
			defer listen.Close()
		
			for {
				fmt.Println("Waiting for client connection")
				conn, err := listen.Accept()
				if err != nil {
					fmt.Println("Accept err=", err)
				} else {
					fmt.Printf("Accepted connection from client: %v\n", conn.RemoteAddr().String())
				}
				go process(conn)
			}
		}

Client.go

		package main
		
		import (
			"bufio"
			"fmt"
			"net"
			"os"
			"strings"
		)
		
		func main() {
			conn, err := net.Dial("tcp", "0.0.0.0:8888")
			if err != nil {
				fmt.Println("Client dial error:", err)
				return
			}
			defer conn.Close()
		
			reader := bufio.NewReader(os.Stdin)
			for {
				fmt.Print("Enter message: ")
				message, err := reader.ReadString('\n')
				if err != nil {
					fmt.Println("ReadString error:", err)
					break
				}
		
				message = strings.Trim(message, "\r\n")
				if message == "exit" {
					fmt.Println("Client is exiting")
					break
				}
		
				_, err = conn.Write([]byte(message + "\n"))
				if err != nil {
					fmt.Println("Connection write error:", err)
					break
				}
		
				response, err := bufio.NewReader(conn).ReadString('\n')
				if err != nil {
					fmt.Println("Read response error:", err)
					break
				}
		
				fmt.Println("Server response:", response)
			}
		}

2. 服务端客户端通信

server.go

		package main
		
		import (
			"bufio"
			"fmt"
			"net"
			"os"
			"strings"
		)
		
		func handleClient(conn net.Conn) {
			defer conn.Close()
		
			reader := bufio.NewReader(conn)
			writer := bufio.NewWriter(conn)
		
			for {
				// 读取客户端消息
				message, err := reader.ReadString('\n')
				if err != nil {
					fmt.Printf("Error reading client message: %v\n", err)
					return
				}
		
				message = strings.Trim(message, "\r\n")
				fmt.Printf("Received message from client: %s\n", message)
		
				// 回复客户端消息
				response := "Server received: " + message + "\n"
				_, err = writer.WriteString(response)
				if err != nil {
					fmt.Printf("Error sending response to client: %v\n", err)
					return
				}
				writer.Flush()
		
				// 检查客户端是否要退出
				if message == "exit" {
					fmt.Println("Client is exiting")
					return
				}
			}
		}
		
		func main() {
			fmt.Println("Server is listening")
			listener, err := net.Listen("tcp", "0.0.0.0:8888")
			if err != nil {
				fmt.Println("Listen error:", err)
				return
			}
			defer listener.Close()
		
			for {
				fmt.Println("Waiting for client connection")
				conn, err := listener.Accept()
				if err != nil {
					fmt.Println("Accept error:", err)
					break
				}
				fmt.Println("Client connected:", conn.RemoteAddr().String())
		
				go handleClient(conn)
		
				// 启动一个 goroutine 处理服务端发送消息
				go func(c net.Conn) {
					reader := bufio.NewReader(os.Stdin)
					writer := bufio.NewWriter(c)
		
					for {
						// 从控制台读取输入
						fmt.Print("Enter message: ")
						input, _ := reader.ReadString('\n')
						input = strings.Trim(input, "\r\n")
		
						// 发送消息给客户端
						_, err := writer.WriteString(input + "\n")
						if err != nil {
							fmt.Printf("Error sending message to client: %v\n", err)
							return
						}
						writer.Flush()
		
						// 检查服务端是否要退出
						if input == "exit" {
							fmt.Println("Server is exiting")
							return
						}
					}
				}(conn)
			}
		
			// 阻塞主线程，使服务端持续运行
			<-make(chan struct{})
		}

Client.go

		package main
		
		import (
			"bufio"
			"fmt"
			"net"
			"os"
			"strings"
		)
		
		func handleServer(conn net.Conn) {
			defer conn.Close()
		
			reader := bufio.NewReader(conn)
			writer := bufio.NewWriter(conn)
		
			for {
				// 读取服务端消息
				message, err := reader.ReadString('\n')
				if err != nil {
					fmt.Printf("Error reading server message: %v\n", err)
					return
				}
		
				message = strings.Trim(message, "\r\n")
				fmt.Printf("Received message from server: %s\n", message)
		
				// 检查服务端是否要退出
				if message == "exit" {
					fmt.Println("Server is exiting")
					return
				}
		
				// 从控制台读取输入
				fmt.Print("Enter message: ")
				input, _ := reader.ReadString('\n')
				input = strings.Trim(input, "\r\n")
		
				// 发送消息给服务端
				_, err = writer.WriteString(input + "\n")
				if err != nil {
					fmt.Printf("Error sending message to server: %v\n", err)
					return
				}
				writer.Flush()
		
				// 检查客户端是否要退出
				if input == "exit" {
					fmt.Println("Client is exiting")
					return
				}
			}
		}
		
		func main() {
			conn, err := net.Dial("tcp", "127.0.0.1:8888")
			if err != nil {
				fmt.Println("Client dial error:", err)
				return
			}
			fmt.Println("Connected to server")
		
			go handleServer(conn)
		
			// 从控制台读取输入
			reader := bufio.NewReader(os.Stdin)
			for {
				fmt.Print("Enter message: ")
				input, _ := reader.ReadString('\n')
				input = strings.Trim(input, "\r\n")
		
				// 发送消息给服务端
				_, err = conn.Write([]byte(input + "\n"))
				if err != nil {
					fmt.Printf("Error sending message to server: %v\n", err)
					return
				}
		
				// 检查客户端是否要退出
				if input == "exit" {
					fmt.Println("Client is exiting")
					break
				}
			}
		
			conn.Close()
		}

在这里插入图片描述

LoisMay
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Go语言流程控制之goto语句与无限循环
09-21
主要介绍了Go语言流程控制之goto语句与无限循环,是golang入门学习中的基础知识,需要的朋友可以参考下
go 客户端和服务端使用Json 使用结构体交互（内涵JSON彩蛋）
qq_40500045的博客
05-14 1167
方法
go 的结构体极速序列化
robinfoxnan的专栏
11-07 1150
golang的结构体极速序列化方式，
Golang学习(二十九）序列化和反序列化
默子昂
03-07 3945
我们不同编程语言之间的数据是无法直接交互的，我们想要解决这个问题 就需要将不同语言之间传输的数据做一个统一规范，而json是目前最流行的数据格式 一、json格式 1、json是什么 json 是一种数据交换格式，主要是将要传输的数据转换为json特有的格式 其他人拿到这个json数据后，可以通过数据反向转换得到转换前的数据 这样大家都将数据转为json格式，谁用就拿过来转换为自己识别的数据即可 2、json数据格式说明 JSON 依赖key-value 键值对形式来保存数据，.
【zinx】Golang轻量级TCP服务器框架（四）—— 基础的json全局配置文件
一年之内毫无半点成绩，想起来做人真是没趣。
09-29 379
Golang轻量级TCP服务器框架（二）—— 基础的json全局配置文件1.思路2.代码演示 原作者视频地址：zinx-Golang轻量级TCP服务器框架 本人为自学整理的文档，梳理思考开发框架的基本思路，方法，以及视频中不理解的地方。 若想学习，强烈建议直接观看原作视频即可。 可在下方留言交流。 1.思路 这一节很简单，就是讲解如何使用.json文件给server框架做全局的配置。 2.代码演示 ...
go的json反序列化的几种形式
Q_W_W_Q的博客
03-16 399
注释都有，注意每个细节！
golang json 序列化、反序列化 字符串反序列化
最新发布
牛肉胡辣汤
11-11 620
在使用Golang进行开发时，经常会遇到需要将一段JSON字符串进行序列化和反序列化的情况。我们可以使用JSON来保存用户的注册信息，并在需要时将其序列化和反序列化。需要注意的是，为了将JSON字符串正确解析为结构体，我们需要将JSON字符串转换为字节数组([]byte)，并将结构体变量的指针传给​。在结构体字段的标签中可以定义序列化和反序列化时的名称，以便更好地控制JSON的格式。以上就是对Golang中JSON序列化、反序列化以及字符串反序列化的详细介绍。​包来处理JSON的序列化和反序列化。
go 学习笔记 之-序列化与反序列化 文件操作（解释为什么要进行序列化）
weixin_39802680的博客
07-14 2125
小技巧 小技巧: 为了方便操作我们可以将file相关结构封装成结构体或全局变量 type DBFile struct { File *os.File Offset int64 } var ( newFile *os.File err error ) 创建空文件 package main import ( "log" "os" ) var ( newFile *os.File err error ) func main() {
十一、结构体和 Json 相互转换（序列化反序列化）
阿澈不吃蒜的博客
08-03 1653
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。RESTfull Api 接口中返回的数据都是 json 数据。稍微复杂点的JSON注意一个点：结构体内的私有属性不能被json包访问，如果结构体内部的属性都要就行转换，需要全部为公有属性（开头字符大写）比如我们 Golang 要给 App 或者小程序提供 Api 接口数据，这个时候就需要涉及到结构体和Json 之间的相互转换。是指把结构体数据转化成。
Go语言中的序列化：原理、实现和应用
禅与计算机程序设计艺术
07-22 1801
作者：禅与计算机程序设计艺术 随着互联网web服务的发展，数据层面的需求也越来越复杂，这就要求开发者对数据的存储和交换进行更好的处理。数据存储方案无疑成为影响系统性能和可靠性的一大关键因素。在分布式系统中，数据需要在不同节点间进行传输，因此数据传输方案不可避免地涉及到序列化和反序列化过程。 序列化即将对象转化为字节流或者字符
go 序列化与反序列化
go|Python的个人博客
08-01 1192
如果一个JSON值不匹配给出的目标类型，或者如果一个json数字写入目标类型时溢出，Unmarshal函数会跳过该字段并尽量完成其余的解码操作。JSON的null值解码为go的接口、指针、切片时会将它们设为nil，因为null在json里一般表示“不存在”。要将json数据解码写入一个结构体，函数会匹配输入对象的键和Marshal使用的键（结构体字段名或者它的标签指定的键名），优先选择精确的匹配，但也接受大小写不敏感的匹配。接口类型的值编码为接口内保持的具体类型的值（的json编码）。......
go语言goto语句跳转到指定的标签实现方法
12-20
Go 语言中使用 goto 语句能简化一些代码的实现过程。 使用 goto 集中处理错误 package main import "fmt" func main() { for x := 0; x < 10; x++ { for y := 0; y < 10; y++ { if y == 2 { // 跳转到...
Go语言关键词和预声明常量、类别、函数
01-20
Go语言有25个关键词。它们只能在语法允许的场合使用，不能被用户自定义的变量或者函数名覆盖。它们如下所示。 break default func interface select case defer go map struct chan else goto package switch...
最新款goto解密工具源码，PHP加密解密反编译工具
08-12
最新款goto解密工具源码，PHP加密解密反编译工具
十三. Go学习：Json协议
ouyangyiwen的博客
12-24 170
Json用途 Json数据协议 1. 导入包：import "encoding/json" 2. 序列化：json.Marshal(data interface{}) 3. 反序列化：json.UnMarshal(data []byte,v intface{}) 代码范例 package main import ( "encoding/json" "fmt" ) type User struct { UserName string NickName string Age
Go语言网络编程入门：TCP、HTTP、JSON序列化、Gin、WebSocket、RPC、gRPC示例
Pistachiout的学习博客
05-19 2613
在本文中，我们将介绍Go语言中的网络编程的不同方式，包括TCP、HTTP、Gin框架、WebSocket、RPC、gRPC的介绍与连接实例，并对所有示例代码都给出了详细的注释，最后对每种模式进行了总结。
go原生rpc包的使用：传递数据的载体：golang封装的http协议/tcp/jsonrpc
小豆角的博客
06-10 2259
rpc是一种通信协议，也就是计算机之间的沟通方式，类比http，mysql等，计算机之间通信是网络连接，tcp/ip协议里一个网络连接包含五元组信息-协议-端口-ip，rpc通过在一个网络连接上设置stub，监控这个连接的rpc请求，一般情况rpc的server端绑定的stub的载体有：1.http协议上，监听所有的http连接（指定server端ip,协议，端口），所有通过http协议过来的连接...
【Go】Go数据操作 - 处理JSON文件
Tsang的博客
08-08 1104
本文共计4417字，预计阅读时间7分钟
Go_Json的序列化和反序列化
itzhuzhu的博客
02-21 2149
序列化用json.Marshal() 反序列化用json.Unmarshal()，反序列化时要和序列化前的数据类型保持一致
C语言的goto语法
06-02
C语言中的goto语句可以无条件地使程序转移到指定标签处，它的基本语法如下： ```c goto label; ... label: statement; ``` 其中，label是一个标签，可以是任意的标识符，但必须在当前函数内唯一，它通常用来标识一个代码块的起始位置。当程序执行到goto语句时，会转移到label标签所在的语句处继续执行。注意，goto语句只能用于在同一函数内进行跳转，不能跨越函数。另外，过多使用goto语句可能会导致程序结构不清晰，增加代码维护的难度，因此应该谨慎使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

LoisMay

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

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

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

打赏作者

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

抵扣说明：

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

余额充值