lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改了XML同时增加了json

Browse Source
This commit is contained in:
astaxie
2012-09-29 17:51:46 +08:00
parent 347c7ed150
commit 2fd34122e2
2 changed files with 234 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
7.1.md
View File

@@ -87,18 +87,36 @@ XML本质上是一种树形的数据格式，而我们可以定义与之匹配
} }
上面的例子中，将xml文件解析成对应的strcut对象是通过`xml.Unmarshal`来完成的，这个过程是如何实现的？可以看到我们的struct定义后面多了一些类似于`xml:"serverName"`这样的内容,这个是strcut的一个特性，它们被称为 strcut tag，它们是用来辅助反射的，Go语言的反射机制，可以利用这些tag信息来将来自XML文件中的数据反射成对应的struct对象，关于反射如何利用struct tag的更多内容请参阅reflect中的相关内容。在定义struct的时候，应该如何设置 struct tag呢？ 上面的例子中，将xml文件解析成对应的strcut对象是通过`xml.Unmarshal`来完成的，这个过程是如何实现的？可以看到我们的struct定义后面多了一些类似于`xml:"serverName"`这样的内容,这个是strcut的一个特性，它们被称为 strcut tag，它们是用来辅助反射的。我们来看一下`Unmarshal`的定义：
- 如果struct中一个string或者[]type类型的字段中tag定义了`",innerxml"`,那么这个字段会累计把这些原始的XML数据累计起来，如上Description定义。 func Unmarshal(data []byte, v interface{}) error
- 如果strcut中有一个字段类型xml.Name，叫做XMLName，那么在解析的时候就会这个element的名字
- 如果strcut里面字段后面的tag里面定义了XML的element，那么解析的时候就会把相应的element值赋值给struct字段，如上servername和serverip定义。
- 如果strcut里面字段后面的tag定义了`",attr"`，那么会读取该element下面的属性字段，如上version定义。
- 如果strcut字段后面的tag定义了`"a>b>c"`,那么会解析xml元素的结构a下面的b下面的c元素。
- 如果strcut字段后面的tag定义了`"-"`,那么这个字段不会被解析到任何数据。
- 如果strcut字段后面的tag定义了`",any"`，如果他的子元素在不满足其他的规则的时候就会匹配到这个字段。
- 如果strcut字段后面的tag定义了`",comments"`,这个字段一般都是[]byte或者string类型，那么在这个元素下面的注释会累积在这个字段里面。
上上面详细讲述了如何定义struct的tag。 只要设置对了tag，那么XML解析就如上面示例般简单，tag和xml的element是一一对应的关系，如上所示，我们可以通过slice来表示多个同级元素。 我们看到函数定义了两个参数，第一个是XML数据流，第二个是存储的对应类型，目前支持struct、slice和string，XML包内部采用了反射来进行数据的映射，所以v里面的字段必须是导出的。`Unmarshal`解析的时候XML元素和字段怎么对应起来的呢？这是有一个优先级读取流程的，首先会读取struct tag，如果没有，那么就会对应字段名。必须注意一点的是解析的时候tag、字段名、XML元素都是大小写敏感的，所以必须一一对应字段。
Go语言的反射机制，可以利用这些tag信息来将来自XML文件中的数据反射成对应的struct对象，关于反射如何利用struct tag的更多内容请参阅reflect中的相关内容。
解析XML到struct的时候遵循如下的规则：
- 如果struct的一个字段是string或者[]byte类型且它的tag含有`",innerxml"`，Unmarshal将会将此字段所对应的元素内所有内嵌的原始xml累加到此字段上，如上面例子Description定义。最后的输出是
<server>
<serverName>Shanghai_VPN</serverName>
<serverIP>127.0.0.1</serverIP>
</server>
<server>
<serverName>Beijing_VPN</serverName>
<serverIP>127.0.0.2</serverIP>
</server>
- 如果struct中有一个字段类型xml.Name，叫做XMLName，那么在解析的时候就会保存这个element的名字到该字段,如上面例子中的servers。
- 如果struct里面字段后面的tag里面定义了XML的element名称，那么解析的时候就会把相应的element值赋值给struct字段，如上servername和serverip定义。
- 如果struct里面字段后面的tag定义了`",attr"`，那么会读取该结构所对应的element下面的属性字段，如上version定义。
- 如果struct字段后面的tag定义了`"a>b>c"`,那么会解析xml元素的结构a下面的b下面的c元素。
- 如果struct字段后面的tag定义了`"-"`,那么这个字段不会被解析到任何数据。
- 如果struct字段后面的tag定义了`",any"`，如果他的子元素在不满足其他的规则的时候就会匹配到这个字段。
- 如果struct字段后面的tag定义了`",comments"`,这个字段一般都是[]byte或者string类型，那么在这个元素下面的注释会累积存储在这个字段里面。
上面详细讲述了如何定义struct的tag。 只要设置对了tag，那么XML解析就如上面示例般简单，tag和XML的element是一一对应的关系，如上所示，我们还可以通过slice来表示多个同级元素。
>注意： 为了正确解析，go语言的xml包要求struct定义中的所有字段必须是可导出的（即首字母大写） >注意： 为了正确解析，go语言的xml包要求struct定义中的所有字段必须是可导出的（即首字母大写）
@@ -157,13 +175,22 @@ XML本质上是一种树形的数据格式，而我们可以定义与之匹配
</server> </server>
</servers> </servers>
和我们之前定义的文件的格式一模一样，之所以会有`os.Stdout.Write([]byte(xml.Header))` 这句代码的出现，是因为`xml.MarshalIndent`或者`xml.Marshal`输出的信息都是不带XML头的，为了生成正确的xml文件，我们使用了xml包预定义的Header变量，另外生成的xml文件的无层次结构，也是由struct tag来控制的。 和我们之前定义的文件的格式一模一样，之所以会有`os.Stdout.Write([]byte(xml.Header))` 这句代码的出现，是因为`xml.MarshalIndent`或者`xml.Marshal`输出的信息都是不带XML头的，为了生成正确的xml文件，我们使用了xml包预定义的Header变量。
那么生成的XML文件中的element名字是通过获取的呢？他有如下几种方式获取： 我们看到`Marshal`函数接收的参数v是interface类型，所以他可以是任意类型，那么如何生成相应的XML呢？
- 字段名XMLName，类型xml.Name - 如果v是 array或者slice，那么输出每一个元素，类似<type>value</type>
- 如果v是指针，那么会Marshal指针指向的内容，如果指针为空，什么都不输出
- 如果v是interface，那么就处理interface所包含的数据
- 如果v是其他数据类型，就会输出这个数据类型所拥有的字段信息
那么生成的XML文件中的element名字是通过获取的呢？按照如下优先级获取：
- 如果v是struct，XMLName的tag中定义的名称
- 字段名XMLName，并且类型是xml.Name的字段值
- 通过strcut的字段中定义的tag来获取 - 通过strcut的字段中定义的tag来获取
- 通过strcut的字段名用来获取 - 通过strcut的字段名用来获取
- marshall的类型名称
而那么里面的结构和数据是如何输出的呢？我们需要如何设置struct里面的tag信息呢？ 而那么里面的结构和数据是如何输出的呢？我们需要如何设置struct里面的tag信息呢？

