如何用GO語言編寫緩存服務？
隨著互聯網的飛速發展，各行各業對互聯網服務的要求也越來越高，服務架構能撐起多大的業務數據?服務響應的速度能不能達到要求?我們的架構師每天都在思考這些問題。
對于數據庫或者對象存儲等服務來說，它們受限于自己先天的設計目標，往往不能具有很好的性能，響應時間通常是秒級。此時就需要高性能的緩存來為我們的服務提速了，緩存服務的響應時間通常是毫秒級，甚至小于1ms。
緩存服務需要被設置在其他服務的前端，客戶端首先訪問緩存，查詢自己的數據，僅當客戶端需要的數據不存在于緩存中時，才去訪問實際的服務。從實際的服務中獲取到的數據會被放在緩存中，以備下次使用。
緩存的設計目標就是盡可能地快，但它引起了其他的問題。比如目前業界使用較多的緩存服務有Memcached和Redis等，它們都是內存內緩存，單節點***的容量不能超過整個系統的內存。
且一旦服務器重啟，對于Memcached來說就是內容徹底丟失;Redis稍好一點，但也要花費不少時間從磁盤上的數據文件中重新讀入內存。
當我們決定要用Go語言編寫一個緩存服務的時候，首先想到的就是HTTP服務。因為用Go語言寫基于HTTP的緩存服務真的是太方便了，我們只需要一個map來保存數據，寫一個handler負責處理請求，然后調用http.ListenAndServe，***用go run運行。一切就是這么簡單，你不需要去考慮復雜的并發問題，也不需要自己設計一套網絡協議，Go語言的HTTP服務框架會幫你處理好底層的一切。
我們在本文將要實現的是一個簡單的內存緩存服務，所有的緩存數據都存儲在服務器的內存中。一旦服務器重啟，所有的數據都將被清零。
緩存服務的接口
1.1.1 REST接口
本章的接口支持緩存的設置(Set)、獲取(Get)和刪除(Del)這3個基本操作，同時還支持對緩存服務狀態的查詢。Set操作用于將一對鍵值對(key value pair)設置進緩存服務器，它通過HTTP的PUT方法進行;Get操作用于查詢某個鍵并獲取其值，它通過HTTP的GET方法進行;Del操作用于從緩存中刪除某個鍵，它通過HTTP的DELETE方法進行。我們可以查詢的緩存服務狀態包括當前緩存了多少對鍵值對，所有的鍵一共占據了多少字節，所有的值一共占據了多少字節。
- PUT /cache/<key>
- 請求正文
- ● <value>
客戶端通過HTTP的PUT方法將一對鍵值對設置進緩存服務器，服務器將該鍵值對保存在內存堆上創建的map里。
這里/cache/
- GET /cache/<key>
- 響應正文
- ● <value>
客戶端通過HTTP的GET方法從緩存服務器上獲取key對應的value，服務器在map中查找該key，如果key不存在，服務器返回HTTP錯誤代碼404 NOT FOUND;如果key存在，則服務器在HTTP響應正文(response body)中返回相應的value。
- DELETE /cache/
客戶端通過HTTP的DELETE方法將key從緩存中刪除。無論之前該key是否存在，之后它都將不存在，服務器始終返回HTTP錯誤代碼200 OK。
- GET /status
- 響應正文
- ● JSON格式的緩存狀態
客戶端通過這個接口獲取緩存服務的狀態，在HTTP響應正文中返回的狀態是以JSON格式編碼的一個cache.Stat結構體(見例1-3)。
1.1.2 緩存Set流程
我們可以用一張簡單的圖來概括Set流程，見圖1-1。
圖1-1 in memory緩存的Set流程
客戶端的PUT請求提供了key和value。cacheHandler實現了http.Handler接口，其ServeHTTP方法對HTTP請求進行解析，并調用cache.Cache接口的Set方法。
在cache模塊中，inMemoryCache結構體實現Cache接口，其Set方法最終將鍵值對保存在內存的map中。cacheHandler***會返回客戶端一個HTTP錯誤號來表示結果，如果成功則返回的是200 OK，否則返回500 Internal Server Error。
Go語言中的map的含義和用法跟大多數現代編程語言中的map一樣，map是一種用于保存鍵值對的散列表數據結構，可以通過中括號 [ ] 進行key的查詢和設置。
由于程序會對key進行散列和掩碼運算以直接獲取存儲key的偏移量，所以能獲得近乎O(1)的查詢和設置復雜度。之所以說近乎O(1)是因為兩個key在經過散列和掩碼運算后有可能會具有相同的偏移量，此時將不得不繼續進行線性搜索，不過發生這種不幸情況的概率很小。
1.1.3 緩存Get流程
緩存Get流程見圖1-2。
圖1-2 in memory緩存的Get流程
客戶端的Get請求提供了key。cacheHandler的ServeHTTP方法對HTTP請求進行解析，并調用cache.Cache接口的Get方法。inMemoryCache結構體的Get方法在map中查詢key對應的value并返回。cacheHandler會將value寫入HTTP響應正文并返回200 OK，如果cache.Cache.Get方法返回錯誤，cacheHandler會返回500 Internal Server Error。如果value長度為0，說明該key不存在，cacheHandler會返回404 Not Found。
1.1.4 緩存Del流程
緩存Del流程見圖1-3。
圖1-3 in memory緩存的Del流程
客戶端的DELETE請求提供了key。cacheHandler的ServeHTTP方法對HTTP請求進行解析，并調用cache.Cache接口的Del方法。inMemoryCache結構體的Del方法在map中查詢key是否存在，如果存在則調用delete函數刪除該key。如果cache.Cache.Del方法返回錯誤，cacheHandler會返回500 Internal Server Error，否則返回200 OK。
REST接口和處理流程介紹完了，接下來我們來看看如何實現。
Go語言實現
1.2.1 main包的實現
緩存服務的main包只有一個函數，就是main函數。在Go語言中，如果某個項目需要被編譯為可執行程序，那么它的源碼需要有一個main包，其中需要有一個main函數，它用來作為可執行程序的入口函數。如果某個項目不需要被編譯為可執行程序，只是實現一個庫，則可以沒有main包和main函數。我們的緩存服務需要被編譯成一個可執行程序，所以需要提供main包和main函數。main函數的實現見例1-1：
例1-1 main函數
- func main() {
- c := cache.New("inmemory")
- http.New(c).Listen()
- }
我們的main函數非常簡單，它需要做的只是調用cache.New函數創建一個新的cache.Cache接口的實例c，然后以c為參數調用http.New函數創建一個指向http.Server結構體的指針并調用其Listen方法。
cache.New這樣的寫法則是指定我們調用的New函數屬于cache包。Go語言調用同一個包內的函數不需要在函數前面帶上包名，Go編譯器會默認在當前包內查找。調用另一個包中的函數則需要指定包名，讓Go編譯器知道去哪里查找這個函數。這里我們是在main包中調用cache包的New函數，所以需要指定包名。
1.2.2 cache包的實現
我們在cache包中實現服務的緩存功能。在cache包內，我們首先聲明了一個Cache接口，見例1-2。
例1-2 Cache接口
- type Cache interface {
- Set(string, []byte) error
- Get(string) ([]byte, error)
- Del(string) error
- GetStat() Stat
- }
在Go語言中，接口和實現是完全分開的。接口甚至擁有它自己的類型(type interface)。開發者可以自由聲明一個接口，然后以一種或多種方式去實現這個接口。在例1-2中，我們看到的就是一個名為Cache的接口聲明。
在接口內，我們會聲明一些方法，一個接口就是該接口內所有方法的集合。任何結構體只要實現了某個接口聲明的所有方法，我們就認為該結構體實現了該接口。實現某個接口的結構體可以不止一個，這意味著同樣的接口實現的方式可以有很多種，Go語言就是用這種方式來實現多態。
我們的Cache接口一共聲明了4個方法，分別是Set、Get、Del和GetStat。
Set方法用于將鍵值對設置進緩存，它接收兩個參數，類型分別是string和[ ]byte，其中string是key的類型，而[ ]byte則是value的類型，byte前面的中括號意味著它的類型是字節(byte)的切片(slice)。Go語言中切片的內部實現可以被認為是一個指向切片***個元素的地址和該切片的長度。切片和數組(Array)的區別在于數組的長度是固定的，而切片則是底層數組的一個視圖，其長度可以動態調整。Set方法的返回值只有一個。若返回值的類型是error，則用于返回Set操作的錯誤，當Set操作成功時，返回nil。
Get方法根據key從緩存中獲取value，所以它接收一個string類型的參數，返回值則是兩個，分別是 [ ]byte和error。在Go語言中，當函數具有多個返回值時，需要用小括號()將它們括在一起。
Del方法從緩存中刪除key，所以它只有一個string類型的參數和一個error類型的返回值。
GetStat方法用于獲取緩存的狀態，它沒有參數，只有一個Stat類型的返回值。Stat是一種結構體，見例1-3。
例1-3 Stat結構體相關實現
- type Stat struct {
- Count int64
- KeySize int64
- ValueSize int64
- }
- func (s *Stat) add(k string, v []byte) {
- s.Count += 1
- s.KeySize += int64(len(k))
- s.ValueSize += int64(len(v))
- }
- func (s *Stat) del(k string, v []byte) {
- s.Count -= 1
- s.KeySize -= int64(len(k))
- s.ValueSize -= int64(len(v))
- }
Go語言編程僅僅聲明接口類型(type interface)是沒用的，還必須實現接口。而接口的實現需要依附于某個結構體類型(type struct)。Stat就是一個結構體，它的內部有3個字段，Count用于表示緩存目前保存的鍵值對數量，KeySize和ValueSize分別表示key和value占據的總字節數。
結構體也可以包含方法，和接口不同的地方在于結構體必須實現這些方法，而接口只需要聲明。Stat結構體實現了add和del兩個方法，這兩個方法分別用于新加鍵值對和刪除鍵值對時改變緩存的狀態。
在了解完整個Cache接口之后，我們就可以去看看New函數的實現了，見例1-4。
例1-4 New函數實現
- func New(typ string) Cache {
- var c Cache
- if typ == "inmemory" {
- c = newInMemoryCache()
- }
- if c == nil {
- panic("unknown cache type " + typ)
- }
- log.Println(typ, "ready to serve")
- return c
- }
cache包的New函數用來創建并返回一個Cache接口，它接收一個string類型的參數typ，typ用于指定需要創建的Cache接口的具體結構體類型。
我們在函數體的***行聲明了一個類型為Cache接口的變量c，當typ字符串等于“inmemory”時，我們將newInMemoryCache函數的返回值賦值給c。如果c為nil，我們調用panic報錯并退出整個程序，否則我們打印一條日志通知緩存開始服務并將c返回。
本文實現的緩存服務是一種內存緩存(in memory)，實現Cache接口的結構體名為inMemoryCache，見例1-5。
例1-5 inMemoryCache相關代碼
- type inMemoryCache struct {
- c map[string][]byte
- mutex sync.RWMutex
- Stat
- }
- func (c *inMemoryCache) Set(k string, v []byte) error {
- c.mutex.Lock()
- defer c.mutex.Unlock()
- tmp, exist := c.c[k]
- if exist {
- c.del(k, tmp)
- }
- c.c[k] = v
- c.add(k, v)
- return nil
- }
- func (c *inMemoryCache) Get(k string) ([]byte, error) {
- c.mutex.RLock()
- defer c.mutex.RUnlock()
- return c.c[k], nil
- }
- func (c *inMemoryCache) Del(k string) error {
- c.mutex.Lock()
- defer c.mutex.Unlock()
- v, exist := c.c[k]
- if exist {
- delete(c.c, k)
- c.del(k, v)
- }
- return nil
- }
- func (c *inMemoryCache) GetStat() Stat {
- return c.Stat
- }
- func newInMemoryCache() *inMemoryCache {
- return &inMemoryCache{make(map[string][]byte), sync.RWMutex{}, Stat{}}
- }
inMemoryCache結構體包含一個成員c，類型是以string為key、以 [ ]byte為value的map，用來保存鍵值對;一個mutex，類型是sync.RWMutex，用來對map的并發訪問提供讀寫鎖保護;一個Stat，用來記錄緩存狀態。
Go語言的map可以支持多個goroutine同時讀，但不能支持多個goroutine同時寫或同時既讀又寫，所以我們必須用一個讀寫鎖保護map的并發讀寫，當多個goroutine同時讀時，它們會調用mutex.RLock()，互不影響。
當有至少一個goroutine需要寫時，它會調用mutex.Lock()，此時它會等待所有其他讀寫鎖釋放，然后自己加鎖，在它加鎖后其他goroutine需要加鎖則必須等待它先解鎖。讀寫鎖mutex的類型是sync.RWMutex，sync是Go語言自帶的一個標準包，它提供了包括Mutex、RWMutex在內的多種互斥鎖的實現。
需要特別注意的是Stat，它的類型是Stat結構體，但是它沒有提供成員名字，這種寫法在Go語言中被稱為內嵌。結構體可以內嵌多個結構體和接口，接則只能內嵌多個接口。
Go語言通過內嵌來實現繼承，內嵌結構體/接口可以被認為是外層結構體/接口的父類。一個內嵌結構體/接口的所有成員/方法都可以通過外層結構體/接口直接訪問，那些成員/方法的首字母不需要大寫。(通常我們從一個結構體外部只能訪問其首字母大寫的成員/方法，訪問自己的內嵌成員的成員/方法不受此限制。)當我們需要訪問某個內嵌成員本身時，我們可以直接用它的類型指代它，就如同我們在inMemoryCache.GetStat函數中做的那樣。
1.2.3 HTTP包的實現
HTTP包用來實現我們的HTTP服務功能。由于不需要使用多態，我們在HTTP包里并沒有聲明接口，而是直接聲明了一個Server結構體，見例1-6。
例1-6 Server相關實現
- type Server struct {
- cache.Cache
- }
- func (s *Server) Listen() {
- http.Handle("/cache/", s.cacheHandler())
- http.Handle("/status", s.statusHandler())
- http.ListenAndServe(":12345", nil)
- }
- func New(c cache.Cache) *Server {
- return &Server{c}
- }
Server結構體中內嵌了cache.Cache，cache.Cache就是之前介紹的cache包的Cache接口。HTTP包的Server結構體內嵌該接口意味著http.Server也實現了cache.Cache接口，而實現的方式則由實際的內嵌結構體決定。
接下來我們看到Server的Listen方法會調用http.Handle函數，它會注冊兩個Handler分別用來處理/cache/和/status這兩個HTTP協議的端點。
這里需要注意的是http.Handle函數并不屬于我們的HTTP包，而是Go語言自己的net/http標準包。還記得嗎?Server結構體自身就處于我們的HTTP包里，引用自己包內的名字無需指定包名，所以當我們指定HTTP包名時，Go語言編譯器會知道去net/http包中查找名字。
Server.cacheHandler方法返回的是一個http.Handler接口，它用來處理HTTP端點/cache/的請求，也就是緩存的Set、Get、Del這3個基本操作，見例1-7。
例1-7 cacheHandler相關實現
- type cacheHandler struct {
- *Server
- }
- func (h *cacheHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
- key := strings.Split(r.URL.EscapedPath(), "/")[2]
- if len(key) == 0 {
- w.WriteHeader(http.StatusBadRequest)
- return
- }
- m := r.Method
- if m == http.MethodPut {
- b, _ := ioutil.ReadAll(r.Body)
- if len(b) != 0 {
- e := h.Set(key, b)
- if e != nil {
- log.Println(e)
- w.WriteHeader(http.Status InternalServerError)
- }
- }
- return
- }
- if m == http.MethodGet {
- b, e := h.Get(key)
- if e != nil {
- log.Println(e)
- w.WriteHeader(http.StatusInternalServer Error)
- return
- }
- if len(b) == 0 {
- w.WriteHeader(http.StatusNotFound)
- return
- }
- w.Write(b)
- return
- }
- if m == http.MethodDelete {
- e := h.Del(key)
- if e != nil {
- log.Println(e)
- w.WriteHeader(http.StatusInternal ServerError)
- }
- return
- }
- w.WriteHeader(http.StatusMethodNotAllowed)
- }
- func (s *Server) cacheHandler() http.Handler {
- return &cacheHandler{s}
- }
cacheHandler結構體內嵌了一個Server結構體的指針，并實現了ServeHTTP方法，實現該方法就意味著實現了http.Handler接口。例1-8展示了Go語言標準包net/http對Handler接口的定義。
例1-8 Go標準包net/http中Handler接口的定義
- type Handler interface {
- ServeHTTP(ResponseWriter, *Request)
- }
cacheHandler的ServeHTTP方法解析URL以獲取key，并根據HTTP請求的3種方式PUT/GET/DELETE決定調用cache.Cache的Set/Get/Del方法。
這里我們看到了Go語言內嵌的高階使用方式——多重內嵌：cacheHandler內嵌了Server結構體指針，而Server內嵌了cache.Cache接口。于是cacheHandler就可以直接訪問cache.Cache的方法了。
Server.statusHandler方法同樣返回一個http.Handler接口，其實現見例1-9。
例1-9 statusHandler相關實現
- type statusHandler struct {
- *Server
- }
- func (h *statusHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
- if r.Method != http.MethodGet {
- w.WriteHeader(http.StatusMethodNotAllowed)
- return
- }
- b, e := json.Marshal(h.GetStat())
- if e != nil {
- log.Println(e)
- w.WriteHeader(http.StatusInternalServerError)
- return
- }
- w.Write(b)
- }
- func (s *Server) statusHandler() http.Handler {
- return &statusHandler{s}
- }
和cacheHandler一樣，statusHandler內嵌Server結構體指針并實現ServeHTTP方法。該方法調用cache.Cache的GetStat方法并將返回的cache.Stat結構體用JSON格式編碼成字節切片b，寫入HTTP的響應正文。
如果你是一位程序員，看到這里你的心里可能會有一個疑問。我們這樣實現會不會太復雜了?為了處理兩個HTTP端點的請求，我們需要實現兩個Handler結構體并分別實現它們的ServeHTTP方法，能不能直接在Server結構體上實現ServeHTTP方法并根據URL區分不同的HTTP請求?
從實現上來說是可行的，但是那意味著Server的ServeHTTP需要承擔兩個不同的職責，處理兩類HTTP請求。將這兩類請求分開到不同的結構體內實現符合SOLID的單一職責原則。
Go語言的實現介紹完了，接下來我們需要把程序運行起來，并進行功能測試來驗證我們的實現。
