后端开发总结（1）：前后端数据传输

Json(Javascript object Nantation)是一种数据交换格式，常用于前后端数据传输。任意一端将数据转换成json 字符串，另一端再将该字符串解析成相应的数据结构，如string，strcut对象等。在实际项目中，编码成json串的数据结构，往往是切片类型

文章参考 : https://blog.csdn.net/zxy_666/article/details/80173288

go对json格式的转化：https://go.dev/blog/json

1 后端——>前端

go语言本身为我们提供了json的工具包”encoding/json”。参考：https://studyglang.com/articles/6742

1.1 Json Marshal

state := &entity.AddStateoptions{
   DeviceName:  "d11",
   Lngitude:   100.076690123,
   Latitude:    10.023512345,
   Altitude:    4000.023512345,
   Temperature: 30.123,
   Intensity:   1000.023,
}
bytes, err := json.Marshal(state) // 将struct转化成byte格式
//[]byte类型，转化成string类型便于查看
fmt.Println(string(bytes))
1
2
3
4
5
6
7
8
9
10
11

1.2 前后端交互的json输出规则

我们需要统一对外输出 json 信息

{
   "code": 5000,
   "message": "message",
   "data":""
}

1
2
3
4
5
6

后端需要利用web框架，如gin，在controller层向前端输出Json格式的返回结果

// gin.H就是一个map用以简化生成 json 的方式
// c.JSON(状态码，message)
c.JSON(http.StatusOK, gin.H{
            "code": 0,
            "message": "正常",
            "dataset": gin.H{
                "name": "测试接口"
            },
        })
1
2
3
4
5
6
7
8
9

code、message 大多数时候是默认值，只有在特定接口返回特定信息，可以对接口进行封装

package httprsp

// gin响应错误消息体封装
type GinErrorRsp struct {
	Code int64  `json:"code"`
	Msg  string `json:"msg"`
}

const (
	BadRequest int64 = 4000
	UnauthorizedRequest int64 = 4001
	InternalServerError int64 = 5000
)

var (
	// Ok OK
	Ok GinErrorRsp = GinErrorRsp{2000, "ok"}
	// Unauthorized 未授权请求
	Unauthorized GinErrorRsp = GinErrorRsp{4001, "unauthorized request"}
	// Forbidden 请求拒绝
	Forbidden GinErrorRsp = GinErrorRsp{4003, "forbidden"}
)

func NewRequestParamsErrorRsp() GinErrorRsp {
	return GinErrorRsp{
		BadRequest, "request params error",
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1.3 使用示例

func InfoTask(c *gin.Context) {
  // 接收前端传递参数  
   var req task.InfoTaskReq
  // 将参数与结构体进行绑定  
   if err := c.ShouldBind(&req); err != nil {
      log.Error(err.Error())
      // 绑定错误，直接返回 
      c.JSON(http.StatusBadRequest, httprsp.ParamsErrorRsp())
      return
   }
    
   res, err := 调用service层的逻辑得到返回
  // 如果后端返回参数与前端不一致，需要dto进一步加工  
   dto := assembler.ToTaskInfoDTO(params)
   if err != nil {
      c.JSON(http.StatusBadRequest, httprsp.NewBadRequestRsp(err.Error()))
      return
   }

    // 执行正常，将结果从后端传递给前端)
   c.JSON(http.StatusOK, common.NewCommonHttpRsp(dto))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2 前端——>后端

前端返回了结果回来，需要将结果进行解析，一则通过assembler转化成对应的结构体，另一则通过直接提取出需要的信息

// 对应接收通用数据的结构
type ResponseBody struct {
   Code int         `json:"code"` // 返回code 2000成功
   Msg  string      `json:"msg"`  // 返回提示
   Data interface{} `json:"data"` // 返回数据
}

func (resp ResponseBody) IsOk() bool {
   return resp.Code == 2000
}
1
2
3
4
5
6
7
8
9
10

转化的具体操作

response,err = 前端返回数据
if err := json.Unmarshal(response.Body(), &responseBody); err != nil {
   return err
}

// Unmarshal 解析 JSON 编码的数据并将结果存储在 v 指向的值中。
// 如果 v 为 nil 或不是指针，则 Unmarshal 返回 InvalidUnmarshalError
1
2
3
4
5
6
7