财富管理模块自用的内部请求工具包

博主： JIeJaitt
发布时间：2024 年 07 月 13 日
80 次浏览
暂无评论
10058字数
分类：还没写好

阅读一下下面的代码，并且向我解释：

```go
type client struct {
	requester requester.Requester
}

func (c client) ExchangeRates(ctx context.Context, params mapping.ExchangeRateParams) (*mapping.ExchangeRateResult, error) {
	ret := &mapping.ExchangeRateResult{}
	r := template.RequestTemplate{
		HttpClient:  c.requester,
		RequestUrl:  constant.URLExchangeRate,
		ReqParam:    params,
		RspResult:   ret,
		ErrorHandle: template.DefaultErrorHandle,
	}

return ret, r.DoPost(ctx)
}
```

这段代码定义了一个 `client` 结构体及其方法 `ExchangeRates`。让我为您解释这段代码的主要部分：

1. 结构体定义：

```go
type client struct {
	requester requester.Requester
}
```

这定义了一个名为 `client` 的结构体，它有一个字段 `requester`，类型为 `requester.Requester`。这可能是一个用于发送 HTTP 请求的接口或结构体。

2. 方法定义：

```go
func (c client) ExchangeRates(ctx context.Context, params mapping.ExchangeRateParams) (*mapping.ExchangeRateResult, error)
```

这是 `client` 结构体的一个方法，名为 `ExchangeRates`。它接受一个上下文 `ctx` 和 `params` 参数，返回一个指向 `mapping.ExchangeRateResult` 的指针和一个错误。

3. 方法实现：
   - 创建一个 `mapping.ExchangeRateResult` 的指针 `ret`。
   - 构造一个 `template.RequestTemplate` 结构体 `r`，包含了执行请求所需的各种信息。
   - 使用 `r.DoPost(ctx)` 发送 POST 请求，并返回结果和可能的错误。

这个方法似乎是用来获取汇率信息的。它使用了一个模板化的请求结构来简化 HTTP 请求的发送过程。

是否需要我进一步解释代码中的某些具体部分？

## requester 包

```go
package requester

import (
	"context"
	"net/http"
	"strings"
	"time"

"github.com/go-resty/resty/v2"
	"github.com/pkg/errors"
	"gl.fotechwealth.com.local/backend/trade-lib.git/contexthelper"

"trade/internal/common/apmtrace"
	commonconstant "trade/internal/common/constant"
	"trade/pkg/utils"
)

// var ErrNotOK = stderr.New("status not ok")
//
// func IsStatusNotOK(err error) bool {
// 	return errors.Is(err, ErrNotOK)
// }

//go:generate mockery --name Requester --filename requester.go --with-expecter
type Requester interface {
	Get(ctx context.Context, path string, ops ...Ops) (*resty.Response, error)
	Post(ctx context.Context, path string, ops ...Ops) (*resty.Response, error)
	SetRetryConfig(retryCnt int, waitTime time.Duration, maxWaitTime time.Duration)
	SetRetryCondition(retryConditionFunc resty.RetryConditionFunc)
}

type client struct {
	client      *resty.Client
	host        string
	serviceName string
}

func New(c *resty.Client, host string, serviceName string) Requester {
	if c.GetClient().Timeout == 0 {
		c.SetTimeout(time.Minute)
	}

return &client{client: c, host: host, serviceName: serviceName}
}

func (r client) SetRetryConfig(retryCnt int, waitTime time.Duration, maxWaitTime time.Duration) {
	r.client.SetRetryCount(retryCnt).SetRetryWaitTime(waitTime).
		SetRetryMaxWaitTime(maxWaitTime)
}

func (r client) SetRetryCondition(retryConditionFunc resty.RetryConditionFunc) {
	r.client.AddRetryCondition(retryConditionFunc)
}

func (r client) Get(ctx context.Context, path string, ops ...Ops) (*resty.Response, error) {
	path, err := JoinPath(r.host, path)
	if err != nil {
		return nil, errors.Wrapf(err, "join host(%v) with path(%v) failed", r.host, path)
	}

req := r.new(ctx, ops...)
	_, span := apmtrace.SimpleHttpTrace(req.Context(), r.serviceName, r.serviceName, req.Header)
	defer span.End()

resp, err := req.Get(path)
	if err != nil {
		return resp, errors.Wrapf(err, "send GET request to %q failed", path)
	}

return resp, nil
}

func (r client) Post(ctx context.Context, path string, ops ...Ops) (*resty.Response, error) {
	path, err := JoinPath(r.host, path)
	if err != nil {
		return nil, errors.Wrapf(err, "join host(%v) with path(%v) failed", r.host, path)
	}

req := r.new(ctx, ops...)
	_, span := apmtrace.SimpleHttpTrace(req.Context(), r.serviceName, r.serviceName, req.Header)
	defer span.End()

resp, err := req.Post(path)
	if err != nil {
		return resp, errors.Wrapf(err, "send POST request to  %q failed", path)
	}

return resp, nil
}

func (r client) new(ctx context.Context, ops ...Ops) *resty.Request {
	request := r.client.R().EnableTrace().SetContext(ctx)

if lang, ok := contexthelper.Load(ctx, commonconstant.HeaderLang).(string); ok {
		request.SetHeader(commonconstant.HeaderLang, lang)
	} else {
		request.SetHeader(commonconstant.HeaderLang, commonconstant.ZhLanguages) // 默认请求中文
	}

if requestID, ok := contexthelper.Load(ctx, commonconstant.HeaderRequestId).(string); ok {
		request.SetHeader(commonconstant.HeaderRequestId, requestID)
	} else {
		request.SetHeader(commonconstant.HeaderRequestId, utils.UUID())
	}

for _, op := range ops {
		op(request)
	}

return request
}

// func (r client) check(method func(string) (*resty.Response, error), path string) (*resty.Response, error) {
// 	resp, err := method(path)
// 	if err != nil {
// 		return resp, errors.WithMessagef(err, "send request failed")
// 	}
//
// 	if resp != nil && resp.StatusCode() != http.StatusOK {
// 		return resp, ErrNotOK
// 	}
//
// 	return resp, nil
// }

type Ops func(request *resty.Request)

func WithBody(body interface{}) Ops {
	return func(request *resty.Request) {
		request.SetBody(body)
	}
}

func WithResult(body interface{}) Ops {
	return func(request *resty.Request) {
		request.SetResult(body)
	}
}

func WithHeaders(headers map[string]string) Ops {
	return func(request *resty.Request) {
		request.SetHeaders(headers)
	}
}

func WithHeader(header, value string) Ops {
	return func(request *resty.Request) {
		request.SetHeader(header, value)
	}
}

func WithQueryParams(params map[string]string) Ops {
	return func(request *resty.Request) {
		request.SetQueryParams(params)
	}
}

func WithQueryParam(param, value string) Ops {
	return func(request *resty.Request) {
		request.SetQueryParam(param, value)
	}
}

func WithQueryString(queryString string) Ops {
	return func(request *resty.Request) {
		request.SetQueryString(queryString)
	}
}

// JoinPath returns a URL string with the provided path elements joined to
// the existing path of base and the resulting path cleaned of any ./ or ../ elements.
func JoinPath(base string, elem ...string) (result string, err error) {
	// go1.19.3/src/net/url/url.go:1258
	// return url.JoinPath(base, elem...)

for _, e := range elem {
		base = singleJoiningSlash(base, e)
	}
	return base, nil
}

func singleJoiningSlash(a, b string) string {
	aslash := strings.HasSuffix(a, "/")
	bslash := strings.HasPrefix(b, "/")
	switch {
	case aslash && bslash:
		return a + b[1:]
	case !aslash && !bslash:
		return a + "/" + b
	}
	return a + b
}

func FastCloseRespBody(w *http.Response) {
	_ = w.Body.Close()
}
```

