ByteView和Sink

久违啦米娜桑！！！

最近有点忙，一月有余没有更新了，实在对不起大家！！！

上线后看到不少朋友发的私信，感谢大家的赞许与信任，后面我会尽最大的努力按时更新，不断推出更优质的文章！！！

本来计划最后花1讲的篇幅写完groupcache的源码分析的，今天刷了一下发现量还是有点多，可能得分两三讲；不过不会等到两三周才讲完的，预计趁着这个中秋假期刷完，一天一篇结束这个项目。

之前我们已经看完了groupcache项目的各个子包，今天要真正开始欣赏groupcache的漂亮代码了！（剧透一下，groupcache.go里面还是发现了一些写的很“漂亮”的代码，几行的内容够琢磨小半天的）

先看一下groupcache这个package的uml图吧：

从图中我们可以看到一个很重要的interface：Sink和一个很重要的struct：ByteView，为什么说重要呢，我也不知道。。。不过看连线嘛，一堆的struct都与这2个类型产生了关系，于是今天我们围绕着这2个类型展开源码透析！

1、byteview.go

可以看到这个go文件中只有一个类型ByteView，这个类型有2个属性和一堆绑定的方法，下面我们逐个来看：

ByteView的定义很简单，存着一个[]byte类型的b和string类型的s，这个需要牢记，因为其他很多地方都是围绕着这个类型展开的编码！这个文件中涉及的方法总体看还是比较简洁简单，大家参照着中英文注释浏览一遍应该很容易理解：

// Len returns the view's length.
//【返回一个view的长度】
func (v ByteView) Len() int {
    if v.b != nil {
        return len(v.b)
    }
    return len(v.s)
}

// ByteSlice returns a copy of the data as a byte slice.
//【获取一份[]byte类型的view值的拷贝】
func (v ByteView) ByteSlice() []byte {
    if v.b != nil {
        return cloneBytes(v.b)
    }
    return []byte(v.s)
}

// String returns the data as a string, making a copy if necessary.
//【上一个是返回[]byte类型，这里是string类型】
func (v ByteView) String() string {
    if v.b != nil {
        return string(v.b)
    }
    return v.s
}

// At returns the byte at index i.
//【返回第i个byte】
func (v ByteView) At(i int) byte {
    if v.b != nil {
        return v.b[i]
    }
    //【字符串索引获取到的值是byte类型】
    return v.s[i]
}

// Slice slices the view between the provided from and to indices.
//【返回从索引from到to的view的切分结果】
func (v ByteView) Slice(from, to int) ByteView {
    if v.b != nil {
        return ByteView{b: v.b[from:to]}
    }
    return ByteView{s: v.s[from:to]}
}

// SliceFrom slices the view from the provided index until the end.
//【相当于上面的to为len(b)】
func (v ByteView) SliceFrom(from int) ByteView {
    if v.b != nil {
        return ByteView{b: v.b[from:]}
    }
    return ByteView{s: v.s[from:]}
}

// Copy copies b into dest and returns the number of bytes copied.
//【拷贝一份view到dest】
func (v ByteView) Copy(dest []byte) int {
    if v.b != nil {
        return copy(dest, v.b)
    }
    return copy(dest, v.s)
}

// Equal returns whether the bytes in b are the same as the bytes in
// b2.
//【相等判断，具体比较的实现在下面】
func (v ByteView) Equal(b2 ByteView) bool {
    if b2.b == nil {
        return v.EqualString(b2.s)
    }
    return v.EqualBytes(b2.b)
}

// EqualString returns whether the bytes in b are the same as the bytes
// in s.
func (v ByteView) EqualString(s string) bool {
    if v.b == nil {
        //【如果b为nil，则比较s是否相等】
        return v.s == s
    }
    //【l为view的长度，实现在上面】
    l := v.Len()
    //【长度不同直接返回false】
    if len(s) != l {
        return false
    }
    //【判断[]byte中的每一个byte是否和string的每一个字符相等】
    for i, bi := range v.b {
        if bi != s[i] {
            return false
        }
    }
    return true
}

// EqualBytes returns whether the bytes in b are the same as the bytes
// in b2.
func (v ByteView) EqualBytes(b2 []byte) bool {
    //【b不为空，直接通过Equal方法比较】
    if v.b != nil {
        return bytes.Equal(v.b, b2)
    }
    l := v.Len()
    //【长度不等直接返回false】
    if len(b2) != l {
        return false
    }
    //【与上一个方法类似，比较字符串和[]byte每一个byte是否相等】
    for i, bi := range b2 {
        if bi != v.s[i] {
            return false
        }
    }
    return true
}

// Reader returns an io.ReadSeeker for the bytes in v.
//【返回值其实是bytes包或者strings包中的*Reader类型，这是个struct
// 实现了io.ReadSeeker等接口】
func (v ByteView) Reader() io.ReadSeeker {
    if v.b != nil {
        return bytes.NewReader(v.b)
    }
    return strings.NewReader(v.s)
}

