从JSON转换为XML

Question

我在这里看到了许多有关从XML转换为JSON的文章，最近我写了一个程序来做，但是我也很好奇您将如何从JSON转换为XML？

样本JSON：

"version":"0.1",
  "termsofService":"http://www.wunderground.com/weather/api/d/terms.html",
  "features": {
  "conditions": 1
  }
    }
  , "current_observation": {
        "image": {
        "url":"http://icons.wxug.com/graphics/wu2/logo_130x80.png",
        "title":"Weather Underground",
        "link":"http://www.wunderground.com"
        },
        "display_location": {
        "full":"Kearney, MO",
        "city":"Kearney",
        "state":"MO",
        "state_name":"Missouri",

我不确定这是否对您有用，但是我将JSON发布到XML程序中。

package main

import (
    "fmt"
    "net/url"
    "encoding/xml"
    "net/http"
    "log"
    "io/ioutil"
    "encoding/json"
)

type reportType struct{
    Version xml.CharData        `xml:"version"`
    TermsOfService xml.CharData `xml:"termsofService"
    `
    Features xml.CharData       `xml:"features>feature"`
    Full     string     `xml:"current_observation>display_location>full"`
    StateName string        `xml:"current_observation>display_location>state_name"`
    WindGust string     `xml:"current_observation>observation_location>full"`
    Problem myErrorType     `xml:"error"`
}
type myErrorType struct{
    TypeOfError xml.CharData `xml:"type"`
    Desciption xml.CharData `xml:"description"`
}
type reportTypeJson struct{
    Version        string  `json:"version"`;
    TermsOfService string `json:"termsofService"`;
    Features    map[string]string `json:"features"`;
    CurrentObservation map[string]map[string]string `json:"current_observation"`

}
func main() {
    fmt.Println("data is from WeatherUnderground.")
    fmt.Println("https://www.wunderground.com/")
    var state, city string
    str1 := "What is your state?"
    str2 := "What is your city?"
    fmt.Println(str1)
    fmt.Scanf("%s", &state)
    fmt.Println(str2)
    fmt.Scanf("%s", &city)
    baseURL := "http://api.wunderground.com/api/";
    apiKey := "Nunna"
    var query string

    //set up the query
    query = baseURL+apiKey +
    "/conditions/q/"+
    url.QueryEscape(state)+ "/"+
    url.QueryEscape(city)+ ".xml"
    fmt.Println("The escaped query: "+query)

    response, err := http.Get(query)
    doErr(err, "After the GET")
    var body []byte
    body, err = ioutil.ReadAll(response.Body)
    doErr(err, "After Readall")
    fmt.Println(body);
    fmt.Printf("The body: %s\n",body)

    //Unmarshalling
    var report reportType
    xml.Unmarshal(body, &report)
    fmt.Printf("The Report: %s\n", report)
    fmt.Printf("The description is [%s]\n",report.Problem.Desciption)

    //Now marshal the data out in JSON
    var data []byte
    var output reportTypeJson
    output.Version = string(report.Version);
    output.TermsOfService = string(report.TermsOfService)

    output.Features= map[string]string{"feature":string(report.Features)} // allocate a map, add the 'features' value to it and assign it to output.Features
    output.CurrentObservation = map[string]map[string]string {
        "display_location": map[string]string {
            "full": report.Full,
            "state_name": report.StateName,
        },"observation_location":map[string]string {"full": report.WindGust},
    }
    data,err = json.MarshalIndent(output,"","      ")
    doErr(err, "From marshalIndent")
    fmt.Printf("JSON output nicely formatted: \n%s\n",data)


}
func doErr( err error, message string){
    if err != nil{
        log.Panicf("ERROR: %s %s \n", message, err.Error())
    }


}
//OUTPUT:
//JSON output nicely formatted: 
//{
//     "version": "0.1",
//      "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
//      "features": {
//            "feature": "conditions"
//      },
//      "current_observation": {
//            "display_location": {
//                  "full": "Kearney, MO",
//                  "state_name": "Missouri"
//            },
//            "observation_location": {
//                  "full": "HOMESTEAD HILLS, Kearney, Missouri"
//            }
//      }
//}

Answer 1

这是与另一个方向相同的过程。 定义结构/对象以对输入进行建模（在本例中为json），创建方法以将对输入进行建模的结构中的所有值分配给您要用于输出的结构，然后编组输出以获取字符串。 因此，举一个使用您输入的概念上比较困难的字段之一作为示例，将一些json解组到reportTypeJson的实例中，我可以像这样分配给用来对xml建模的reportType ；

report.StateName = jsonReport.CurrentObservation["display_location"]["state_name"]

这里最大的区别是表示xml的结构是扁平的（例如，它具有Something> InnerSomething> InnerInnerSomething来表示其嵌套值，而golang中的结构没有嵌套），其中与json一样，golang中的结构往往具有相同的结构嵌套量（例如具有map [string] map [string] [string]意味着项目在主结构内嵌套了3级）。 您可以通过访问字段时的间接访问量来观察到这一点，例如在上面的示例中，访问CurrentObservation有一个间接访问CurrentObservation但这是一个地图映射，因此我用display_location键对其进行索引，从而产生一个map[string]string ，因为我正在寻找statename值，所以我必须使用state_name索引到其中以访问该值。

请注意，在实际程序中，将需要进行许多检查，因为这些操作是不安全的。 例如，如果读取的json不包含display_location对象，则jsonReport.CurrentObservation["display_location"]将返回nil ，并且尝试访问["state_name"将导致恐慌。

另外，另一点注意，在您的程序中，我建议添加两个函数，一个函数称为NewJsonReport(report *reportType) *reportTypeJson, err ，另一个NewXmlReport(report *reportTypeJson) *reportType, err称为NewXmlReport(report *reportTypeJson) *reportType, err在其中初始化/分配一个新函数返回类型的实例，并返回它，以避免代码重复并使程序main更具可读性。 在程序的多个位置进行这种类型的分配是草率的编码，这将增加大量的维护成本，并且可能会导致线下的错误（例如，如果某个模型或输入中的某些内容发生了更改，您必须修复整个程序中对它的所有引用，而不仅仅是更新我上面提到的功能）。