Golang 处理 Json(二):解码
本文内容纲要:
-定义结构
-stringtag
--tag
-动态解析
-Decode
-接口
-延迟解析
-不定字段解析
-接口配合断言
-混合结构
-json.RawMessage
-总结
golang编码json还比较简单,而解析json则非常蛋疼。不像PHP一句json_decode()就能搞定。之前项目开发中,为了兼容不同客户端的需求,请求的content-type可以是json,也可以是www-x-urlencode。然后某天前端希望某个后端服务提供json的处理,而当时后端使用java实现了www-x-urlencode的请求,对于突然希望提供json处理产生了极大的情绪。当时不太理解,现在看来,对于静态语言解析未知的JSON确实是一项挑战。
定义结构
与编码json的Marshal类似,解析json也提供了Unmarshal方法。对于解析json,也大致分两步,首先定义结构,然后调用Unmarshal方法序列化。我们先从简单的例子开始吧。
typeAccountstruct{
Emailstring`json:"email"`
Passwordstring`json:"password"`
Moneyfloat64`json:"money"`
}
varjsonStringstring=`{
"email":"phpgo@163.com",
"password":"123456",
"money":100.5
}`
funcmain(){
account:=Account{}
err:=json.Unmarshal([]byte(jsonString),&account)
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%+v\n",account)
}
输出:
{Email:phpgo@163.comPassword:123456Money:100.5}
Unmarshal接受一个byte数组和空接口指针的参数。和sql中读取数据类似,先定义一个数据实例,然后传其指针地址。
与编码类似,golang会将json的数据结构和go的数据结构进行匹配。匹配的原则就是寻找tag的相同的字段,然后查找字段。查询的时候是大小写不敏感的:
typeAccountstruct{
Emailstring`json:"email"`
PassWordstring
Moneyfloat64`json:"money"`
}
varjsonStringstring=`{
"email":"phpgo@163.com",
"password":"123456",
"money":100.5
}`
funcmain(){
account:=Account{}
err:=json.Unmarshal([]byte(jsonString),&account)
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%+v\n",account)
}
输出:
{Email:phpgo@163.comPassWord:123456Money:100.5}
把Password的tag去掉,再修改成PassWord,依然可以把json的password匹配到PassWord,但是如果结构的字段是私有的,即使tag符合,也不会被解析:
typeAccountstruct{
Emailstring`json:"email"`
passwordstring`json:"password"`
Moneyfloat64`json:"money"`
}
varjsonStringstring=`{
"email":"phpgo@163.com",
"password":"123456",
"money":100.5
}`
funcmain(){
account:=Account{}
err:=json.Unmarshal([]byte(jsonString),&account)
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%+v\n",account)
}
输出:
{Email:phpgo@163.compassword:Money:100.5}
上面的password并不会被解析赋值json的password,大小写不敏感只是针对公有字段而言。
再寻找tag或字段的时候匹配不成功,则会抛弃这个json字段的值:
typeAccountstruct{
Emailstring`json:"email"`
Passwordstring`json:"password"`
}
varjsonStringstring=`{
"email":"phpgo@163.com",
"password":"123456",
"money":100.5
}`
funcmain(){
account:=Account{}
err:=json.Unmarshal([]byte(jsonString),&account)
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%+v\n",account)
}
输出:
{Email:phpgo@163.comPassword:123456}
并不会有money字段被赋值。
stringtag
在编码的时候,我们使用tagstring,可以把结构定义的数字类型以字串形式编码。同样在解码的时候,只有字串类型的数字,才能被正确解析,否则会报错:
typeAccountstruct{
Emailstring`json:"email"`
Passwordstring`json:"password"`
Moneyfloat64`json:"money,string"`
}
varjsonStringstring=`{
"email":"phpgo@163.com",
"password":"123456",
"money":"100.5"//不能没有双引号,否则会报错
}`
funcmain(){
account:=Account{}
err:=json.Unmarshal([]byte(jsonString),&account)
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%+v\n",account)
}
输出:
{Email:phpgo@163.comPassword:123456Money:100.5}
Money是float64类型。
如果json的money是100.5
,会得到下面的错误:
2017/03/0817:39:21json:invaliduseof,stringstructtag,tryingtounmarshalunquotedvalueintofloat64
exitstatus1
-tag
与编码一样,tag的-
也不会被解析,但是会初始化其零值:
typeAccountstruct{
Emailstring`json:"email"`
Passwordstring`json:"password"`
Moneyfloat64`json:"-"`
}
varjsonStringstring=`{
"email":"phpgo@163.com",
"password":"123456",
"money":100.5
}`
funcmain(){
account:=Account{}
err:=json.Unmarshal([]byte(jsonString),&account)
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%+v\n",account)
}
输出:
{Email:phpgo@163.comPassword:123456Money:0}
稍微总结一下,解析json最好的方式就是定义与将要被解析json的结构。有人写了一个小工具json-to-go,自动将json格式化成golang的结构。
动态解析
通常根据json的格式预先定义golang的结构进行解析是最理想的情况。可是实际开发中,理想的情况往往都存在理想的愿望之中,很多json非但格式不确定,有的还可能是动态数据类型。
例如通常登录的时候,往往既可以使用手机号做用户名,也可以使用邮件做用户名,客户端传的json可以是字串,也可以是数字。此时服务端解析就需要技巧了。
Decode
前面我们使用了简单的方法Unmarshal直接解析json字串,下面我们使用更底层的方法NewDecode和Decode方法。
packagemain
import(
"encoding/json"
"fmt"
"io"
"log"
"strings"
)
typeUserstruct{
UserNamestring`json:"username"`
Passwordstring`json:"password"`
}
varjsonStringstring=`{
"username":"phpgo@163.com",
"password":"123"
}`
funcDecode(rio.Reader)(u*User,errerror){
u=new(User)
err=json.NewDecoder(r).Decode(u)
iferr!=nil{
return
}
return
}
funcmain(){
user,err:=Decode(strings.NewReader(jsonString))
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%#v\n",user)
}
输出:
&main.User{UserName:"phpgo@163.com",Password:"123"}
我们定义了一个Decode函数,在这个函数进行json字串的解析。然后调用json的NewDecoder方法构造一个Decode对象,最后使用这个对象的Decode方法赋值给定义好的结构对象。
对于字串,可是使用strings.NewReader方法,让字串变成一个Stream对象。
接口
如果客户端传的username的值是一个数字类型的手机号,那么上面的解析方法将会失败。正如我们之前所介绍的动态类型行为一样,使用空接口可以hold住这样的情景。
typeUserstruct{
UserNameinterface{}`json:"username"`
Passwordstring`json:"password"`
}
varjsonStringstring=`{
"username":15899758289,
"password":"123"
}`
funcDecode(rio.Reader)(u*User,errerror){
u=new(User)
err=json.NewDecoder(r).Decode(u)
iferr!=nil{
return
}
return
}
funcmain(){
user,err:=Decode(strings.NewReader(jsonString))
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%#v\n",user)
}
输出:
&main.User{UserName:1.5899758289e+10,Password:"123"}
貌似成功了,可是返回的数字是科学计数法,有点奇怪。可以使用golang的断言,然后转换类型:
typeUserstruct{
UserNameinterface{}`json:"username"`
Passwordstring`json:"password"`
}
varjsonStringstring=`{
"username":15899758289,
"password":"123"
}`
funcDecode(rio.Reader)(u*User,errerror){
u=new(User)
iferr=json.NewDecoder(r).Decode(u);err!=nil{
return
}
switcht:=u.UserName.(type){
casestring:
u.UserName=t
casefloat64:
u.UserName=int64(t)
}
return
}
funcmain(){
user,err:=Decode(strings.NewReader(jsonString))
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%#v\n",user)
}
输出:
&main.User{UserName:15899758289,Password:"123"}
看起来挺好,可是我们的UserName字段始终是一个空接口,使用他的时候,还是需要转换类型,这样情况看来,解析的时候就应该转换好类型,那么用的时候就省心了。
修改定义的结构如下:
typeUserstruct{
UserNameinterface{}`json:"username"`
Passwordstring`json:"password"`
Emailstring
Phoneint64
}
这样就能通过fmt.Println(user.Email+"addme")
使用字段进行操作了。当然也有人认为Email和Phone纯粹多于,因为使用的时候,还是需要再判断当前结构实例是那种情况。
延迟解析
因为UserName字段,实际上是在使用的时候,才会用到他的具体类型,因此我们可以延迟解析。使用json.RawMessage方式,将json的字串继续以byte数组方式存在。
typeUserstruct{
UserNamejson.RawMessage`json:"username"`
Passwordstring`json:"password"`
Emailstring
Phoneint64
}
varjsonStringstring=`{
"username":"phpgo@163.com",
"password":"123"
}`
funcDecode(rio.Reader)(u*User,errerror){
u=new(User)
iferr=json.NewDecoder(r).Decode(u);err!=nil{
return
}
varemailstring
iferr=json.Unmarshal(u.UserName,&email);err==nil{
u.Email=email
return
}
varphoneint64
iferr=json.Unmarshal(u.UserName,&phone);err==nil{
u.Phone=phone
}
return
}
funcmain(){
user,err:=Decode(strings.NewReader(jsonString))
iferr!=nil{
log.Fatal(err)
}
fmt.Printf("%#v\n",user)
}
总体而言,延迟解析和使用空接口的方式类似。需要再次调用Unmarshal方法,对json.RawMessage进行解析。原理和解析到接口的形式类似。
不定字段解析
对于未知json结构的解析,不同的数据类型可以映射到接口或者使用延迟解析。有时候,会遇到json的数据字段都不一样的情况。例如需要解析下面一个json字串:
接口配合断言
varjsonStringstring=`{
"things":[
{
"name":"Alice",
"age":37
},
{
"city":"Ipoh",
"country":"Malaysia"
},
{
"name":"Bob",
"age":36
},
{
"city":"Northampton",
"country":"England"
}
]
}`
json字串的是一个对象,其中一个keythings的值是一个数组,这个数组的每一个item都未必一样,大致是两种数据结构,可以抽象为person和place。即,定义下面的结构体:
typePersonstruct{
Namestring`json:"name"`
Ageint`json:"age"`
}
typePlacestruct{
Citystring`json:"city"`
Countrystring`json:"country"`
}
接下来我们Unmarshaljson字串到一个map结构,然后迭代item并使用type断言的方式解析数据:
funcdecode(jsonStr[]byte)(persons[]Person,places[]Place){
vardatamap[string][]map[string]interface{}
err:=json.Unmarshal(jsonStr,&data)
iferr!=nil{
fmt.Println(err)
return
}
fori:=rangedata["things"]{
item:=data["things"][i]
ifitem["name"]!=nil{
persons=addPerson(persons,item)
}else{
places=addPlace(places,item)
}
}
return
}
迭代的时候会判断item是否是person还是place,然后调用对应的解析方法:
funcaddPerson(persons[]Person,itemmap[string]interface{})[]Person{
name:=item["name"].(string)
age:=item["age"].(float64)
person:=Person{name,int(age)}
persons=append(persons,person)
returnpersons
}
funcaddPlace(places[]Place,itemmap[string]interface{})[]Place{
city:=item["city"].(string)
country:=item["country"].(string)
place:=Place{City:city,Country:country}
places=append(places,place)
returnplaces
}
代码汇总:
typePersonstruct{
Namestring`json:"name"`
Ageint`json:"age"`
}
typePlacestruct{
Citystring`json:"city"`
Countrystring`json:"country"`
}
funcdecode(jsonStr[]byte)(persons[]Person,places[]Place){
vardatamap[string][]map[string]interface{}
err:=json.Unmarshal(jsonStr,&data)
iferr!=nil{
fmt.Println(err)
return
}
fori:=rangedata["things"]{
item:=data["things"][i]
ifitem["name"]!=nil{
persons=addPerson(persons,item)
}else{
places=addPlace(places,item)
}
}
return
}
funcaddPerson(persons[]Person,itemmap[string]interface{})[]Person{
name:=item["name"].(string)
age:=item["age"].(float64)
person:=Person{name,int(age)}
persons=append(persons,person)
returnpersons
}
funcaddPlace(places[]Place,itemmap[string]interface{})[]Place{
city:=item["city"].(string)
country:=item["country"].(string)
place:=Place{City:city,Country:country}
places=append(places,place)
returnplaces
}
varjsonStringstring=`{
"things":[
{
"name":"Alice",
"age":37
},
{
"city":"Ipoh",
"country":"Malaysia"
},
{
"name":"Bob",
"age":36
},
{
"city":"Northampton",
"country":"England"
}
]
}`
funcmain(){
personA,placeA:=decode([]byte(jsonString))
fmt.Printf("%+v\n",personA)
fmt.Printf("%+v\n",placeA)
}
输出:
[{Name:AliceAge:37}{Name:BobAge:36}]
[{City:IpohCountry:Malaysia}{City:NorthamptonCountry:England}]
混合结构
混合结构很好理解,如同我们前面解析username为email和phone两种情况,就在结构中定义好这两种结构即可。
typeMixedstruct{
Namestring`json:"name"`
Ageint`json:"age"`
citystring`json:"city"`
Countrystring`json:"country"`
}
混合结构的思路很简单,借助golang会初始化没有匹配的json和抛弃没有匹配的json,给特定的字段赋值。比如每一个item都具有四个字段,只不过有的会匹配person的json数据,有的则是匹配place。没有匹配的字段则是零值。接下来在根据item的具体情况,分别赋值到对于的Person或Place结构。
typePersonstruct{
Namestring`json:"name"`
Ageint`json:"age"`
}
typePlacestruct{
Citystring`json:"city"`
Countrystring`json:"country"`
}
typeMixedstruct{
Namestring`json:"name"`
Ageint`json:"age"`
citystring`json:"city"`
Countrystring`json:"country"`
}
funcdecode(jsonStr[]byte)(persons[]Person,places[]Place){
vardatamap[string][]Mixed
err:=json.Unmarshal(jsonStr,&data)
iferr!=nil{
fmt.Println(err)
return
}
fmt.Printf("%+v\n",data["things"])
fori:=rangedata["things"]{
item:=data["things"][i]
ifitem.Name!=""{
persons=append(persons,Person{Name:item.Name,Age:item.Age})
}else{
places=append(places,Place{City:item.city,Country:item.Country})
}
}
return
}
varjsonStringstring=`{
"things":[
{
"name":"Alice",
"age":37
},
{
"city":"Ipoh",
"country":"Malaysia"
},
{
"name":"Bob",
"age":36
},
{
"city":"Northampton",
"country":"England"
}
]
}`
funcmain(){
personA,placeA:=decode([]byte(jsonString))
fmt.Printf("%+v\n",personA)
fmt.Printf("%+v\n",placeA)
}
输出:
[{Name:AliceAge:37city:Country:}{Name:Age:0city:Country:Malaysia}{Name:BobAge:36city:Country:}{Name:Age:0city:Country:England}]
[{Name:AliceAge:37}{Name:BobAge:36}]
[{City:Country:Malaysia}{City:Country:England}]
混合结构的解析方式也很不错。思路还是借助了解析json中抛弃不要的字段,借助零值处理。
json.RawMessage
json.RawMessage非常有用,延迟解析也可以使用这个样例。我们已经介绍过类似的技巧,下面就贴代码了:
typePersonstruct{
Namestring`json:"name"`
Ageint`json:"age"`
}
typePlacestruct{
Citystring`json:"city"`
Countrystring`json:"country"`
}
funcaddPerson(itemjson.RawMessage,persons[]Person)([]Person){
person:=Person{}
iferr:=json.Unmarshal(item,&person);err!=nil{
fmt.Println(err)
}else{
ifperson!=*new(Person){
persons=append(persons,person)
}
}
returnpersons
}
funcaddPlace(itemjson.RawMessage,places[]Place)([]Place){
place:=Place{}
iferr:=json.Unmarshal(item,&place);err!=nil{
fmt.Println(err)
}else{
ifplace!=*new(Place){
places=append(places,place)
}
}
returnplaces
}
funcdecode(jsonStr[]byte)(persons[]Person,places[]Place){
vardatamap[string][]json.RawMessage
err:=json.Unmarshal(jsonStr,&data)
iferr!=nil{
fmt.Println(err)
return
}
for_,item:=rangedata["things"]{
persons=addPerson(item,persons)
places=addPlace(item,places)
}
return
}
varjsonStringstring=`{
"things":[
{
"name":"Alice",
"age":37
},
{
"city":"Ipoh",
"country":"Malaysia"
},
{
"name":"Bob",
"age":36
},
{
"city":"Northampton",
"country":"England"
}
]
}`
funcmain(){
personA,placeA:=decode([]byte(jsonString))
fmt.Printf("%+v\n",personA)
fmt.Printf("%+v\n",placeA)
}
输出:
[{Name:AliceAge:37}{Name:BobAge:36}]
[{City:IpohCountry:Malaysia}{City:NorthamptonCountry:England}]
把things的item数组解析成一个json.RawMessage,然后再定义其他结构逐步解析。上述这些例子其实在真实的开发环境下,应该尽量避免。像person或是place这样的数据,可以定义两个数组分别存储他们,这样就方便很多。不管怎么样,通过这个略傻的例子,我们也知道了如何解析json数据。
总结
关于golang解析json的介绍基本就这么多。想要解析越简单,就需要定义越明确的map结构。面对无法确定的数据结构或类型,再动态解析方面可以借助接口与断言的方式解析,也可以使json.RawMessage延迟解析。具体使用情况,还得考虑实际的需求和应用场景。
总而言之,使用json作为现在api的数据通信方式已经很普遍了。
相关文章
Golang处理Json(一):编码
Golang处理Json(二):解码
参考:
http://json.org/
http://www.jianshu.com/p/31757e530144
https://golang.org/pkg/encoding/json/
本文内容总结:定义结构,stringtag,-tag,动态解析,Decode,接口,延迟解析,不定字段解析,接口配合断言,混合结构,json.RawMessage,总结,
原文链接:https://www.cnblogs.com/52php/p/6518728.html