// ReadAt implements io.ReaderAt on the bytes in v.
func (v ByteView) ReadAt(p []byte, off int64) (n int, err error) {
    if off < 0 {
        return 0, errors.New("view: invalid offset")
    }
    if off >= int64(v.Len()) {
        return 0, io.EOF
    }
    //【从off开始拷贝一份数据到p】
    n = v.SliceFrom(int(off)).Copy(p)
    if n < len(p) {
        err = io.EOF
    }
    return
}

// WriteTo implements io.WriterTo on the bytes in v.
//【将v写入w】
func (v ByteView) WriteTo(w io.Writer) (n int64, err error) {
    var m int
    if v.b != nil {
        m, err = w.Write(v.b)
    } else {
        m, err = io.WriteString(w, v.s)
    }
    if err == nil && m < v.Len() {
        err = io.ErrShortWrite
    }
    n = int64(m)
    return
}

ByteView这个struct需要记住，下面我们看Sink，其中很多地方会操作ByteView。

2、sinks.go

前面在uml图中已经看到有5个类型实现了Sink接口，我们先看一下sink.go的结构：

粗看是1个接口5个结构体和一堆函数，我们从Sink入手：

可以看到实现了Sink的结构体应该是用来存储某种数据的，存的时候需要调用到SetXxx()方法，可以通过view()方法获取到一些东西，返回值是上面介绍的ByteView类型的。

先看个简单的struct：stringSink

如上图，stringSink只包含2个成员，初始化函数也特别简单，接收一个*string类型的sp，返回值注意一下，是Sink接口类型的。

stringSink有4个方法，刚好实现了Sink接口

每个方法都挺好理解的，名字不同是因为接收的参数不同，但不管接收到什么类型的参数，都是用于设置stringSink的2个成员。

再看2个函数：

这个太简单了，就是克隆一个byte切片，不多说了，下面一个函数，，，可就没那么简洁了：

这个函数内部定义了一个叫做viewSetter的interface类型，这个类型有个setView(v ByteView) error方法，参数还是ByteView类型的。前面我们看过各种Set方法或多或少或操作到ByteView类型的数据，不过一般是分开处理ByteView中的b或者s，这里明显是不需要区分了，直接设置整个ByteView。第一个if判断参数s是否实现了viewSetter接口，如果实现了，则直接调用setView设置v，如果没有实现，则通过Sink的SetXxx()方法设置ByteView。下面贴一波剩下几个struct及绑定方法的代码，每个struct的逻辑大同小异，大家对这注释理解一下，注意上面介绍到的setView方法在下面的部分struct中是如何实现的：

// ByteViewSink returns a Sink that populates a ByteView.
//【根据参数dst构造byteViewSink结构体实例】
func ByteViewSink(dst *ByteView) Sink {
    if dst == nil {
        panic("nil dst")
    }
    return &byteViewSink{dst: dst}
}

//【属性dst为一个ByteView指针】
type byteViewSink struct {
    dst *ByteView

    // if this code ever ends up tracking that at least one set*
    // method was called, don't make it an error to call set
    // methods multiple times. Lorry's payload.go does that, and
    // it makes sense. The comment at the top of this file about
    // "exactly one of the Set methods" is overly strict. We
    // really care about at least once (in a handler), but if
    // multiple handlers fail (or multiple functions in a program
    // using a Sink), it's okay to re-use the same one.
}

func (s *byteViewSink) setView(v ByteView) error {
    *s.dst = v
    return nil
}

func (s *byteViewSink) view() (ByteView, error) {
    return *s.dst, nil
}

//【设置byteViewSink中ByteView的b】
func (s *byteViewSink) SetProto(m proto.Message) error {
    b, err := proto.Marshal(m)
    if err != nil {
        return err
    }
    *s.dst = ByteView{b: b}
    return nil
}

//【复制b，初始化byteViewSink的dst】
func (s *byteViewSink) SetBytes(b []byte) error {
    *s.dst = ByteView{b: cloneBytes(b)}
    return nil
}
//【通过使用string类型的v初始化一个ByteView后初始化byteViewSink的dst】
func (s *byteViewSink) SetString(v string) error {
    *s.dst = ByteView{s: v}
    return nil
}

// ProtoSink returns a sink that unmarshals binary proto values into m.
//【使用proto.Message类型的m初始化protoSink的dst】
func ProtoSink(m proto.Message) Sink {
    return &protoSink{
        dst: m,
    }
}

//【3个属性】
type protoSink struct {
    dst proto.Message // authoritative value
    typ string

    v ByteView // encoded
}

//【返回protoSink的ByteView类型的v】
func (s *protoSink) view() (ByteView, error) {
    return s.v, nil
}

