Getting started with the go language is simple: go handles XML files

Read  XML  file

Let's take a look at how to read the local  XML  file , Same as  JSON  The data is similar to ,Go  You also need a structure to receive  XML  The data of .

Let's define a  

test.xml

  file , Access is employee information ：

<?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?>
<Record>
 <Name>Yuzhou</Name>
 <SurName>1su</SurName>
 <Tel>
 <Mobile>true</Mobile>
 <Number>12345678</Number>
 </Tel>
 <Tel>
 <Mobile>true</Mobile>
 <Number>0755-12345</Number>
 </Tel>
</Record>

Then we see the  XML  There's a record , So we need two structures ：

Record

  and  

Telphone

 ：

type Record struct {
Name string
Surname string
Tel []Telephone
}

type Telephone struct {
Mobile bool
Number string
}

Then define a  

readFromXML()

  function , Read the file first , Then parse the file ：

func readFromXMl(filename string, key interface{}) error {
in, err := os.Open(filename)
if err != nil {
return err
}

decodeXML := xml.NewDecoder(in)
err = decodeXML.Decode(key)
if err != nil {
return err
}
in.Close()
return nil
}

Finally, the complete part of our code is as follows ：

package main

import (
"encoding/xml"
"fmt"
"os"
)

type Record struct {
Name string
Surname string
Tel []Telephone
}

type Telephone struct {
Mobile bool
Number string
}

func readFromXMl(filename string, key interface{}) error {
in, err := os.Open(filename)
if err != nil {
return err
}

decodeXML := xml.NewDecoder(in)
err = decodeXML.Decode(key)
if err != nil {
return err
}
in.Close()
return nil
}

func main() {

arguments := os.Args
if len(arguments) == 1 {
fmt.Println("Please provide a filename!")
return
}

filename := arguments[1]

var myRecord Record

err := readFromXMl(filename, &myRecord)

if err == nil {
fmt.Println("XML:", myRecord)
} else {
fmt.Println(err)
}
}


Execute the code at the terminal , The results are as follows ：

$ go run main.go test.xml 
XML: {Yuzhou [{true 12345678} {true 0755-12345}]}

analysis  XML

Go  There is a use of  

NewParser()

Created  XML  Parser .  It needs a  

io.Reader()

  As a parameter and returns a pointer to  

Parser

  The pointer to .  If  XML  The file is in the user tab 、 The attribute... Is set on the nested element , If you can resolve these properties , So by extending , You should be able to parse any size of  XML  file .

Now create another  

test.xml

  file ：

<?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?>
<servers version=&quot;1&quot;>
 <server>
 <serverName>Shanghai_VPN</serverName>
 <serverIP>127.0.0.1</serverIP>
 </server>
 <server>
 <serverName>Beijing_VPN</serverName>
 <serverIP>127.0.0.2</serverIP>
 </server>
</servers>

How to parse the above  XML  Documents ？ We can see through  xml  Modular  

Unmarshal()

  Function to achieve our goal ：

func Unmarshal(data []byte, v interface{}) error

data  Receive is  XML  File stream ,v  Is the structure that needs to be output , Defined as  interface, That is to say, we can  XML  Convert to any format . We mainly introduce  struct  Transformation , because  struct  and  XML  All have characteristics similar to tree structure .

Define our structure ：

type Recurlyservers struct {
 XMLName xml.Name `xml:"servers"`
 Version string `xml:"version,attr"`
 Svs []server `xml:"server"`
 Description string `xml:",innerxml"`
}

type server struct {
 XMLName xml.Name `xml:"server"`
 ServerName string `xml:"serverName"`
 ServerIP string `xml:"serverIP"`
}

Complete code ：

package main

import (
"encoding/xml"
"fmt"
"io/ioutil"
"os"
)

type Recurlyservers struct {
XMLName xml.Name `xml:"servers"`
Version string `xml:"version,attr"`
Svs []server `xml:"server"`
Description string `xml:",innerxml"`
}

type server struct {
XMLName xml.Name `xml:"server"`
ServerName string `xml:"serverName"`
ServerIP string `xml:"serverIP"`
}

func main() {
file, err := os.Open("test.xml") // For read access.
if err != nil {
fmt.Printf("error: %v", err)
return
}
defer file.Close()
data, err := ioutil.ReadAll(file)
if err != nil {
fmt.Printf("error: %v", err)
return
}
v := Recurlyservers{}
err = xml.Unmarshal(data, &v)
if err != nil {
fmt.Printf("error: %v", err)
return
}

fmt.Println(v)
}


XML  It's essentially a tree structure , And we can define the matching  go  The structural types of language , And then through

xml.Unmarshal

  to  xml  The file in is parsed into the corresponding  struct  Structure . The above example outputs the following results ：

{{ servers} 1 [{{ server} Shanghai_VPN 127.0.0.1} {{ server} Beijing_VPN 127.0.0.2}]
<server>
 <serverName>Shanghai_VPN</serverName>
 <serverIP>127.0.0.1</serverIP>
</server>
<server>
 <serverName>Beijing_VPN</serverName>
 <serverIP>127.0.0.2</serverIP>
</server>
}

In the example above , take  xml  The file resolves to the corresponding  struct  The structure is through  

xml.Unmarshal

  To complete ,

How this process is implemented ？ You can see our  struct  There are some more definitions, similar to  

xml:"serverName"

  Such content , This is  struct  A feature of , They are called  struct tag, They are used to assist reflection . Let's take a look  Unmarshal  The definition of ：

func Unmarshal(data []byte, v interface{}) error

We see that the function defines two parameters , The first is  XML  File stream , The second is the corresponding type of storage , At present, we support ：

• Structure  struct

• section  slice

• character string  string

XML  Reflection is used inside the suite to map files , therefore  v  The position inside must be output .

Unmarshal

  When parsing  XML  How do elements correspond to corresponding types ？

Read in a sequential order ： First it will read  struct tag, without , Then it will correspond to the field name . It must be noted that when parsing  tag、 Field name 、XML  Elements are case sensitive , So one by one .

analysis  XML  To  struct  Follow the following rules when you ：

• If  struct  The second parameter of is  
  string
    perhaps  
  []byte
    type , And its  tag  contain  
  ",innerxml"
  ,
  Unmarshal
    All embedded primitives in the element corresponding to this position will be  xml  Add up to this position , As in the example above  Description  Definition . The final output is ：

 <server>
 <serverName>Shanghai_VPN</serverName>
 <serverIP>127.0.0.1</serverIP>
 </server>
 <server>
 <serverName>Beijing_VPN</serverName>
 <serverIP>127.0.0.2</serverIP>
 </server>

summary

This article mainly introduces how to read local data  XML  File and parse  XML  file , Separate use  Go  Of  ​

​encoding/ XML​

​​  In bag  ​

​NewDecoder()​

​​  and  ​

​Unmarshal()​

​  function . Then explore more usage , For example  Web  Read the configuration file during development , Or receive  XML  File format file . The next article will introduce how to  Go  Data into  XML  file .