设计模式那些事(3)——使用建造者模式封装go的http库

在日常开发中经常会用到http库来发送请求，就将常用的请求方法封装了一个库，灵活又好用。

这里用到了建造者模式，类似的使用场景都可以这样来实现：

具体实现

package requests

import (
    "bytes"
    "context"
    "encoding/json"
    "errors"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "strings"
    "time"
)

const (
    contentType = "Content-Type"
)

type HttpSend struct {
    ctx            context.Context   // 上下文
    client         *http.Client      // 客户端
    request        *http.Request     // 请求体
    url, httpProxy string            // 请求路径
    getValue       interface{}       // get请求体
    postValue      interface{}       // post请求体
    postFormValue  url.Values        // form-data post请求体
    header         map[string]string // header
    timeout        time.Duration     // 超时时间
    tryNum         int               // 重试次数
    doNum          int               // 已重试次数
    intervalTime   time.Duration     // 重试间隔时间
    err            error             // 错误
}

// 使用建造者模式初始化HttpClient
func NewHttpClient(ctx context.Context, options ...HttpOptions) *HttpSend {
    client := new(HttpSend)
    client.ctx = ctx
    for i := 0; i < len(options); i++ {
        options[i](client)
    }
    client.NewClient(ctx)
    if client.timeout != 0 {
        client.client.Timeout = client.timeout
    }
    return client
}

// 实例化HttpClient
func (h *HttpSend) NewClient(ctx context.Context) {
    h.client = new(http.Client)
    if h.httpProxy != "" {
        var proxyUrl *url.URL
        proxyUrl, h.err = url.Parse(h.httpProxy)
        if h.err != nil {
            log.Errorf(ctx, fmt.Sprintf("初始化httpClient-httpProxy解析错误， error:%s", h.err))
        }
        h.client.Transport = &http.Transport{
            Proxy: http.ProxyURL(proxyUrl),
        }
    }
}

// 包装了重试的do方法
func (h *HttpSend) HttpDo() []byte {
    var resp *http.Response
    var body []byte
    resp, h.err = h.client.Do(h.request)
    if h.err == nil {
        log.Infof(h.ctx, fmt.Sprintf("HttpDo，resp:%+v, error:%+v", resp, h.err))
        defer resp.Body.Close()
        if resp.StatusCode == http.StatusOK {
            body, h.err = ioutil.ReadAll(resp.Body)
        } else {
            h.err = errors.New(resp.Status)
        }
    } else {
        for h.doNum < h.tryNum {
            h.doNum++
            log.Errorf(h.ctx, fmt.Sprintf("HttpDo,url:%s,resp:%+v,重试次数:%d,error:%s", h.url, resp, h.doNum, h.err))
            time.Sleep(h.intervalTime)
            h.NewClient(h.ctx)
            body = h.HttpDo()
            return body
        }
    }
    return body
}

// 发送get请求
func (h *HttpSend) HttpGet() ([]byte, error) {
    if h.err != nil {
        return []byte{}, h.err
    }
    defer func(t time.Time) {
        log.Info(h.ctx, fmt.Sprintf("took %v/s", time.Since(t).Seconds()))
    }(time.Now())
    log.Info(h.ctx, fmt.Sprintf("url:%s,request:%s", h.url, h.url))
    h.request, h.err = http.NewRequest(http.MethodGet, h.url, nil)
    if h.err != nil {
        return []byte{}, h.err
    }
    h.setHeader()
    var body []byte
    body = h.HttpDo()
    log.Infof(h.ctx, fmt.Sprintf("url:%s,response:%s,error:%s", h.url, string(body), h.err))
    return body, h.err
}

