Golang-Interface能怎么用?

Golang Interface 应用

Interface是什么？

在Golang中，interface是一组method的集合，duck-type programing的一种体现。不关心属性（数据），只关心行为（方法）。可以认为interface是一种协议，一种为了双方交流而做出的约定。

// The error built-in interface type is the conventional interface for
// representing an error condition, with the nil value representing no error.
type error interface {
    Error() string
}

// ----------------
// 定义自己的err类型
type MyErr struct {}

// 实现error接口
func (e *MyErr)Error() string {
    return "my error"	
}

Interface能干什么？

• writing generic algorithm （泛型编程）
• hiding implementation detail （隐藏具体实现）
• providing interception points （提供拦截点）

writing generic algorithm

golang的泛型最早1.17才提供版本支持。用interface实现一下行不行呀？

package sort

type Interface interface {
    // Len is the number of elements in the collection.
    Len() int
    // Less reports whether the element with
    // index i should sort before the element with index j.
    Less(i, j int) bool
    // Swap swaps the elements with indexes i and j.
    Swap(i, j int)
}

// ------------------

type BestLanguage struct {
    Name  string
    Score int
}

func (b BestLanguage) String() string {
    return fmt.Sprintf("%s:%d", b.Name, b.Score)
}

type Languages []BestLanguage

// 实现了sort的Interface，不知道是怎么排序的，但拥有了排序的能力
func (l Languages) Len() int {
    return len(Languages{})
}

func (l Languages) Less(i, j int) bool {
    return l[i].Score > l[j].Score
}
func (l Languages) Swap(i, j int) {
    l[i], l[j] = l[j], l[i]
}


func main() {
    languages := []BestLanguage{
        {"Chinese", 5},
        {"English", 4},
        {"Japanese", 3},
    }

    fmt.Println(languages)
    sort.Sort(Languages(languages))
    fmt.Println(languages)
}

// Return concrete types, receive interfaces as parameter.
func ConvertInterfaceToString(v interface{}) string {
    var vstr string
    switch v.(type) {
    case int:
        vstr = strconv.Itoa(v.(int))
    case int32:
        vstr = strconv.Itoa(int(v.(int32)))
    case int64:
        vstr = strconv.FormatInt(v.(int64), 10)
    case float64:
        vstr = strconv.Itoa(int(v.(float64)))
    case string:
        vstr = v.(string)
    default:
    }
    return vstr
}

hiding implement detail

三个函数返回的具体 struct （都实现了 Context interface），但是对于使用者来说是完全无感知的。

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}

// ------------------

type cancelCtx struct {
    Context
    mu       sync.Mutex
    done     chan struct{}
    children map[canceler]struct{}
    err      error
}
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)    //返回 cancelCtx

type timerCtx struct {
    cancelCtx
    timer *time.Timer
    deadline time.Time
}
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) //返回 timerCtx

type valueCtx struct {
    Context
    key, val interface{}
}
func WithValue(parent Context, key, val interface{}) Context    //返回 valueCtx

providing interception points

实现RoundTripper接口，可以在http请求前后写入自己的逻辑，如apm，jaeger的打点。

package http

type RoundTripper interface {
    RoundTrip(*Request) (*Response, error)
}

func WrapClient(c *http.Client) *http.Client {
    if c == nil {
        c = http.DefaultClient
    }
    copied := *c
    copied.Transport = wrapRoundTripper(copied.Transport)
    return &copied
}

func wrapRoundTripper(r http.RoundTripper) http.RoundTripper {
    if r == nil {
        r = http.DefaultTransport
    }
    rt := &roundTripper{r: r}
    return rt
}

type roundTripper struct {
    r http.RoundTripper
}

func (r *roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
  // do something
  resp, err := r.r.RoundTrip(req) // real request
  // do something
  return resp, err
}

值接收 or 指针接收

实现接口的时候应该用值还是指针？

1. 赋值时必须用指针。
2. 初始化为指针类型，编译指定没问题。
3. ❎表示编译不通过，因为对象没有声明接口的全部方法。
4. 指针类型没有声明全部，但是能编译通过，因为Go自己做了一些转换。

type Animal interface {
    Eat(food string)
    Say()
}

// 全部值
type Dog struct {
    food string
}

func (d Dog) Eat(food string) {
    d.food = food
}
func (d Dog) Say() {
    fmt.Println("dog like ", d.food)
}

// 全部指针
type Cat struct {
    food string
}

func (d *Cat) Eat(food string) {
    d.food = food
}
func (d *Cat) Say() {
    fmt.Println("cat like ", d.food)
}

// 有值、有指针
type Fish struct {
    food string
}

func (d *Fish) Eat(food string) {
    d.food = food
}
func (d Fish) Say() {
    fmt.Println("fish like ", d.food)
}

func main() {
    var dog Animal = Dog{}
    var dog Animal = &Dog{}
    var dog Animal = new(Dog)
    dog.Eat("bone")
    dog.Say()
    // dog like    # 没吃上，赋值失败

    ❎ var cat Animal = Cat{}
    //var cat Animal = &Cat{}
    var cat Animal = new(Cat)
    cat.Eat("fish")
    cat.Say()
    // cat like  fish

    ❎ var fish Animal = Fish{}
    var fish Animal = new(Fish)
    fish.Eat("small fish")
    fish.Say()
    // fish like  small fish
}

参考

http://legendtkl.com/2017/06/12/understanding-golang-interface/