Go 学习笔记（7）：学习成果之写一个 API 调用的 sdk

import json
import requests


class PrivateAPI:
    def __init__(self, host, org, header_host):
        self.host = host
        self.org = org
        self.header_host = header_host

    def search_instances(self, object_id, data):
        api = f"/object/{object_id}/instance/_search"
        url = f"{self.host}{api}"

        # 将字典转成 JSON
        json_data = json.dumps(data)

        headers = {
            "user": "defaultUser",
            "org": self.org,
            "Host": self.header_host
        }

        # 发起 HTTP 请求
        response = requests.post(url, data=json_data, headers=headers)

        if response.status_code != 200:
            raise Exception("Status is not 200")

        # 解析 JSON 响应
        result = response.json()

        return result


def main():
    # 创建 PrivateAPI 实例
    api = PrivateAPI("http://127.0.0.1", "777777", "uat.api.com")

    # 调用 search_instances 方法发起查询请求
    try:
        ret = api.search_instances("HOST", {})
        print(ret)
    except Exception as e:
        print("Error:", e)


if __name__ == "__main__":
    main()

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

// PrivateAPI 定义API的，暴露环境参数
type PrivateAPI struct {
    host       string
    org        string
    headerHost string
}

// newPrivateAPI 是构造函数，用于实例化 PrivateAPI 结构体
func newPrivateAPI(host string, org string, headerHost string) *PrivateAPI {
    return &PrivateAPI{
        host:       host,
        org:        org,
        headerHost: headerHost,
    }
}

// searchInstances 是 PrivateAPI 结构体的方法，用于向私有API发起查询实例的请求
// objectId 表示对象ID，data 是查询参数的map
// 返回值是查询结果的map和可能的错误信息
func (pa *PrivateAPI) searchInstances(objectId string, data map[string]interface{}) (map[string]interface{}, error) {
    // 构造 API 请求的路径
    api := fmt.Sprintf("/object/%s/instance/_search", objectId)
    // 构造完整的请求 URL
    url := fmt.Sprintf("%s%s", pa.host, api)

    // 将查询参数 map 转成 JSON 格式
    bytesData, err := json.Marshal(data)
    if err != nil {
        return nil, fmt.Errorf("map to json error: %s", err)
    }

    // 创建 HTTP 请求对象
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(bytesData))
    if err != nil {
        return nil, fmt.Errorf("http req error: %s", err)
    }

    // 设置请求头信息
    req.Header.Set("user", "defaultUser")
    req.Header.Set("org", pa.org)

    req.Host = pa.headerHost

    // 创建 HTTP 客户端并发送请求
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("http get resp error: %s", err)
    }

    // 断开连接
    defer resp.Body.Close()

    // 检查响应状态码是否为 200
    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("status is not 200")
    }

    // 读取响应体的内容
    bytesResponse, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("read resp error: %s", err)
    }

    // 将响应体内容解析为 map
    var result map[string]interface{}
    nok := json.Unmarshal(bytesResponse, &result)
    if nok != nil {
        return nil, fmt.Errorf("json to map error: %s", nok)
    }

    return result, nil
}

func main() {
    // 创建 PrivateAPI 实例
    api := newPrivateAPI("http://127.0.0.1", "777777", "uat.api.com")

    // 调用 searchInstances 方法发起查询请求
    ret, err := api.searchInstances("HOST", map[string]interface{}{})
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // 打印查询结果
    fmt.Println(ret)
}

// 错误的设置方式，不会生效
req.Header.Set("Host", "xxx")

// 正确方式
req.Host = "xxx"

defer resp.Body.Close()