// 发送json参数的get请求
func (h *HttpSend) HttpGetWithJson() ([]byte, error) {
    if h.err != nil {
        return []byte{}, h.err
    }
    getValue, err := json.Marshal(h.getValue)
    if err != nil {
        log.Errorf(h.ctx, fmt.Sprintf("err:%s", err))
        return nil, err
    }
    log.Infof(h.ctx, fmt.Sprintf("url:%s,request:%+v", h.url, h.getValue))
    h.request, h.err = http.NewRequest(http.MethodGet, h.url, strings.NewReader(string(getValue)))
    if _, ok := h.header[contentType]; !ok {
        h.request.Header.Set(contentType, "application/json")
    }
    h.setHeader()
    var body []byte
    body = h.HttpDo()
    log.Infof(h.ctx, fmt.Sprintf("url:%s,response:%s,error:%s", h.url, string(body), h.err))
    return body, h.err
}

// 发送json格式的post请求
func (h *HttpSend) HttpPost() ([]byte, error) {
    if h.err != nil {
        return []byte{}, h.err
    }
    postValue, err := json.Marshal(h.postValue)
    if err != nil {
        log.Errorf(h.ctx, fmt.Sprintf("err:%s", err))
        return nil, err
    }
    log.Infof(h.ctx, fmt.Sprintf("url:%s,request:%s", h.url, h.postValue))
    h.request, h.err = http.NewRequest(http.MethodPost, h.url, strings.NewReader(string(postValue)))
    if _, ok := h.header[contentType]; !ok {
        h.request.Header.Set(contentType, "application/json")
    }
    h.setHeader()
    var body []byte
    body = h.HttpDo()
    log.Infof(h.ctx, fmt.Sprintf("url:%s,response:%s", h.url, string(body)))
    return body, h.err
}

// 发送form-data的post请求
func (h *HttpSend) HttpPostForm() ([]byte, error) {
    if h.err != nil {
        return []byte{}, h.err
    }
    log.Infof(h.ctx, fmt.Sprintf("url:%s,postValue:%+v", h.url, h.postFormValue))
    h.request, h.err = http.NewRequest(http.MethodPost, h.url, strings.NewReader(h.postFormValue.Encode()))
    if h.err != nil {
        return []byte{}, h.err
    }
    h.request.Header.Set(contentType, "application/x-www-form-urlencoded")
    var body []byte
    body = h.HttpDo()
    log.Infof(h.ctx, fmt.Sprintf("send post success,body:%s,h.err:%s", string(body), h.err))
    return body, h.err
}

// 设置header
func (h *HttpSend) setHeader() {
    for k, v := range h.header {
        h.request.Header.Set(k, v)
    }
}

type HttpOptions func(*HttpSend)

// 设置请求路径
func UrlOptions(url string) HttpOptions {
    return func(client *HttpSend) {
        client.url = url
    }
}

// 设置post请求体
func PostValueOptions(postValue interface{}) HttpOptions {
    return func(client *HttpSend) {
        client.postValue = postValue
    }
}

// 设置form-data格式的post请求体
func PostFormValueOptions(postFormValue url.Values) HttpOptions {
    return func(client *HttpSend) {
        client.postFormValue = postFormValue
    }
}

// 设置get请求体
func GetValueOptions(getValue interface{}) HttpOptions {
    return func(client *HttpSend) {
        client.getValue = getValue
    }
}

// 设置超时时间
func TimeOptions(timeout time.Duration) HttpOptions {
    return func(client *HttpSend) {
        client.timeout = timeout
    }
}

// 设置代理
func ProxyOptions(proxy string) HttpOptions {
    return func(client *HttpSend) {
        client.httpProxy = proxy
    }
}

// 设置请求头
func HeaderOptions(header map[string]string) HttpOptions {
    return func(client *HttpSend) {
        client.header = header
    }
}

// 设置重试参数
func TryOptions(tryNum int, intervalTime time.Duration) HttpOptions {
    return func(client *HttpSend) {
        client.tryNum = tryNum
        client.intervalTime = intervalTime
    }
}

使用

data, err := requests.NewHttpClient(
        ctx,
        requests.UrlOptions(xxxUrl),
        requests.PostValueOptions(postParams),
        requests.TryOptions(2, time.Second*3)).
        HttpPost()