Go语言数据序列化和反序列化有哪些方法

在Go语言中，数据序列化和反序列化是将数据结构转换为字节流以便存储或传输，以及从字节流恢复数据结构的过程。Go语言提供了多种方法来实现这些操作。以下是一些常用的序列化和反序列化方法：

序列化方法

1. JSON序列化：

   • 使用encoding/json包可以将Go语言的数据结构转换为JSON格式的字节流。

   import (
       "encoding/json"
       "fmt"
   )
   
   type Person struct {
       Name string `json:"name"`
       Age  int    `json:"age"`
   }
   
   func main() {
       p := Person{Name: "Alice", Age: 30}
       jsonData, err := json.Marshal(p)
       if err != nil {
           fmt.Println("Error marshaling JSON:", err)
           return
       }
       fmt.Println("JSON data:", string(jsonData))
   }
   

2. XML序列化：

   • 使用encoding/xml包可以将Go语言的数据结构转换为XML格式的字节流。

   import (
       "encoding/xml"
       "fmt"
   )
   
   type Person struct {
       XMLName xml.Name `xml:"person"`
       Name    string   `xml:"name"`
       Age     int      `xml:"age"`
   }
   
   func main() {
       p := Person{Name: "Alice", Age: 30}
       xmlData, err := xml.MarshalIndent(p, "", "  ")
       if err != nil {
           fmt.Println("Error marshaling XML:", err)
           return
       }
       fmt.Println("XML data:", string(xmlData))
   }
   

3. 二进制序列化：

   • 使用encoding/binary包可以将Go语言的数据结构转换为二进制格式的字节流。

   import (
       "encoding/binary"
       "fmt"
   )
   
   type Person struct {
       NameLength uint8
       Name       [100]byte
       Age        uint8
   }
   
   func main() {
       p := Person{NameLength: 5, Name: [100]byte{'A', 'l', 'i', 'c', 'e'}, Age: 30}
       var buf bytes.Buffer
       binary.Write(&buf, binary.LittleEndian, p)
       binaryData := buf.Bytes()
       fmt.Println("Binary data:", binaryData)
   }
   

反序列化方法

1. JSON反序列化：

   • 使用encoding/json包可以将JSON格式的字节流转换回Go语言的数据结构。

   import (
       "encoding/json"
       "fmt"
   )
   
   type Person struct {
       Name string `json:"name"`
       Age  int    `json:"age"`
   }
   
   func main() {
       jsonData := []byte(`{"name":"Bob","age":25}`)
       var p Person
       err := json.Unmarshal(jsonData, &p)
       if err != nil {
           fmt.Println("Error unmarshaling JSON:", err)
           return
       }
       fmt.Println("Deserialized person:", p)
   }
   

2. XML反序列化：

   • 使用encoding/xml包可以将XML格式的字节流转换回Go语言的数据结构。

   import (
       "encoding/xml"
       "fmt"
   )
   
   type Person struct {
       XMLName xml.Name `xml:"person"`
       Name    string   `xml:"name"`
       Age     int      `xml:"age"`
   }
   
   func main() {
       xmlData := []byte(`<person><name>Bob</name><age>25</age></person>`)
       var p Person
       err := xml.Unmarshal(xmlData, &p)
       if err != nil {
           fmt.Println("Error unmarshaling XML:", err)
           return
       }
       fmt.Println("Deserialized person:", p)
   }
   

3. 二进制反序列化：

   • 使用encoding/binary包可以将二进制格式的字节流转换回Go语言的数据结构。

   import (
       "encoding/binary"
       "fmt"
   )
   
   type Person struct {
       NameLength uint8
       Name       [100]byte
       Age        uint8
   }
   
   func main() {
       binaryData := []byte{5, 'A', 'l', 'i', 'c', 'e', 0, 0, 0, 30}
       var p Person
       buf := bytes.NewReader(binaryData)
       binary.Read(buf, binary.LittleEndian, &p)
       fmt.Println("Deserialized person:", p)
   }
   

除了上述方法，还有一些第三方库提供了更多的序列化和反序列化功能，例如protobuf用于高效的二进制序列化，msgpack用于更紧凑的二进制序列化等。选择哪种方法取决于具体的应用场景和性能需求。