【转】Golang下的encoding相关模块使用go编解码

xiaoxiao2025-04-26 4

转自：https://www.jianshu.com/p/772ca3c6c7ed

encoding/json模块的使用

包名：encoding/json 在程序开发过程中最常见的就是讲字符串以及json之间的转化。在Golang中需要先定义一个json字符串的结构体来作为转换介质。

marshal和unmarshal

常用的几个方法函数:

//将接口v中的数据解析成json格式的[]byte func Marshal(v interface{}) ([]byte, error) //按照一定格式和缩进方式格式化json字符串 func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) //将json字符串转换成[]byte，不能够读入接口v中 func Unmarshal(data []byte, v interface{}) error

需要注意的问题：

/* 针对json的输出，我们定义struct tag的时候需要注意： (1)字段的tag是"-"，该字段不会输出到JSON (2)tag中带有自定义名称，该自定义名称会出现在json的字段名中 (3)tag中带有"omitempty"选项，该字段值为空，不会输出到json (4)如果字段类型为bool,string,int,int64等，而tag中带有",string"选项，该字段输出到json的时候会把该字段对应的值转换成json字符串 Marshal函数只有在转换成功的时候才会返回数据，所以转换过程需要注意以下几点： (1)JSON对象只支持string作为key，所编码一个map，那么必须是map[string]T这种类型 (2)Channel，complex和function是不能被编码成JSON的 (3)嵌套的数据是不能编码的，不然会让json编码进入死循环 (4)指针在编码的二十号会输出指针指向的内容，而指针会输出null */

示例：

# 将golang内部对象格式化成json串 $ cat marshal-test.go package main import ( "fmt" "encoding/json" _ "bytes" "os" ) type Serverslice struct{ Servers []Server `json:"servers"` } type Server struct{ ServerName string `json:"servername"` ServerIP string `json:"serverip,omitempty"` } func main() { var s Serverslice //func append(slice []Type, elems ...Type) []Type s.Servers = append(s.Servers,Server{ServerName:"Beijing",ServerIP:"10.0.0.1"}) s.Servers = append(s.Servers,Server{ServerName:"Xi'an",ServerIP:"10.0.0.2"}) //slice里面嵌套结构体[{},{}] 遍历出来的是slice里面包含json串 ss := []Server{{"Beijing","172.0.0.1"},{"Shanghai","172.0.0.2"}} b,err := json.Marshal(s) if err != nil { os.Exit(1) } fmt.Println(string(b)) bb,err := json.MarshalIndent(ss,""," ") if err == nil { fmt.Println(string(bb)) } } //第一个是结构体内部嵌套[]struct //第二个是[]struct来初始化结构体对象的 $ go run marshal-test.go {"servers":[{"servername":"Beijing","serverip":"10.0.0.1"},{"servername":"Xi'an","serverip":"10.0.0.2"}]} [ { "servername": "Beijing", "serverip": "172.0.0.1" }, { "servername": "Shanghai", "serverip": "172.0.0.2" } ] # 将json字符串读取后转化成内部的对象实例 $ cat unmarshal.go package main import ( "fmt" "encoding/json" ) type Server struct { ServerName string `json:"servername"` ServerIP string `json:"serverip"` } //数组对应slice type Serverslice struct{ Servers []Server } func main() { //初始化一个json字符串 str := `{"servers":[{"servername":"Beijing","serverip":"10.0.0.1"},{"servername":"Xi'an","serverip":"10.0.0.2"}]}` //func Unmarshal(data []byte, v interface{}) error //初始化一个接口对象，用来存储json对象元素 var s Serverslice //将json的字符串转换成s对象(这里用的是指针的方式，所以可以直接修改底层结构体中的数据) //需要读取的json字符串必须先写入[]byte类型的对象中(二进制对象文件) if err := json.Unmarshal([]byte(str),&s); err == nil { fmt.Println(s) fmt.Println(s.Servers) fmt.Println(s.Servers[0].ServerName,s.Servers[1].ServerName) } }

decode和encode

encoding/hex模块的使用

hex包主要用来编码和解码16进制的字符串主要函数：

//将src解码到[]byte类型的dst(长度为DecodedLen(len(src)))中，并且返回dst的长度 func Decode(dst, src []byte) (int, error) //解码16进制的字符串为一个[]byte func DecodeString(s string) ([]byte, error) //x个byte解码后的长度，一般是x/2 func DecodedLen(x int) int //返回data的dump字符串，格式类似于`hexdump -C`命令行输出 func Dump(data []byte) string func Dumper(w io.Writer) io.WriteCloser //将src编码到dst中(固定的长度为EncodedLen(len(src)) ) func Encode(dst, src []byte) int //将[]byte转换成字符串16进制的字符串 func EncodeToString(src []byte) string //返回一个编码长度，一般为n的2倍 func EncodedLen(n int) int

