Go语言与API客户端交互

天涯学馆
更新于 2天前
阅读 126

目录RESTFulGraphQLRESTFulRESTfulAPI简介定义：一种软件架构风格，设计用于利用HTTP协议进行通信。特点：无状态：每次请求包含所有信息。客户端-服务器模式：分离了用户界面与数据管理功能。缓存：提高性能。分层系统：简化架构，支持中间组件。G

## 目录

- [RESTFul](#RESTFul)
- [GraphQL](#GraphQL)
 
---

## RESTFul

### RESTful API简介

**定义**：一种软件架构风格，设计用于利用HTTP协议进行通信。

**特点**：
- 无状态：每次请求包含所有信息。
- 客户端-服务器模式：分离了用户界面与数据管理功能。
- 缓存：提高性能。
- 分层系统：简化架构，支持中间组件。

### Go语言基础

- 安装Go环境：确保已安装Go并配置好环境变量。
- 基本语法：熟悉Go的基本语法，如变量声明、控制结构等。

### HTTP客户端库选择

- **标准库net/http**：轻量级，直接集成于Go标准库中。
- **第三方库如go-resty**：提供更多高级功能，如自动重试机制。

### 使用net/http创建客户端

```go
package main

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

func main() {
	// 发送GET请求
	resp, err := http.Get("http://example.com/api/data")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer resp.Body.Close()

// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading body:", err)
		return
	}

// 打印响应内容
	fmt.Println(string(body))
}
```

### 处理POST请求

```go
package main

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

type Payload struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

func main() {
	payload := Payload{
		Key:   "example",
		Value: "data",
	}

jsonPayload, _ := json.Marshal(payload)

resp, err := http.Post("http://example.com/api/data", "application/json", bytes.NewBuffer(jsonPayload))
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer resp.Body.Close()

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

fmt.Println(string(body))
}
```

### 错误处理与超时设置

```go
client := &http.Client{
    Timeout: time.Second * 10,
}

req, err := http.NewRequest("GET", "http://example.com/api/data", nil)
if err != nil {
    fmt.Println("Error creating request:", err)
    return
}

req.Header.Set("Authorization", "Bearer "+token)

resp, err := client.Do(req)
if err != nil {
    fmt.Println("Error sending request:", err)
    return
}
```

### 使用第三方库简化操作

安装go-resty:

```bash
go get github.com/go-resty/resty/v2
```

示例代码:

```go
package main

import (
    "github.com/go-resty/resty/v2"
    "fmt"
)

func main() {
    client := resty.New()

resp, err := client.R().
        SetHeader("Content-Type", "application/json").
        SetBody(map[string]string{"key": "example", "value": "data"}).
        Post("http://example.com/api/data")

if err != nil {
        fmt.Println("Error:", err)
        return
    }

fmt.Println(resp.String())
}
```

## GraphQL

### GraphQL客户端库选择

标准库不支持GraphQL：需要使用第三方库。

**常用库**：
- gql
- graphql-go
- graphql-client-go

### 使用graphql-client-go创建客户端

**安装库**：

```bash
go get github.com/graphql-go/graphql
go get github.com/99designs/gqlgen
```

### 创建简单的GraphQL客户端

```go
package main

import (
	"fmt"
	"log"

"github.com/99designs/gqlgen/client"
)

type Query struct{}

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

func (Query) User(id int) (*User, error) {
	return &User{ID: id, Name: "Alice"}, nil
}

func main() {
	// 创建GraphQL客户端
	gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

// 查询语句
	query := `
		query GetUser($id: Int!) {
			user(id: $id) {
				id
				name
			}
		}
	`

// 变量
	variables := map[string]interface{}{
		"id": 1,
	}

// 结果类型
	var result struct {
		User *User `json:"user"`
	}

// 发送查询
	err := gqlClient.Run(query, variables, &result)
	if err != nil {
		log.Fatalf("Error running query: %v", err)
	}

// 打印结果
	fmt.Printf("Result: %+v\n", result)
}
```

### 处理复杂查询

```go
package main

import (
	"fmt"
	"log"

"github.com/99designs/gqlgen/client"
)

type Query struct{}

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
	Posts []Post `json:"posts"`
}

type Post struct {
	ID   int    `json:"id"`
	Title string `json:"title"`
}

func (Query) User(id int) (*User, error) {
	user := &User{ID: id, Name: "Alice"}
	posts := []Post{{ID: 1, Title: "Post 1"}, {ID: 2, Title: "Post 2"}}
	user.Posts = posts
	return user, nil
}

func main() {
	// 创建GraphQL客户端
	gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

// 查询语句
	query := `
		query GetUser($id: Int!) {
			user(id: $id) {
				id
				name
				posts {
					id
					title
				}
			}
		}
	`

// 变量
	variables := map[string]interface{}{
		"id": 1,
	}

// 结果类型
	var result struct {
		User *User `json:"user"`
	}

// 发送查询
	err := gqlClient.Run(query, variables, &result)
	if err != nil {
		log.Fatalf("Error running query: %v", err)
	}

// 打印结果
	fmt.Printf("Result: %+v\n", result)
}
```

### 处理Mutation

```go
package main

import (
	"fmt"
	"log"

"github.com/99designs/gqlgen/client"
)

type Mutation struct{}

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

func (Mutation) CreateUser(name string) (*User, error) {
	return &User{ID: 1, Name: name}, nil
}

func main() {
	// 创建GraphQL客户端
	gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

// 查询语句
	mutation := `
		mutation CreateUser($name: String!) {
			createUser(name: $name) {
				id
				name
			}
		}
	`

// 变量
	variables := map[string]interface{}{
		"name": "Bob",
	}

// 结果类型
	var result struct {
		CreateUser *User `json:"createUser"`
	}

// 发送查询
	err := gqlClient.Run(mutation, variables, &result)
	if err != nil {
		log.Fatalf("Error running mutation: %v", err)
	}

// 打印结果
	fmt.Printf("Result: %+v\n", result)
}
```

### 错误处理与超时设置

```go
package main

import (
	"fmt"
	"log"
	"time"

"github.com/99designs/gqlgen/client"
)

func main() {
	// 创建GraphQL客户端
	gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

// 设置超时
	gqlClient.Timeout = 10 * time.Second

// 查询语句
	query := `
		query GetUser($id: Int!) {
			user(id: $id) {
				id
				name
			}
		}
	`

// 变量
	variables := map[string]interface{}{
		"id": 1,
	}

// 结果类型
	var result struct {
		User *User `json:"user"`
	}

// 发送查询
	err := gqlClient.Run(query, variables, &result)
	if err != nil {
		log.Fatalf("Error running query: %v", err)
	}

// 打印结果
	fmt.Printf("Result: %+v\n", result)
}
```

### 使用第三方库简化操作

**安装gql**：

```bash
go get github.com/graphql-go/graphql
go get github.com/vektah/gqlparser
```

**示例代码**：

```go
package main

import (
    "fmt"
    "log"
    "github.com/vektah/gqlparser/v2/parser"
    "github.com/vektah/gqlparser/v2/ast"
)

func main() {
    // 解析查询
    query := `
    query GetUser($id: Int!) {
      user(id: $id) {
        id
        name
      }
    }
    `
    parsedQuery, err := parser.ParseQuery(query)
    if err != nil {
        log.Fatalf("Error parsing query: %v", err)
    }

// 打印解析结果
    fmt.Printf("Parsed Query: %+v\n", parsedQuery)
}
```

RESTFul

RESTful API简介

定义：一种软件架构风格，设计用于利用HTTP协议进行通信。

特点：

无状态：每次请求包含所有信息。
客户端-服务器模式：分离了用户界面与数据管理功能。
缓存：提高性能。
分层系统：简化架构，支持中间组件。

Go语言基础

安装Go环境：确保已安装Go并配置好环境变量。
基本语法：熟悉Go的基本语法，如变量声明、控制结构等。

HTTP客户端库选择

标准库net/http：轻量级，直接集成于Go标准库中。
第三方库如go-resty：提供更多高级功能，如自动重试机制。

使用net/http创建客户端

package main

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

func main() {
    // 发送GET请求
    resp, err := http.Get("http://example.com/api/data")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    // 读取响应体
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading body:", err)
        return
    }

    // 打印响应内容
    fmt.Println(string(body))
}

处理POST请求

package main

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

type Payload struct {
    Key   string `json:"key"`
    Value string `json:"value"`
}

func main() {
    payload := Payload{
        Key:   "example",
        Value: "data",
    }

    jsonPayload, _ := json.Marshal(payload)

    resp, err := http.Post("http://example.com/api/data", "application/json", bytes.NewBuffer(jsonPayload))
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

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

    fmt.Println(string(body))
}

错误处理与超时设置

client := &http.Client{
    Timeout: time.Second * 10,
}

req, err := http.NewRequest("GET", "http://example.com/api/data", nil)
if err != nil {
    fmt.Println("Error creating request:", err)
    return
}

req.Header.Set("Authorization", "Bearer "+token)

resp, err := client.Do(req)
if err != nil {
    fmt.Println("Error sending request:", err)
    return
}

使用第三方库简化操作

安装go-resty:

go get github.com/go-resty/resty/v2

示例代码:

package main

import (
    "github.com/go-resty/resty/v2"
    "fmt"
)

func main() {
    client := resty.New()

    resp, err := client.R().
        SetHeader("Content-Type", "application/json").
        SetBody(map[string]string{"key": "example", "value": "data"}).
        Post("http://example.com/api/data")

    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println(resp.String())
}

GraphQL

GraphQL客户端库选择

标准库不支持GraphQL：需要使用第三方库。

常用库：

gql
graphql-go
graphql-client-go

使用graphql-client-go创建客户端

安装库：

go get github.com/graphql-go/graphql
go get github.com/99designs/gqlgen

创建简单的GraphQL客户端

package main

import (
    "fmt"
    "log"

    "github.com/99designs/gqlgen/client"
)

type Query struct{}

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func (Query) User(id int) (*User, error) {
    return &User{ID: id, Name: "Alice"}, nil
}

func main() {
    // 创建GraphQL客户端
    gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

    // 查询语句
    query := `
        query GetUser($id: Int!) {
            user(id: $id) {
                id
                name
            }
        }
    `

    // 变量
    variables := map[string]interface{}{
        "id": 1,
    }

    // 结果类型
    var result struct {
        User *User `json:"user"`
    }

    // 发送查询
    err := gqlClient.Run(query, variables, &result)
    if err != nil {
        log.Fatalf("Error running query: %v", err)
    }

    // 打印结果
    fmt.Printf("Result: %+v\n", result)
}

处理复杂查询

package main

import (
    "fmt"
    "log"

    "github.com/99designs/gqlgen/client"
)

type Query struct{}

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Posts []Post `json:"posts"`
}

