【菜鸟进击】初学golang——发送post请求/json

最新推荐文章于 2024-06-27 17:06:45 发布

猫大大大人

最新推荐文章于 2024-06-27 17:06:45 发布

阅读量2.6k

点赞数

CC 4.0 BY-SA版权

分类专栏：菜鸟学习

本文链接：https://blog.youkuaiyun.com/duke1237/article/details/87865618

菜鸟学习专栏收录该内容

1 篇文章

订阅专栏

本文介绍了Golang中与JSON处理相关的概念，包括使用Marshal进行数据编码成json字符串，Unmarshal进行解码，以及context设置超时时间。此外，还提到了Go的interface{}特性和函数与方法的区别。对于内存管理，讨论了切片与数组的关系，以及如何通过copy函数避免大数组的内存问题。最后，文章提及了defer关键字的用法以及Golang的单元测试。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

import (
    "fmt"
    "encoding/json"
    "bytes"
    "io/ioutil"
    "net/http"
    "github.com/angrygiraffe/go-log"
    "context"
)

type Foo struct{
    Size  int                    `json:"size"`
    Sort  map[string]interface{} `json:"sort"`
    Query map[string]interface{} `json:"query"`
}

type LogMsg struct{
    Took       int                    `json:"took"`
    Timed_out  bool                   `json:"timed_out"`
    Hits       map[string]interface{} `json:"hits"`
}


func getPostLog(ctx context.Context, api_url, txt, start_time, module string, size int)(string, error){
    queryobj := ""
    j := []byte(fmt.Sprintf(`
        {"size": %d ,
        "sort":{"@timestamp":"desc"},
        "query":{
                "bool":{
                        "must":[
                                {"match":{"kubernetes.labels.app":{"query":"%s","operator": "and"}}},
                                {"match":{"log":{"query":"%s","operator": "and"}}}
                                ],
                        "filter":{"range":{"@timestamp":{"gte": "%s"}}}
                        }
                }
        }`,size, module, txt, start_time))
    var f Foo
    json.Unmarshal(j, &f)
    byteData,_ := json.Marshal(&f)

    reader := bytes.NewReader(byteData)
    request, err := http.NewRequest("POST", api_url, reader)
    if err != nil {
        log.Errorf("http.NewRequest%v", err)
        return queryobj, err
    }
    request.Header.Set("Content-Type", "application/json;charset=UTF-8")
    client := http.Client{}
    resp, err := client.Do(request.WithContext(ctx))
    if err != nil {
        log.Errorf("client.Do%v", err)
        return queryobj, err
    }
    respBytes, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Errorf("ioutil.ReadAll%v", err)
        return queryobj, err
    }
    //import("unsafe")
    //byte数组直接转成string，优化内存
    //str := (*string)(unsafe.Pointer(&respBytes))

    var logmsg LogMsg
    json.Unmarshal(respBytes, &logmsg)
    hits, res := logmsg.Hits["hits"].([]interface{})
    if res == false{
        return queryobj, err
    }
    for i := 0; i < len(hits); i++{
        hit, res_hit := hits[i].(map[string]interface{})
        if res_hit == false{
            return queryobj, err
        }
        _source, res_source := hit["_source"].(map[string]interface{})
        if res_source == false{
            return queryobj, err
        }
        log := _source["log"]
        queryobj += fmt.Sprint(log)
    }
    return queryobj, nil
}

Marshal:将数据编码成json字符串

Unmarshal：将json字符串解码成对应数据格式

context：用来设置time_out时间

interface{}作为Go的重要特性之一，它代表的是一个类似*void的指针，可以指向不同类型的数据。

golang中函数和方法的区别：https://blog.youkuaiyun.com/d_guco/article/details/53575067

切片，数组：切片保留对底层数组的引用。只要切片存在于内存中，数组就不能被垃圾回收。假设我们有一个非常大的数组，而我们只需要处理它的一小部分，为此我们创建这个数组的一个切片，并处理这个切片。解决该问题的一个方法是使用 copy 函数 func copy(dst, src []T) int 来创建该切片的一个拷贝。这样我们就可以使用这个新的切片，原来的数组可以被垃圾回收。

defer

golang单元测试

import("testing")

func Test_Es(t *testing.T){}