XML解析

設(shè)置要解析的對象

設(shè)置要解析的xml文件對象

type Result struct {
    XMLName xml.Name `xml:"persons"`//標(biāo)簽上的標(biāo)簽名
    Persons []Person `xml:"person"`
}
type Person struct {
    Name string `xml:"name,attr"`//persion標(biāo)簽屬性名為name的屬性值
    Age int `xml:"age,attr"`
    Career string `xml:"career"`//persion中標(biāo)簽名為career的值
    Interests []string `xml:"interests>interest"`//標(biāo)簽interests下的interest數(shù)組
    //不寫>當(dāng)子標(biāo)簽為一個的時候回把它當(dāng)做對象解析
}

對應(yīng)的xml文件
<?xml version="1.0" encoding="UTF-8"?>
<persons>
    <person name="polaris" age="28">
        <career>無業(yè)游民</career>
        <interests>
            <interest>編程</interest>
            <interest>下棋</interest>
        </interests>
    </person>
    <person name="studygolang" age="27">
        <career>碼農(nóng)</career>
        <interests>
            <interest>編程</interest>
            <interest>下棋</interest>
        </interests>
    </person>
</persons>

XML字符串讀取

方法一：轉(zhuǎn)對象

input := `<Person><FirstName>Xu</FirstName><LastName>Xinhua</LastName></Person>`
err := xml.Unmarshal([]byte(input), &v)//將文件轉(zhuǎn)化成對象

方法二：遍歷

package main

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

func main() {
    var t xml.Token
    var err error

    input := `<Person><FirstName>Xu</FirstName><LastName>Xinhua</LastName></Person>`
    inputReader := strings.NewReader(input)

    // 從文件讀取聚凹，如可以如下：
    // content, err := ioutil.ReadFile("studygolang.xml")
    // decoder := xml.NewDecoder(bytes.NewBuffer(content))

    decoder := xml.NewDecoder(inputReader)
    for t, err = decoder.Token(); err == nil; t, err = decoder.Token() {
        switch token := t.(type) {
        // 處理元素開始（標(biāo)簽）
        case xml.StartElement:
            name := token.Name.Local
            fmt.Printf("Token name: %s\n", name)
            for _, attr := range token.Attr {
                attrName := attr.Name.Local
                attrValue := attr.Value
                fmt.Printf("An attribute is: %s %s\n", attrName, attrValue)
            }
        // 處理元素結(jié)束（標(biāo)簽）
        case xml.EndElement:
            fmt.Printf("Token of '%s' end\n", token.Name.Local)
        // 處理字符數(shù)據(jù)（這里就是元素的文本）
        case xml.CharData:
            content := string([]byte(token))
            fmt.Printf("This is the content: %v\n", content)
        default:
            // ...
        }
    }
}

XML文件讀取

//從文件讀取睡榆，如可以如下：
content, err := ioutil.ReadFile("studygolang.xml")
decoder := xml.NewDecoder(bytes.NewBuffer(content))
xml.Unmarshal(content, &result)//將文件轉(zhuǎn)化成對象

生成xml

對象轉(zhuǎn)換為xml

package main

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

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

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

func main() {
    v := &Servers{Version: "1"}
    v.Svs = append(v.Svs, server{"Shanghai_VPN", "127.0.0.1"})
    v.Svs = append(v.Svs, server{"Beijing_VPN", "127.0.0.2"})
    output, err := xml.MarshalIndent(v, "  ", "    ")
    if err != nil {
        fmt.Printf("error: %v\n", err)
    }
    // os.Stdout.Write([]byte(xml.Header))

    // os.Stdout.Write(output)
    //將字節(jié)流轉(zhuǎn)換成string輸出
    fmt.Println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"+string(output))
}

map與XML相互轉(zhuǎn)換（只能解決簡單的的xml）

package main

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

type Map map[string]string

type xmlMapEntry struct {
    XMLName xml.Name
    Value   string `xml:",chardata"`
}

// MarshalXML marshals the map to XML, with each key in the map being a
// tag and it's corresponding value being it's contents.
func (m Map) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
    if len(m) == 0 {
        return nil
    }

    err := e.EncodeToken(start)
    if err != nil {
        return err
    }

    for k, v := range m {
        e.Encode(xmlMapEntry{XMLName: xml.Name{Local: k}, Value: v})
    }

    return e.EncodeToken(start.End())
}

// UnmarshalXML unmarshals the XML into a map of string to strings,
// creating a key in the map for each tag and setting it's value to the
// tags contents.
//
// The fact this function is on the pointer of Map is important, so that
// if m is nil it can be initialized, which is often the case if m is
// nested in another xml structurel. This is also why the first thing done
// on the first line is initialize it.
func (m *Map) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    *m = Map{}
    for {
        var e xmlMapEntry

        err := d.Decode(&e)
        if err == io.EOF {
            break
        } else if err != nil {
            return err
        }

        (*m)[e.XMLName.Local] = e.Value
    }
    return nil
}

func main() {
    // The Map
    m := map[string]string{
        "key_1": "Value One",
        "key_2": "Value Two",
    }
    fmt.Println(m)

    // Encode to XML
    x, _ := xml.MarshalIndent(Map(m), "", "  ")
    fmt.Println(string(x))

    // Decode back from XML
    var rm map[string]string
    xml.Unmarshal(x, (*Map)(&rm))
    fmt.Println(rm)
}