type Post struct {
    ID   int    `json:"id"`
    Title string `json:"title"`
}

func (Query) User(id int) (*User, error) {
    user := &User{ID: id, Name: "Alice"}
    posts := []Post{{ID: 1, Title: "Post 1"}, {ID: 2, Title: "Post 2"}}
    user.Posts = posts
    return user, nil
}

func main() {
    // 创建GraphQL客户端
    gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

    // 查询语句
    query := `
        query GetUser($id: Int!) {
            user(id: $id) {
                id
                name
                posts {
                    id
                    title
                }
            }
        }
    `

    // 变量
    variables := map[string]interface{}{
        "id": 1,
    }

    // 结果类型
    var result struct {
        User *User `json:"user"`
    }

    // 发送查询
    err := gqlClient.Run(query, variables, &result)
    if err != nil {
        log.Fatalf("Error running query: %v", err)
    }

    // 打印结果
    fmt.Printf("Result: %+v\n", result)
}

处理Mutation

package main

import (
    "fmt"
    "log"

    "github.com/99designs/gqlgen/client"
)

type Mutation struct{}

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func (Mutation) CreateUser(name string) (*User, error) {
    return &User{ID: 1, Name: name}, nil
}

func main() {
    // 创建GraphQL客户端
    gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

    // 查询语句
    mutation := `
        mutation CreateUser($name: String!) {
            createUser(name: $name) {
                id
                name
            }
        }
    `

    // 变量
    variables := map[string]interface{}{
        "name": "Bob",
    }

    // 结果类型
    var result struct {
        CreateUser *User `json:"createUser"`
    }

    // 发送查询
    err := gqlClient.Run(mutation, variables, &result)
    if err != nil {
        log.Fatalf("Error running mutation: %v", err)
    }

    // 打印结果
    fmt.Printf("Result: %+v\n", result)
}

