go 调用http接口代码示例

下面是 Go 语言调用 HTTP 接口的代码示例：

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("https://www.example.com")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println(string(body))
}

上面的代码使用了 Go 自带的 `net/http` 包，通过调用 `http.Get` 函数获取了一个 URL 对应的 HTTP 响应。然后，使用 `ioutil.ReadAll` 函数读取了响应的内容并打印到控制台。

相关问题

go语言多线程调用分页接口

首先，需要先明确需要调用的分页接口的具体请求参数和返回值。假设我们要调用的分页接口请求参数为 `page` 和 `size`，返回值为一个包含多个数据项的 JSON 数组。

接下来，我们可以使用 Go 语言内置的 `sync` 包来实现多线程调用分页接口。具体步骤如下：

1. 创建一个等待所有线程完成的 `WaitGroup` 对象。

var wg sync.WaitGroup

2. 定义一个结构体来存储每个线程需要的参数。

type ThreadParams struct {
    Page int
    Size int
}

3. 定义一个函数来执行每个线程的具体任务，该函数需要接收一个 `ThreadParams` 参数，并在完成任务后将 `WaitGroup` 对象中的计数器减一。

func getPage(params ThreadParams) {
    defer wg.Done()

    // 构造请求参数
    reqParams := url.Values{}
    reqParams.Set("page", strconv.Itoa(params.Page))
    reqParams.Set("size", strconv.Itoa(params.Size))

    // 发送 HTTP 请求获取数据
    resp, err := http.Get("https://example.com/api?" + reqParams.Encode())
    if err != nil {
        log.Println(err)
        return
    }

    // 解析 JSON 响应
    defer resp.Body.Close()
    var data []interface{}
    err = json.NewDecoder(resp.Body).Decode(&data)
    if err != nil {
        log.Println(err)
        return
    }

    // 处理数据
    for _, item := range data {
        // TODO: 处理数据项
    }
}

4. 创建多个线程，并将每个线程的参数传递给 `getPage` 函数。

pageSize := 10
totalPages := 5

for i := 1; i <= totalPages; i++ {
    wg.Add(1)
    go getPage(ThreadParams{Page: i, Size: pageSize})
}

5. 等待所有线程完成。

wg.Wait()

完整代码示例：

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "net/url"
    "strconv"
    "sync"
)

type ThreadParams struct {
    Page int
    Size int
}

func getPage(params ThreadParams) {
    defer wg.Done()

    // 构造请求参数
    reqParams := url.Values{}
    reqParams.Set("page", strconv.Itoa(params.Page))
    reqParams.Set("size", strconv.Itoa(params.Size))

    // 发送 HTTP 请求获取数据
    resp, err := http.Get("https://example.com/api?" + reqParams.Encode())
    if err != nil {
        log.Println(err)
        return
    }

    // 解析 JSON 响应
    defer resp.Body.Close()
    var data []interface{}
    err = json.NewDecoder(resp.Body).Decode(&data)
    if err != nil {
        log.Println(err)
        return
    }

    // 处理数据
    for _, item := range data {
        // TODO: 处理数据项
    }
}

var wg sync.WaitGroup

func main() {
    pageSize := 10
    totalPages := 5

    for i := 1; i <= totalPages; i++ {
        wg.Add(1)
        go getPage(ThreadParams{Page: i, Size: pageSize})
    }

    wg.Wait()
}

go如何调用restful接口

在 Go 中，可以使用标准库中的 `net/http` 包来调用 RESTful 接口。具体步骤如下：

1. 创建一个 `http.Client` 实例，该实例可以发送 HTTP 请求并处理响应。

client := &http.Client{}

2. 创建一个 `http.Request` 实例，该实例包含 HTTP 请求的信息，例如 URL、HTTP 方法、请求头、请求体等。

req, err := http.NewRequest("GET", "https://example.com/api/users", nil)
if err != nil {
    log.Fatal(err)
}

3. 可选步骤：设置请求头信息。

req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer <your_access_token>")

4. 发送 HTTP 请求并获取响应。

resp, err := client.Do(req)
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

5. 读取响应体的内容。

body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(body))

完整的示例代码如下：

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

func main() {
	client := &http.Client{}

	req, err := http.NewRequest("GET", "https://example.com/api/users", nil)
	if err != nil {
		log.Fatal(err)
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer <your_access_token>")

	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(body))
}