示例:

$ cat hex.go package main import ( "encoding/hex" "fmt" ) func Something() { //func EncodeToString(src []byte) string 编码byte字节为16进制字符串 src := []byte("hello") fmt.Println(src) //[104 101 108 108 111] encodeStr := hex.EncodeToString(src) //68656c6c6f 16进制转换 fmt.Println(encodeStr) //func Encode(dst, src []byte) int //func EncodedLen(n int) int Welcome := []byte("Gopher!") Wdest := make([]byte, hex.EncodedLen(len(Welcome))) num := hex.Encode(Wdest, Welcome) fmt.Println(Wdest, num) //num=14 //func DecodeString(s string) ([]byte, error) 解码16进制的字符串为byte类型 decodeStr, _ := hex.DecodeString(encodeStr) fmt.Println(string(decodeStr)) //func DecodedLen(x int) int x个byte解码后的长度，一般是x/2 //func Decode(dst, src []byte) (int, error) 将byte类型的src解码到byte类型的dst中，并且返回dst的长度 test := []byte("48656c6c6f20476f7068657221") dest := make([]byte, hex.DecodedLen(len(test))) //定义一个切片 num, err := hex.Decode(dest, test) //转换16进制字符串为byte[]类型，返回切片长度 if err != nil { return } fmt.Println(num, dest[:num], string(dest), len(dest), cap(dest)) // print 13 //func Dump(data []byte) string //返回给定字符串以及字符串相对应的hex dump文件效果相当于linux命令行下的"hexdump -C filename" content := []byte("Go is an open source programming language.") fmt.Println(hex.Dump(content)) } func main() { Something() } $ go run hex.go [104 101 108 108 111] 68656c6c6f [52 55 54 102 55 48 54 56 54 53 55 50 50 49] 14 hello 13 [72 101 108 108 111 32 71 111 112 104 101 114 33] Hello Gopher! 13 13 00000000 47 6f 20 69 73 20 61 6e 20 6f 70 65 6e 20 73 6f |Go is an open so| 00000010 75 72 63 65 20 70 72 6f 67 72 61 6d 6d 69 6e 67 |urce programming| 00000020 20 6c 61 6e 67 75 61 67 65 2e | language.|

encoding/gob包的使用

gob包主要用来管理在二进制的字节流之间进行编码和解码的事物上。一个典型的使用案例就是使用net/rpc包传输在远程过程调用(RPC)中的参数和结果。

import "encoding/gob"

1.一个模拟网络中的字节流转换

示例说明：定义两个结构体P,Q，前者用于gob在一个网络中编码(encoder)的数据结构，后者用于解码(decoder)的数据结构。

package main /* 使用`encoding/gob`包的一个简单用法，创建一个编码器(encoder),传输一些值，然后使用解码器(decoder)进行接收 */ import ( "bytes" "encoding/gob" "fmt" "log" ) type P struct { X, Y, Z int Name string } type Q struct { X, Y *int32 Name string } func main() { // 初始化一个encoder和decoder.t通常encoder和decoder将通过网络连接，并且两者在不同的进程中运行 var network bytes.Buffer // 使用buffer模拟一个网络连接(二进制字节流) enc := gob.NewEncoder(&network) // 编码一些数据到网络中 dec := gob.NewDecoder(&network) // 从网络中读取编码并解析 /* //NewDecoder初始化一个decoder对象，返回空的Decoder结构体 func NewDecoder(r io.Reader) *Decoder // Decoder结构体方法 func (dec *Decoder) Decode(e interface{}) error func (*Decoder) DecodeValue //NewEncoder初始化一个encoder对象，并返回Encoder机构体 func NewEncoder(w io.Writer) *Encoder // Encoder结构体方法 func (enc *Encoder) Encode(e interface{}) error func (enc *Encoder) EncodeValue(value reflect.Value) error */ // 使用enc进行发送一些编码的数据 // 使用enc.Encode方法进行编码两组数据 err := enc.Encode(P{6, 6, 8, "xxbandy.github.io"}) if err != nil { log.Fatal("encode error:", err) } err = enc.Encode(P{1024, 2048, 1000, "BG彪"}) if err != nil { log.Fatal("encode error:", err) } // 使用dec进行解码二进制数据并打印这些值 // 初始化结构体变量，并将网络连接(&network)中的数据按照结构体Q的实例q进行解码 var q Q err = dec.Decode(&q) if err != nil { log.Fatal("decode error 1:", err) } fmt.Printf("%q: {%d, %d}\n", q.Name, *q.X, *q.Y) err = dec.Decode(&q) if err != nil { log.Fatal("decode error 2:", err) } fmt.Printf("%q: {%d, %d}\n", q.Name, *q.X, *q.Y) }

运行效果:

$ go run simple-encoder-decoder.go "xxbandy.github.io": {6, 6} "BG彪": {1024, 2048}

2.通过自定义的Encode和Decode方法工具来传输值

通过接口的方式转换结构体变量中的私有变量

package main import ( "bytes" "encoding/gob" "fmt" "log" ) // Vector 结构体有一些导出的域，这些包不能够被访问，因此我们需要使用`gob`包 // 写一个BinaryMarshal/BinaryUnmarshal方法对来允许我们去发送和接收该类型的数据. // 这些接口都被定义在了`encoding`包中 // 其实等同于当前包中定义的`GobEncode/GobDecoder`接口 type Vector struct { x, y, z int } // Vector的MarshalBinary方法 func (v Vector) MarshalBinary() ([]byte, error) { // A simple encoding: plain text. // 一个简单的纯文本编码示例 var b bytes.Buffer fmt.Fprintln(&b, v.x, v.y, v.z) return b.Bytes(), nil } // Vector的UnmarshalBinary方法修改了接受者方法，必须接收一个指针 func (v *Vector) UnmarshalBinary(data []byte) error { b := bytes.NewBuffer(data) _, err := fmt.Fscanln(b, &v.x, &v.y, &v.z) return err } // 使用自定义的encoding和decoding方法来传输数据 func main() { // 使用buffer伪造一个网络连接 var network bytes.Buffer // 初始化一个编码器encoder并发送一段数据 enc := gob.NewEncoder(&network) //因为Vector中的元素都是私有变量不能被外部调用,需要默认定义相关的方法 // 疑问：为啥Vector结构体相关的方法会自动执行内部的MarshalBinary和UnmarshalBinary方法 err := enc.Encode(Vector{3, 4, 5}) if err != nil { log.Fatal("encode:", err) } // 创建一个解码器(decoder)并接收一个值 dec := gob.NewDecoder(&network) var v Vector err = dec.Decode(&v) if err != nil { log.Fatal("decode:", err) } fmt.Println(v) }

输出示例:

$ go run gob-EncoderDecoder.go {3 4 5}

3.使用gob包来传输接口类型的数据

使用gob包来编码、解码并传输接口类型数据需要使用gob.Register(value interface{})对指定类型数据进行注册。

/** * @File Name: gob-interface.go * @Author: xxbandy @http://xxbandy.github.io * @Email: * @Create Date: 2018-03-12 14:03:10 * @Last Modified: 2018-03-12 14:03:23 * @Description: */ package main import ( "bytes" "encoding/gob" "fmt" "log" "math" ) type Point struct { X, Y int } // 定义一个斜边长度 func (p Point) Hypotenuse() float64 { return math.Hypot(float64(p.X), float64(p.Y)) } //定义毕达哥拉斯接口,其中有很多著名的定理，勾股定理就是其一 type Pythagoras interface { Hypotenuse() float64 } // 该示例演示如何去编码一个接口类型的值 // 和正则类型的区别是注册一个具体的类型而不是实现该接口 func main() { // 构造一个网络连接 var network bytes.Buffer // 首先必须为encoder何decoder注册一个具体的类型 // 随后该具体的类型将发送一个生命去实现该接口 // func Register(value interface{}) gob.Register(Point{}) // 创建一个encoder并发送数据 enc := gob.NewEncoder(&network) for i := 1; i <= 3; i++ { interfaceEncode(enc, Point{3 * i, 4 * i}) } // 创建一个decoder解码数据并返回 dec := gob.NewDecoder(&network) for i := 1; i <= 3; i++ { result := interfaceDecode(dec) fmt.Println(result.Hypotenuse()) } } // interfaceEncode 函数编码一个接口类型的值到encoder示例中 func interfaceEncode(enc *gob.Encoder, p Pythagoras) { // 需要再调用的时候优先进行注册指定的类型，否则会失败 // 需要传送一个指针给接口去编码一个接口类型,如果我们直接去传一个p，将会变成具体类型去代替 err := enc.Encode(&p) if err != nil { log.Fatal("encode:", err) } } // interfaceDecode 从字节流中解码下一个接口类型的值并返回它 // 返回一个Pythagoras 接口类型的值 func interfaceDecode(dec *gob.Decoder) Pythagoras { // decode将失败除非在链接中具体的类型已被注册(Point{}需要先使用gob.Register()注册才可以进行解码) // 一般情况下我们会在主函数调用中去注册 var p Pythagoras err := dec.Decode(&p) if err != nil { log.Fatal("decode:", err) } return p } $ go run gob-interface.go 5 10 15

最新回复(0)