错误处理与超时设置

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/99designs/gqlgen/client"
)

func main() {
    // 创建GraphQL客户端
    gqlClient := client.NewHTTPClient("http://localhost:8080/graphql")

    // 设置超时
    gqlClient.Timeout = 10 * time.Second

    // 查询语句
    query := `
        query GetUser($id: Int!) {
            user(id: $id) {
                id
                name
            }
        }
    `

    // 变量
    variables := map[string]interface{}{
        "id": 1,
    }

    // 结果类型
    var result struct {
        User *User `json:"user"`
    }

    // 发送查询
    err := gqlClient.Run(query, variables, &result)
    if err != nil {
        log.Fatalf("Error running query: %v", err)
    }

    // 打印结果
    fmt.Printf("Result: %+v\n", result)
}

使用第三方库简化操作

安装gql：

go get github.com/graphql-go/graphql
go get github.com/vektah/gqlparser

示例代码：

package main

import (
    "fmt"
    "log"
    "github.com/vektah/gqlparser/v2/parser"
    "github.com/vektah/gqlparser/v2/ast"
)

func main() {
    // 解析查询
    query := `
    query GetUser($id: Int!) {
      user(id: $id) {
        id
        name
      }
    }
    `
    parsedQuery, err := parser.ParseQuery(query)
    if err != nil {
        log.Fatalf("Error parsing query: %v", err)
    }

    // 打印解析结果
    fmt.Printf("Parsed Query: %+v\n", parsedQuery)
}

原创
学分: 6
分类: Go
标签: Go语言

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

Go语言与API客户端交互

目录

RESTFul

RESTful API简介

Go语言基础

HTTP客户端库选择

使用net/http创建客户端

处理POST请求

错误处理与超时设置

使用第三方库简化操作

GraphQL

GraphQL客户端库选择

使用graphql-client-go创建客户端

创建简单的GraphQL客户端

处理复杂查询

处理Mutation

错误处理与超时设置

使用第三方库简化操作

0 条评论

专栏: Go语言开发基础到通关

文章目录