根据您提供的代码，Requester 确实是一个内部封装的与 HTTP 请求相关的库。让我为您总结一下这个 Requester 的主要特点和功能：

1. 接口定义：
   Requester 是一个接口，定义了以下方法：
   
   - Get：发送 GET 请求
   - Post：发送 POST 请求
   - SetRetryConfig：设置重试配置
   - SetRetryCondition：设置重试条件
2. 实现：
   client 结构体实现了 Requester 接口，它包含：
   
   - resty.Client：用于发送 HTTP 请求
   - host：请求的主机地址
   - serviceName：服务名称
3. 主要功能：
   
   - 封装了 GET 和 POST 请求，简化了调用过程
   - 支持设置重试策略
   - 自动添加一些通用的 HTTP 头，如语言和请求 ID
   - 支持追踪和监控（使用 apmtrace 包）
   - 提供了一系列 Ops 函数，用于灵活配置请求（如设置请求体、查询参数、头部等）
4. 错误处理：
   使用 github.com/pkg/errors 包进行错误包装，提供更详细的错误信息
5. 辅助功能：
   
   - JoinPath 函数用于正确拼接 URL 路径
   - FastCloseRespBody 函数用于快速关闭响应体
6. 灵活性：
   通过 Ops 函数，可以在创建请求时灵活地设置各种参数，如请求体、查询参数、头部等

这个 Requester 库封装了底层的 HTTP 请求操作，提供了一个更高级、更易用的接口。它考虑到了错误处理、重试机制、请求追踪等实际应用中常见的需求，使得在项目中进行 HTTP 请求变得更加简单和规范。

需要我详细解释其中的某个部分吗？

## 能向我解释一下这段代码里面涉及到哪些计算机网络基础知识嘛？并且对这些知识相关的基本概念做一下扩展了解向我讲解

这段代码涉及了多个计算机网络的基础知识，我会逐一解释并扩展相关概念：

1. HTTP协议
   
   - 概念：超文本传输协议（Hypertext Transfer Protocol），是互联网上应用最为广泛的一种网络协议。
   - 扩展：HTTP是一个客户端和服务器端请求和应答的标准。客户端是终端用户，服务器是网站。通过使用Web浏览器、网络爬虫或者其它的工具，客户端发起一个HTTP请求到服务器上指定端口（默认端口为80）。
   - 代码中体现：Get和Post方法分别实现了HTTP的GET和POST请求。
