封装http请求客户端

在2015年，TomásSenart就使用接口包装http.Client结构进行了精彩的探讨，你可以在https//github.com/gophercon/2015-talks上找到更多相关信息。 本节从他的想法中获取并演示了一个与http.Client结构的Transport接口相同的示例，类似于我们之前的示例，为REST API编写客户端。

本节将为标准的http.Client结构实现日志记录和基本身份验证中间件。 它还包括一个decorate函数，可以在需要使用各种中间件时使用。

实践

建立 config.go：

package decorator

import (
    "log"
    "net/http"
    "os"
)

// Setup 初始化客户端接口
func Setup() *http.Client {
    c := http.Client{}

    t := Decorate(&http.Transport{},
        Logger(log.New(os.Stdout, "", 0)),
        BasicAuth("username", "password"),
    )
    c.Transport = t
    return &c
}

建立 decorator.go：

package decorator

import "net/http"

// TransportFunc 实现了 RountTripper 接口
type TransportFunc func(*http.Request) (*http.Response, error)

// RoundTrip 仅调用原始的函数
func (tf TransportFunc) RoundTrip(r *http.Request) (*http.Response, error) {
    return tf(r)
}

// Decorator 是一个方便的函数来表示我们的中间件内部功能
type Decorator func(http.RoundTripper) http.RoundTripper

// Decorate 用于包装所有中间件
func Decorate(t http.RoundTripper, rts ...Decorator) http.RoundTripper {
    decorated := t
    for _, rt := range rts {
        decorated = rt(decorated)
    }
    return decorated
}

建立 middleware.go：

package decorator

import (
    "log"
    "net/http"
    "time"
)

// Logger 日志中间件
func Logger(l *log.Logger) Decorator {
    return func(c http.RoundTripper) http.RoundTripper {
        return TransportFunc(func(r *http.Request) (*http.Response, error) {
            start := time.Now()
            l.Printf("started request to %s at %s", r.URL, start.Format("2006-01-02 15:04:05"))
            resp, err := c.RoundTrip(r)
            l.Printf("completed request to %s in %s", r.URL, time.Since(start))
            return resp, err
        })
    }
}

// BasicAuth 基础身份认证中间件
func BasicAuth(username, password string) Decorator {
    return func(c http.RoundTripper) http.RoundTripper {
        return TransportFunc(func(r *http.Request) (*http.Response, error) {
            r.SetBasicAuth(username, password)
            resp, err := c.RoundTrip(r)
            return resp, err
        })
    }
}

建立 exec.go：

package decorator

import "fmt"

// Exec 创建一个客户端，调用google.com然后打印响应
func Exec() error {
    c := Setup()

    resp, err := c.Get("https://www.google.com")
    if err != nil {
        return err
    }
    fmt.Println("Response code:", resp.StatusCode)
    return nil
}

建立 main.go：

package main

import "github.com/agtorre/go-cookbook/chapter6/decorator"

func main() {
    if err := decorator.Exec(); err != nil {
        panic(err)
    }
}

这会输出：

started request to https://www.google.com at 2017-01-01 13:38:42
completed request to https://www.google.com in 194.013054ms
Response code: 200

本节将闭包作为一流的公民和接口。主要技巧是具有功能实现接口。这允许封装具有由函数实现的接口的结构实现的接口。

middleware.go文件包含两个示例客户端中间件函数。 这些可以扩展为包含其他中间件，例如更复杂的身份验证。 本示例也可以与之前的示例结合使用，以生成可以通过其他中间件进行扩展的OAuth2客户端。

Decorator函数是一种便利的封装函数，可以这样比较下：

Decorate(RoundTripper, Middleware1, Middleware2, etc)
vs
var t RoundTripper
t = Middleware1(t)
t = Middleware2(t)
etc

与封装客户端相比，这种方法的优点是我们可以保持接口解耦。如果你想要一个功能齐全的客户端，你还需要实现GET，POST和PostForm等方法。