JSON反序列化Int64类型
JSON在序列化结构体的时候，如果结构体中包含Int64类型的数值类型，序列号之后会导致int64类型变成float64类型，因为JSON里面没有int64。因此导致序列号之后的数值不正确。如果反序列化用map[string]interface{}接，会得到浮点型数据。
type number struct {
N int64
}
func main() {
s := number{29882837987845}
marshal, _ := json.Marshal(s)
var r map[string]interface{}
json.Unmarshal(marshal, &r)
fmt.Println(r) //map[N:2.9882837987845e+13]
}
正确处理方式：
func main() {
s := number{29882837987845}
marshal, _ := json.Marshal(s)
decoder := json.NewDecoder(bytes.NewReader(marshal))
decoder.UseNumber()
var r map[string]interface{}
decoder.Decode(&r)
fmt.Println(r) //map[N:29882837987845]
}
匿名函数共用参数，结果不正确
func main() {
var wg sync.WaitGroup
for i := 0; i< 10; i++ {
go func() {
wg.Add(1)
defer wg.Done()
fmt.Println(i)
}()
}
wg.Wait()
}
以上打印结果会随机：
7
10
10
10
10
10
这里写错的原因是所有的go协程都共用了i变量导致，协程被调度切换导致结果不确定。
正确写法：
func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
go func(i int) {
wg.Add(1)
defer wg.Done()
fmt.Println(i)
}(i)
}
wg.Wait()
}
map未初始化，导致panic:
func main() {
var m map[string]int
m["s"] = 1
fmt.Println(m["s"])
}
正确写法：
func main() {
var m = make(map[string]int)
m["s"] = 1
fmt.Println(m["s"])
}
注意：可以使用len函数获取map的长度，但是不能用cap获取map的容量。
grpc服务端实现接口函数时，返回类型为*emptypb.Empty指针类型，不能返回nil。
func (ds *Server) Update(ctx context.Context, req *devRPC.Update) (*emptypb.Empty, error) {
for _, dev := range req.UpdateDes {
devDTO := dtos.FromRpcToUpdateDev(dev)
err := application.PatchDev(ctx, devDTO, ds.dic)
if err != nil {
return nil, errors.ConvertEdgeXErrToRpc(err)
}
}
return nil, nil
}
备注：使用nil，在序列号和反序列化中，会错误结果。
正确写法：
func (ds *Server) Update(ctx context.Context, req *devRPC.Update) (*emptypb.Empty, error) {
for _, dev := range req.UpdateDevs {
devDTO := dtos.FromRpcToUpdateDev(dev)
err := application.PatchDev(ctx, devDTO, ds.dic)
if err != nil {
return &emptypb.Empty{}, errors.ConvertEdgeXErrToRpc(err)
}
}
return &emptypb.Empty{}, nil
}
HTTP响应未正确关闭
func main() {
resp, err := http.Get("https://api.ipify.org?format=json")
defer resp.Body.Close()//可能发生panic
if err != nil {
fmt.Println(err)
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
如果resp的值nil的话，resp.Body.Close()会导致panic。
正确的写法：
func main() {
resp, err := http.Get("https://api1.ipify.org?format=json")
if err != nil {
fmt.Println(err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
在http.Get返回错误检查过后，再调用defer就不会panic。
HTTP响应关闭正确做法
前面的做法还不是很周全，如果http.Get获取的是一个重定向过的结果，err和resp都不是nil，也会导致resp未关闭。最好还是对resp做判断：
resp, err := http.Get("https://api1.ipify.org?format=json")
if resp != nil {
defer resp.Body.Close()
}
if err != nil {
fmt.Println(err)
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
关闭HTTP连接
默认情况下，标准http库只在目标HTTP服务器要求关闭时才会关闭网络连接。这意味着你的应用在某些条件下会消耗完sockets/file的文件描述符。
你可以通过设置请求变量中的Close域的值为true，来让http库在请求完成时关闭连接。
另一个选项是添加一个Connection的请求头，并设置为close。目标HTTP服务器应该也会响应一个Connection: close的头。当http库看到这个响应头时，它也将会关闭连接。
func main() {
req, err := http.NewRequest("GET","http://golang.org",nil)
if err != nil {
fmt.Println(err)
return
}
req.Close = true
//也可以使用下面方式
//req.Header.Add("Connection", "close")
resp, err := http.DefaultClient.Do(req)
if resp != nil {
defer resp.Body.Close()
}
if err != nil {
fmt.Println(err)
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(len(string(body)))
}
备注：如果你向同一个HTTP服务器发送大量的请求，那么把保持网络连接的打开是没问题的。然而，如果你的应用在短时间内向大量不同的HTTP服务器发送一两个请求，那么在引用收到响应后立刻关闭网络连接是一个好主意。增加打开文件的限制数可能也是个好主意。当然，正确的选择源自于应用。
recover只能直接在defer函数内有效
func doRecover() {
fmt.Println("recovered =>",recover()) //prints: recovered => <nil>
}
func main() {
defer func() {
doRecover() //panic is not recovered
}()
panic("not good")
}
上面的panic不能被捕获。
func main() {
defer func() {
fmt.Println("recovered:",recover())
}()
panic("not good")
}