253
7.2.md
View File

@@ -1,60 +1,195 @@
#7.2 JSON处理 #7.2 JSON处理
JSON（Javascript Object Notation）是一种轻量级的数据交换语言，以文字为基础，具有自我描述性且易于让人阅读。尽管JSON是在Javascript的一个子集，但JSON是独立于语言的文本格式，并且采用了类似于C语言家族的一些习惯。JSON与XML最大的不同在于XML是一个完整的标记语言，而JSON不是。JSON由于比XML更小、更快，更易解析,以及浏览器的内建快速解析支持,使得其更适用于网络数据传输领域。目前我们看到很多的开放平台，基本上所有的接口都是采用了JSON作为他们的数据交互。那么JSON在Web开发中如此重要，Go语言对于JSON支持的怎么样呢？其实Go语言的标准库里面已经非常好的支持了JSON，可以对JSON包进行解析、生成JSON数据。 JSON（Javascript Object Notation）是一种轻量级的数据交换语言，以文字为基础，具有自我描述性且易于让人阅读。尽管JSON是在Javascript的一个子集，但JSON是独立于语言的文本格式，并且采用了类似于C语言家族的一些习惯。JSON与XML最大的不同在于XML是一个完整的标记语言，而JSON不是。JSON由于比XML更小、更快，更易解析,以及浏览器的内建快速解析支持,使得其更适用于网络数据传输领域。目前我们看到很多的开放平台，基本上所有的接口都是采用了JSON作为他们的数据交互。那么JSON在Web开发中如此重要，Go语言对于JSON支持的怎么样呢？其实Go语言的标准库里面已经非常好的支持了JSON，可以对JSON包进行解析、生成JSON数据。
我们还是假设目前想要描述所有的服务器列表，通过JSON如何来表达，请看下面的描述 我们还是假设目前想要描述所有的服务器列表，通过JSON如何来表达，请看下面的描述
{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]} {"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}
接下来的例子以此JSON数据为基础，我们来进行JSON的解析和生成。 接下来的例子以此JSON数据为基础，我们来进行JSON的解析和生成。
##解析JSON ##解析JSON
###解析到结构体 ###解析到结构体
假如有了上面的JSON串，那么我们如何来解析这个JSON串呢？Go的JSON包中有如下函数 假如有了上面的JSON串，那么我们如何来解析这个JSON串呢？Go的JSON包中有如下函数
func Unmarshal(data []byte, v interface{}) error func Unmarshal(data []byte, v interface{}) error
通过这个函数我们就可以实现解析的目的，详细的解析例子请看如下代码： 通过这个函数我们就可以实现解析的目的，详细的解析例子请看如下代码：
package main package main
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
) )
type Server struct { type Server struct {
ServerName string ServerName string
ServerIP string ServerIP string
} }
type Serverslice struct { type Serverslice struct {
Servers []Server Servers []Server
} }
func main() { func main() {
var s Serverslice var s Serverslice
str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}` str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`
json.Unmarshal([]byte(str), &s) json.Unmarshal([]byte(str), &s)
fmt.Println(s) fmt.Println(s)
} }
通过上面的例子我们可以看到我们首先定义了结构体，结构体和JSON的数据一一对应，数组对应slice，字段名对应JSON里面的KEY，那么解析的时候如何解析到对应的字段的呢？例如JSON的key是`Foo`，那么怎么找对应的字段呢？ 通过上面的例子我们可以看到我们首先定义了结构体，结构体和JSON的数据一一对应，数组对应slice，字段名对应JSON里面的KEY，那么解析的时候如何解析到对应的字段的呢？例如JSON的key是`Foo`，那么怎么找对应的字段呢？
- 首先查找字段的tag里面带有`Foo`的导出字段(首字母大写) - 首先查找字段的tag里面带有`Foo`的导出字段(首字母大写)
- 其次查找字段名是`Foo`的导出字段 - 其次查找字段名是`Foo`的导出字段
- 最后查找类似`FOO`或者`FoO`这样的除了首字母之外其他大小写不敏感的导出字段 - 最后查找类似`FOO`或者`FoO`这样的除了首字母之外其他大小写不敏感的导出字段
聪明的你一定注意到了一点，能够输出的数据必须是导出字段，其他字段是不能输出的。同时JSON解析的时候只会解析能找得到的字段，如果找不到的字段会被忽略，这样的一个好处是在于当你接收到一个很大的JSON数据的时候，你如果只想部分数据，那么用这种方式就可以轻松的解决了。 聪明的你一定注意到了一点，能够输出的数据必须是导出字段，其他字段是不能输出的。同时JSON解析的时候只会解析能找得到的字段，如果找不到的字段会被忽略，这样的一个好处是在于当你接收到一个很大的JSON数据的时候，你如果只想部分数据，那么用这种方式就可以轻松的解决了。
###解析到interface 上面这个是官方提供的解决方案，其实很多时候我们通过类型断言，操作起来不是很方便，目前bitly公司开发了一个`simplejson`,在处理未知结构体的JSON处理中相当方便，详细例子如下所示：
我们知道上面哪种解析方式是当我们了解了JSON的数据结构的情况下来进行的解析，那么如果我们在不知道JSON格式的情况下，如何来解析JSON呢？
js, err := NewJson([]byte(`{
##生成JSON "test": {
"array": [1, "2", 3],
## links "int": 10,
* [目录](<preface.md>) "float": 5.150,
* 上一节: [XML处理](<7.1.md>) "bignum": 9223372036854775807,
* 下一节: [正则处理](<7.3.md>) "string": "simplejson",
"bool": true
## LastModified }
}`))
arr, _ := js.Get("test").Get("array").Array()
i, _ := js.Get("test").Get("int").Int()
ms := js.Get("test").Get("string").MustString()
我们看到通过这个库对于我们来说操作JSON非常的简单，比起前面介绍的官方方案更加简洁。
###解析到interface
我们知道上面哪种解析方式是当我们了解了JSON的数据结构的情况下来进行的解析，那么如果我们在不知道JSON格式的情况下，如何来解析JSON呢？
我们知道interface{}可以存储任意的数据类型，那么这正好符合JSON包在未知数据结构的时候来进行解析，JSON包中采用map[string]interface{}和[]interface{}结构来存储任意的JSON对象和数组。Go类型和JSON类型的对应关系如下：
- bool 代表 JSON booleans,
- float64 代表 JSON numbers,
- string 代表 JSON strings,
- nil 代表 JSON null.
现在我们假设有如下的JSON数据
b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
如果在我们不知道他的结构的情况下，我们把他解析到interface{}里面
var f interface{}
err := json.Unmarshal(b, &f)
这个时候f里面存储了一个map类似，他们的key是string，值存储在空的interface{}里
f = map[string]interface{}{
"Name": "Wednesday",
"Age": 6,
"Parents": []interface{}{
"Gomez",
"Morticia",
},
}
那么如何来访问这些数据呢？通过断言的方式：
m := f.(map[string]interface{})
通过断言之后，你就可以通过如下方式来访问里面的数据了
for k, v := range m {
switch vv := v.(type) {
case string:
fmt.Println(k, "is string", vv)
case int:
fmt.Println(k, "is int", vv)
case []interface{}:
fmt.Println(k, "is an array:")
for i, u := range vv {
fmt.Println(i, u)
}
default:
fmt.Println(k, "is of a type I don't know how to handle")
}
}
通过上面的示例代码我们看到，我们就可以来访问结构不确定的JSON数据串。
##生成JSON
我们开发很多应用的时候，最后都是要输出JSON数据串，那么如何来处理呢？JSON包里面通过`Marshal`函数来处理，函数定义如下：
func Marshal(v interface{}) ([]byte, error)
假设我们还是需要生成上面的服务器列表信息，那么如何来处理呢？请看下面的例子：
package main
import (
"encoding/json"
"fmt"
)
type Server struct {
ServerName string
ServerIP string
}
type Serverslice struct {
Servers []Server
}
func main() {
var s Serverslice
s.Servers = append(s.Servers, Server{ServerName: "Shanghai_VPN", ServerIP: "127.0.0.1"})
s.Servers = append(s.Servers, Server{ServerName: "Beijing_VPN", ServerIP: "127.0.0.2"})
b, err := json.Marshal(s)
if err != nil {
fmt.Println("json err:", err)
}
fmt.Println(string(b))
}
输出如下内容：
{"Servers":[{"ServerName":"Shanghai_VPN","ServerIP":"127.0.0.1"},{"ServerName":"Beijing_VPN","ServerIP":"127.0.0.2"}]}
我们看到上面的输出字段名都是大写的，如果你想用小写的怎么办呢？把结构体的字段名改成小写的？JSON输出的时候必须注意，只有导出的字段才会被输出，如果修改字段名，那么就会发现什么都不会输出，所以必须通过struct tag定义来实现：
type Server struct {
ServerName string `json:"serverName"`
ServerIP string `json:"serverIP"`
}
type Serverslice struct {
Servers []Server `json:"servers"`
}
通过修改上面的结构体定义，这样输出的JSON串和我们最开始定义的JSON串就保持一模一样了。
针对JSON的输出我们struct tag的定义需要注意一下几点设置：
- tag中带有`"-"`，那么这个字段不会输出到JSON
- tag中带有自定义名称，那么这个自定义名称会出现在JSON的字段名中，例如上面例子中serverName
- tag中如果带有`"omitempty"`，那么如果该字段值为空，就不会输出到JSON串中
- 如果字段类型是int，而tag中带有`"string"`，那么这个字段在输出到JSON的时候会把该字段对应的值转换成JSON字符串
Marshal函数只有在转换成功的时候才会返回数据，在转换的过程中我们需要注意几点：
- JSON对象只支持string作为key，所以要编码一个map，那么必须是map[string]T这种类型(T是Go语言中任意的类型)
- Channel, complex和function是不能被编码成JSON的
- 嵌套的数据是不能编码的，不然会让JSON编码进入死循环
- 指针在编码的时候会输出指针指向的内容，而空指针会输出null
通过上面这个讲解，我们了解了如何使用Go语言的标准包里面的JSON来进行编解JSON数据，同时介绍了第三方包`go-simplejson`如何方便的操作JSON数据，这个对于我们接下来的Web开发相当重要。
## links
* [目录](<preface.md>)
* 上一节: [XML处理](<7.1.md>)
* 下一节: [正则处理](<7.3.md>)
## LastModified
* $Id$ * $Id$