# goChainRestfulClient

**Repository Path**: hexug/go-chain-restful-client

## Basic Information

- **Project Name**: goChainRestfulClient
- **Description**: 一个易用的go语言http客户端
是对标准库net/http的二次封装
- **Primary Language**: Go
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-06-24
- **Last Updated**: 2024-10-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Go语言

## README

# 对标准库中的http进行二次封装
  
  欲达到的效果是链式设置request请求的各个参数，以及发起请求
  
# 使用

[请求例子](./rest/rest_test.go)

## 示例响应数据结构体

```go
type Data struct {
	Args    map[string]any    `json:"args"`
	Data    string            `json:"data"`
	Files   map[string]string `json:"files"`
	Form    map[string]string `json:"form"`
	Headers map[string]string `json:"headers"`
	Json    any               `json:"json"`
	Origin  string            `json:"origin"`
	URL     string            `json:"url"`
}
```

## 示例请求地址

```go
var (
	url = "http://192.168.140.3:8000"
	ctx = context.Background()
)
```

## 基础请求

```go
func main() {
    var data Data
    c := rest.NewDefaultClient()
    c.SetTimeout(time.Second * 5)
    err := c.SetBaseURL(url).
		SetBasicAuth("abc", "bbb").
		Post("post").
		Param("abc", "ccc").
		Do(ctx).
		Into(&data)
    if err != nil {
		fmt.Println(err.Error())
		return
    }
    fmt.Println("args: ", data.Args)
    fmt.Println("data部分：", data.Data)
    fmt.Println("文件部分：", data.Files)
    fmt.Println("表单部分：", data.Form)
    fmt.Println("头部份：", data.Headers)
    fmt.Println("json部分：", data.Json)
    fmt.Println("origin部分：", data.Origin)
    fmt.Println("url部分：", data.URL)
}
```

这是一个简单的请求，其中：
+ 设置了基础url
+ 请求方法为post
+ 请求参数为abc=ccc
+ 请求头为abc:bbb
+ 响应数据为data结构体
+ 请求超时时间为5秒

请求发起后，将响应数据解析到data结构体中。

> 注意：
> 请求是自带日志的，这里的日志等级是debug

## 设置日志等级

```go
func main() {
    var data Data
	// 设置日志等级为info
    c := rest.NewLogLevelClient(logger.INFO)
    err := c.SetBaseURL(url).
		SetBasicAuth("abc", "bbb").
		Post("post").
		Do(ctx).
		Into(&data)
    if err != nil {
		fmt.Println(err.Error())
    }
}
```
或者

```go
func main() {
    var data Data
    c := rest.NewDefaultClient() 
	// 设置日志等级为info
    err := c.SetLogLevel(logger.DEBUG).
		SetBaseURL(url).
		SetBasicAuth("abc", "bbb").
		Post("post").
		Do(ctx).
		Into(&data)
    if err != nil {
		fmt.Println(err.Error())
    }
}
```

第一种设置是在创建客户端的时候设置，这种是设置全局的日志等级
第二种设置是在请求的时候设置，这种是设置单个请求的日志等级，更加灵活。

## Get请求

```go
func main() {
	c := rest.NewLogLevelClient(logger.INFO)
	resp := c.SetBaseURL(url).
		Get("/get").
		Header("aaa", "b").
		Param("aaa", "ccc").
		Param("aaa", "bbb").
		Do(ctx)
	if resp.Error() != nil {
		fmt.Println(resp.Error().Error())
		return
	}
	data := new(Data)
	err := resp.Into(data)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println(resp.StatusCode())
	fmt.Println("args: ", data.Args)
	fmt.Println("data部分：", data.Data)
	fmt.Println("文件部分：", data.Files)
	fmt.Println("表单部分：", data.Form)
	fmt.Println("头部分：")
	for k, v := range data.Headers {
		fmt.Printf("\t%s = %s\n", k, v)
	}
	fmt.Println("json部分：", data.Json)
	fmt.Println("origin部分：", data.Origin)
	fmt.Println("url部分：", data.URL)
	/*
		200
		args:  map[aaa:[ccc bbb]]
		data部分：
		文件部分： map[]
		表单部分： map[]
		头部分：
			Host = 10.0.0.12:8000
			User-Agent = go-chain-restful-client/1.0
			Accept-Encoding = gzip
		json部分： <nil>
		origin部分： 10.0.0.1
		url部分： http://10.0.0.12:8000/get
	*/
}
```