//【将s.dst反序列化后丢给b，并且复制一份丢给protoSink中ByteView的b】
func (s *protoSink) SetBytes(b []byte) error {
    err := proto.Unmarshal(b, s.dst)
    if err != nil {
        return err
    }
    s.v.b = cloneBytes(b)
    s.v.s = ""
    return nil
}
//【将b解码后写入s.dst】
func (s *protoSink) SetString(v string) error {
    b := []byte(v)
    err := proto.Unmarshal(b, s.dst)
    if err != nil {
        return err
    }
    s.v.b = b
    s.v.s = ""
    return nil
}

//【将m写入protoSink的dst】
func (s *protoSink) SetProto(m proto.Message) error {
    b, err := proto.Marshal(m)
    if err != nil {
        return err
    }
    // TODO(bradfitz): optimize for same-task case more and write
    // right through? would need to document ownership rules at
    // the same time. but then we could just assign *dst = *m
    // here. This works for now:
    err = proto.Unmarshal(b, s.dst)
    if err != nil {
        return err
    }
    s.v.b = b
    s.v.s = ""
    return nil
}

// AllocatingByteSliceSink returns a Sink that allocates
// a byte slice to hold the received value and assigns
// it to *dst. The memory is not retained by groupcache.
//【分配一个字节切片来保存接收到的数据】
func AllocatingByteSliceSink(dst *[]byte) Sink {
    return &allocBytesSink{dst: dst}
}

//【有一个字节切片指针类型的属性dst】
type allocBytesSink struct {
    dst *[]byte
    v   ByteView
}

func (s *allocBytesSink) view() (ByteView, error) {
    return s.v, nil
}

//【设置allocBytesSink的v，同时复制v中的b或者s丢给dst】
func (s *allocBytesSink) setView(v ByteView) error {
    if v.b != nil {
        *s.dst = cloneBytes(v.b)
    } else {
        *s.dst = []byte(v.s)
    }
    s.v = v
    return nil
}

//【这个得从下面的setBytesOwned开始往上看】
func (s *allocBytesSink) SetProto(m proto.Message) error {
    b, err := proto.Marshal(m)
    if err != nil {
        return err
    }
    return s.setBytesOwned(b)
}

//【复制一份b，然后调用setBytesOwned】
func (s *allocBytesSink) SetBytes(b []byte) error {
    return s.setBytesOwned(cloneBytes(b))
}

//【使用b设置allocBytesSink的dst和ByteView】
func (s *allocBytesSink) setBytesOwned(b []byte) error {
    if s.dst == nil {
        return errors.New("nil AllocatingByteSliceSink *[]byte dst")
    }
    *s.dst = cloneBytes(b) // another copy, protecting the read-only s.v.b view
    s.v.b = b
    s.v.s = ""
    return nil
}

//【字符串转成[]byte后进行和上面类似的操作】
func (s *allocBytesSink) SetString(v string) error {
    if s.dst == nil {
        return errors.New("nil AllocatingByteSliceSink *[]byte dst")
    }
    *s.dst = []byte(v)
    s.v.b = nil
    s.v.s = v
    return nil
}

// TruncatingByteSliceSink returns a Sink that writes up to len(*dst)
// bytes to *dst. If more bytes are available, they're silently
// truncated. If fewer bytes are available than len(*dst), *dst
// is shrunk to fit the number of bytes available.
//【截面字节切片Sink，写入len(*dst)个字节到dst，如果长度超了会被截断，
//少了则dst会收缩长度来适配】
func TruncatingByteSliceSink(dst *[]byte) Sink {
    return &truncBytesSink{dst: dst}
}

type truncBytesSink struct {
    dst *[]byte
    v   ByteView
}

func (s *truncBytesSink) view() (ByteView, error) {
    return s.v, nil
}

//【从下面的setBytesOwned开始看】
func (s *truncBytesSink) SetProto(m proto.Message) error {
    b, err := proto.Marshal(m)
    if err != nil {
        return err
    }
    return s.setBytesOwned(b)
}

func (s *truncBytesSink) SetBytes(b []byte) error {
    return s.setBytesOwned(cloneBytes(b))
}

func (s *truncBytesSink) setBytesOwned(b []byte) error {
    if s.dst == nil {
        return errors.New("nil TruncatingByteSliceSink *[]byte dst")
    }
    n := copy(*s.dst, b)
    //【收缩】
    if n < len(*s.dst) {
        *s.dst = (*s.dst)[:n]
    }
    s.v.b = b
    s.v.s = ""
    return nil
}

func (s *truncBytesSink) SetString(v string) error {
    if s.dst == nil {
        return errors.New("nil TruncatingByteSliceSink *[]byte dst")
    }
    n := copy(*s.dst, v)
    //【收缩】
    if n < len(*s.dst) {
        *s.dst = (*s.dst)[:n]
    }
    s.v.b = nil
    s.v.s = v
    return nil
}

ok，这次先介绍到这里，下一讲我们来看peers.go和http.go中都写了些什么。