vitess源码阅读笔记cache系列之memcache客户端(兼谈让人又爱又恨的gc和golang的错误处理机制)

//学习构造Reader和Writer即可，这中方式在golang中非常普遍
func newConnection(nc net.Conn) *Connection {
    return &Connection{
        conn: nc,
        buffered: bufio.ReadWriter{
            bufio.NewReader(nc),        //只要实现了Read接口就可以用来构造Reader
            bufio.NewWriter(nc),        //只要实现了Write接口就可以用来构造Writer
        },
    }
}

func (self *Connection) Close() {
    self.conn.Close()
    self.conn = nil        //用于判断一个connection是否关闭了，见IsClosed函数
}

func (self *Connection) IsClosed() bool {
    return self.conn == nil

func (self *Connection) Get(key string) (value []byte, flags uint16, err error) { //有名字的函数返回值，以后写个return就自动返回这些啦
    defer handleError(&err)
    value, flags, _ = self.get("get", key)
    return

func (self *Connection) Gets(key string) (value []byte, flags uint16, cas uint64, err error) { 
    defer handleError(&err)
    value, flags, cas = self.get("gets", key)
    return
}

func (self *Connection) Set(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
    defer handleError(&err)
    return self.store("set", key, flags, timeout, value, 0), nil
}

func (self *Connection) Add(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
    defer handleError(&err)
    return self.store("add", key, flags, timeout, value, 0), nil
}

func (self *Connection) Replace(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
    defer handleError(&err)
    return self.store("replace", key, flags, timeout, value, 0), nil
}

func (self *Connection) Append(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
    defer handleError(&err)
    return self.store("append", key, flags, timeout, value, 0), nil
}

func (self *Connection) Prepend(key string, flags uint16, timeout uint64, value []byte) (stored bool, err error) {
    defer handleError(&err)
    return self.store("prepend", key, flags, timeout, value, 0), nil
}

func (self *Connection) Cas(key string, flags uint16, timeout uint64, value []byte, cas uint64) (stored bool, err error) {
    defer handleError(&err)
    return self.store("cas", key, flags, timeout, value, cas), nil
}

func (self *Connection) Delete(key string) (deleted bool, err error) {
    defer handleError(&err)
    // delete <key> [<time>] [noreply]\r\n
    self.writestrings("delete ", key, "\r\n")
    reply := self.readline()
    if strings.Contains(reply, "ERROR") {
        panic(NewMemcacheError("Server error"))
    }
    return strings.HasPrefix(reply, "DELETED"), nil
}

type MemcacheError struct {
    Message string
}

//可变参数，这个在golang里面也是个常见的模式
func NewMemcacheError(format string, args ...interface{}) MemcacheError {
    return MemcacheError{fmt.Sprintf(format, args...)}
}

func (self MemcacheError) Error() string {
    return self.Message
}

func handleError(err *error) {
    if x := recover(); x != nil {
        *err = x.(MemcacheError)        //golang是强类型的，interface需要强制要转化一下，这也是golang的常见模式
    }