2. RESTful API
   
   - 概念：表述性状态传递（Representational State Transfer），是一种软件架构风格。
   - 扩展：REST是设计风格而不是标准。REST通常基于使用HTTP、URI、XML以及HTML这些现有的广泛流行的协议和标准。REST强调HTTP方法的使用，如GET用于获取资源，POST用于创建资源。
   - 代码中体现：通过Get和Post方法实现了RESTful风格的API调用。
3. URL结构
   
   - 概念：统一资源定位符（Uniform Resource Locator），用于定位互联网上资源。
   - 扩展：一个完整的URL包括协议（如http://）、主机名（如www.example.com）、路径（如/path/to/resource）等部分。
   - 代码中体现：JoinPath函数用于正确拼接URL路径。
4. HTTP请求头
   
   - 概念：HTTP头部包含有关请求或响应的补充信息。
   - 扩展：常见的请求头包括Content-Type（指定内容类型）、User-Agent（标识客户端应用程序）等。
   - 代码中体现：WithHeader和WithHeaders函数用于设置HTTP请求头。
5. HTTP状态码
   
   - 概念：HTTP响应状态码指示特定HTTP请求是否已成功完成。
   - 扩展：状态码分为五类：信息响应（100–199），成功响应（200–299），重定向（300–399），客户端错误（400–499）和服务器错误（500–599）。
   - 代码中体现：虽然代码中被注释掉了，但有检查状态码是否为200（OK）的逻辑。
6. 请求重试机制
   
   - 概念：当网络请求失败时，自动重新尝试该请求的机制。
   - 扩展：重试机制可以提高系统的可靠性，但需要谨慎使用以避免对服务器造成不必要的负担。
   - 代码中体现：SetRetryConfig和SetRetryCondition方法用于配置重试策略。
7. 上下文（Context）
   
   - 概念：在Go语言中，Context用于跨API边界和进程间传递截止日期、取消信号和其他请求范围的值。
   - 扩展：Context可以用于控制请求的生命周期，例如设置超时或取消长时间运行的操作。
   - 代码中体现：Get和Post方法都接受一个ctx参数，用于传递上下文信息。
8. 分布式追踪
   
   - 概念：在分布式系统中跟踪请求流程的技术。
   - 扩展：分布式追踪可以帮助开发者理解系统行为，识别性能瓶颈。
   - 代码中体现：使用apmtrace.SimpleHttpTrace进行请求追踪。

这些概念构成了现代网络应用程序的基础。理解这些概念对于开发和维护网络应用程序至关重要。

## TCP三次握手和四次挥手

HTTPS 实际上是 HTTP 协议和 SSL/TLS 协议的组合。在建立 HTTPS 连接时，会先进行 SSL/TLS 握手，然后再进行 HTTP 的通信。您提到的"三次握手"和"四次挥手"实际上是 TCP 协议的概念，因为 HTTPS 使用 TCP 作为传输层协议。让我详细解释一下：

1. TCP 三次握手（建立连接）：
   
   a) 客户端发送 SYN 包到服务器，进入 SYN_SENT 状态。
   b) 服务器收到 SYN 包，回复 SYN+ACK 包，进入 SYN_RECEIVED 状态。
   c) 客户端收到 SYN+ACK 包，回复 ACK 包，双方进入 ESTABLISHED 状态。
2. TCP 四次挥手（断开连接）：
   
   a) 客户端发送 FIN 包，进入 FIN_WAIT_1 状态。
   b) 服务器收到 FIN 包，发送 ACK 包，进入 CLOSE_WAIT 状态。
   c) 服务器发送 FIN 包，进入 LAST_ACK 状态。
   d) 客户端收到 FIN 包，发送 ACK 包，进入 TIME_WAIT 状态，等待 2MSL 后关闭连接。

对于 HTTPS，在 TCP 连接建立之后，还会进行 SSL/TLS 握手：

1. 客户端发送 ClientHello 消息，包含支持的 SSL/TLS 版本、加密算法等。
2. 服务器回复 ServerHello 消息，选择使用的协议版本和加密算法。
3. 服务器发送证书。
4. 服务器发送 ServerHelloDone 消息。
5. 客户端验证证书，生成随机数，用服务器公钥加密发送。
6. 服务器用私钥解密，获得随机数。
7. 双方使用随机数生成会话密钥。
8. 客户端发送 Finished 消息。
9. 服务器发送 Finished 消息。

SSL/TLS 握手完成后，后续的 HTTP 通信都会使用协商好的加密算法和会话密钥进行加密。

这个过程确保了 HTTPS 通信的安全性，包括：

1. 身份验证：通过证书确认服务器身份。
2. 保密性：使用加密算法保护数据不被窃听。
3. 完整性：使用消息认证码（MAC）确保数据不被篡改。

理解这个过程对于开发安全的网络应用程序和诊断 HTTPS 相关问题非常重要。

最后修改：2024 年 07 月 15 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

财富管理模块自用的内部请求工具包

JIeJaitt • 2024 年 07 月 13 日