只會golang,只會心疼giegie

本文目錄一覽：

• 1、Golang 新手該怎麼提升能力
• 2、怎麼學習golang
• 3、徹底理解Golang Map
• 4、用golang會不會被制裁
• 5、go語言實現一個簡單的簡單網關

Golang 新手該怎麼提升能力

新手入門技巧：

1.升級你的角色等級

Pokemon GO 遊戲如果你的目標不是只有 「收集所有神奇寶貝” 的話,而是想用心玩這款遊戲,那角色等級絕對是最重要的一環,甚至比抓到稀有神奇寶貝還重要。

等級高,你才能解鎖與獲得更多道具,如:更強的寶貝球、讓你更好抓神奇寶貝的 Razz Berry、經驗值兩倍的 Lucky Egg、吸引野生神奇寶貝的 Incense 等等。

等級高,你才能抓到 CP (戰鬥力)更強的神奇寶貝。

等級越高,你才能提升更多神奇寶貝的能力(CP 與 HP)。

升級到 5 級才能進到 GYM 里跟其他玩家戰鬥。

2.不要擔心寶貝球不夠

寶貝球是一個非常容易取得的道具,幾乎每一個 PokeStop 都能獲得兩個以上,等你玩久之後一定會嫌寶貝球數量太多(背包預設只能裝 350 個道具),把它丟掉會變成非常平常的事,所以抓神奇寶貝時不用害怕丟歪失手,盡情的試手感與角度吧!不過還是要注意次數,小心神奇寶貝會烙跑走。

3.抓光每一個你所看到的神奇寶貝

跟一開始一樣,如果你的目標不是只有 「收集所有神奇寶貝”,那隻要是地圖中出現的神奇寶貝,就全部都抓光吧!每抓一隻都能獲得經驗值、STARDUST 與 CANDY,而這些都是遊戲中非常重要的元素。

4.先不要提升與進化你的神奇寶貝

剛開始玩時角色等級還太低,因此抓的神奇寶貝 CP 戰鬥力都會很低,幾乎只有 100 以下,所以千萬不要急着提升或進化神奇寶貝,把 STARDUST 與 CANDY 保留下來,等到等級變高開始抓到 CP 200、甚至是 300 以上再決定也不遲,而且你還有機會抓到已經進化過的神奇寶貝。

5.只保留 CP 高與能力強的神奇寶貝(僅限初期)

CP 值(戰鬥力)越高,基本上也代表神奇寶貝越強,因此當你抓到相同的神奇寶貝時,如果 CP 值差 30 以上,就不要猶豫把它 TRANSFER 換成 CANDY 吧!這樣也不佔空間。而等到後期開始專心養育神奇寶貝時,可以參考這篇文章,把素質最好的神奇寶貝找出來。

資訊頁面下方可看到它的攻擊能力,每一位神奇寶貝都有兩種,上面是普通攻擊、下面為絕招,目前還沒有數據表示哪種能力比較強,就筆者經驗來說,數字越高也代表攻擊力越強,因此如果是 CP 很接近的神奇寶貝,就從這邊比較,保留攻擊力強的那隻就對了!

6.慎選使用 Incense 與 Lucky Egg 的時機

當等級升到 5 級以及 7 級時,你會各獲得一個 Incense 道具(30 分鐘內吸引更多的野生神奇寶貝),筆者會建議先使用一個就好,另一個等到 9 級獲得 Lucky Egg(30 分鐘內可兩倍經驗值) 時再用,效果會更好。

Lucky Egg 與 Incense 同時使用的效果非常不錯,30 分鐘內你一定會抓到非常多神奇寶貝,而每抓一個可獲得 100XP,經驗值兩倍之後變 200XP,如果是新的神奇寶貝再加 500XP,兩倍之後變 1000XP,30 分鐘過後你的經驗值絕對是用暴增,連升兩級都有可能,所以說不要急的把 Lucky Egg 或 Incense 用掉,等到兩個都擁有時再用效果是最大的!

7.Pokestops 的更新速度很快

Pokestops 是用來提供玩家道具的物件,因此更新速度非常快,當你翻轉過一次變成紫色後,只要等個 1~2 分鐘 5 分鐘就會再變回藍色,因此如果你缺道具又懶得一直走的話,就找一個翻得到 2~3 Pokestops 的位置待着,不到一小時你絕對能獲得非常多道具。(經實測確定是 5 分鐘,之前筆者邊寫文章邊測才會感覺更新超快的錯覺)

如果你住的地方就能翻到 Pokestops,那真的非常幸運,不僅有無限道具可以取得,待在家也能賺 XP 經驗值,不用走來走去。(每翻一次可獲得 50XP)。

8.捕捉 Pokemon 神奇寶貝時需不需要停下來?

這點筆者相信很多玩家都很好奇,答案是:不用!

只要是進入抓 Pokemon 神奇寶貝的畫面後,即便你離碰到的位置超過 1 公里(誇飾法),都能正常捕捉,唯一要注意是如果你有開啟 AR,那就手機畫面就必須保持碰到神奇寶貝的方向才能看到它,沒開啟 AR 的玩家則怎麼移動都沒關係。

不過安全第一,筆者還是建議抓神奇寶貝時停下來,才不會發生任何意外,除非你目前正在搭車。

9.不用太擔心 Pokemon GO 是不是很耗網路流量

繼 T-Moblie 之後,香港 CSL Mobile 也表示會推出 Pokemon GO 無限網路流量服務,因此很多玩家都誤認為 Pokemon GO 非常耗網路流量,事實上你不用太擔心!

根據筆者玩兩周的經驗,角色等級已升級到 14,收集上百隻神奇寶貝,平時在外也正常使用 F

怎麼學習golang

已經有好多程序員都把Go語言描述為是一種所見即所得(WYSIWYG)的編程語言。這是說，代碼要做的事和它在字面上表達的意思是完全一致的。 在這些新語言中，包含D，Go，Rust和Vala語言，Go曾一度出現在TIOBE的排行榜上面。與其他新語言相比，Go的魅力明顯要大很多。Go的成熟特徵會得到許多開發者的欣賞，而不僅僅是因為其誇大其詞的曝光度。下面我們來一起探討一下谷歌開發的Go語言以及談談Go為什麼會吸引眾多開發者： 快速簡單的編譯 Go編譯速度很快，如此快速的編譯使它很容易作為腳本語言使用。關於編譯速度快主要有以下幾個原因：首先，Go不使用頭文件；其次如果一個模塊是依賴A的，這反過來又取決於B，在A裏面的需求改變只需重新編譯原始模塊和與A相依賴的地方；最後，對象模塊裏面包含了足夠的依賴關係信息，所以編譯器不需要重新創建文件。你只需要簡單地編譯主模塊，項目中需要的其他部分就會自動編譯，很酷，是不是？ 通過返回數值列表來處理錯誤信息 目前，在本地語言裏面處理錯誤的方式主要有兩種：直接返回代碼或者拋異常。這兩種都不是最理想的處理方式。其中返回代碼是非常令人沮喪的，因為返回的錯誤代碼經常與從函數中返回的數據相衝突。Go允許函數返回多個值來解決這個問題。這個從函數裏面返回的值，可以用來檢查定義的類型是否正確並且可以隨時隨地對函數的返回值進行檢查。如果你對錯誤值不關心，你可以不必檢查。在這兩種情況下，常規的返回值都是可用的。 簡化的成分（優先於繼承） 通過使用接口，類型是有資格成為對象中一員的，就像Java指定行為一樣。例如在標準庫裏面的IO包，定義一個Writer來指定一個方法，一個Writer函數，其中輸入參數是位元組數組並且返回整數類型值或者錯誤類型。任何類型實現一個帶有相同簽名的Writer方法是對IO的完全實現，Writer接口。這種是解耦代碼而不是優雅。它還簡化了模擬對象來進行單元測試。例如你想在數據庫對象中測試一個方法，在標準語言中，你通常需要創建一個數據庫對象，並且需要進行大量的初始化和協議來模擬對象。在Go裏面，如果該方法需要實現一個接口，你可以創建任何對該接口有用的對象，所以，你創建了MockDatabase，這是很小的對象，只實現了幾個需要運行和模擬的接口——沒有構造函數，沒有附件功能，只是一些方法。 簡化的並發性 相對於其他語言，並發性在Go裏面顯得更加容易。把『go』關鍵字放在任意函數前面然後那個函數就會在其go-routine自動運行（一個很輕的線程）。go-routines是通過通道進行交流並且基本上封鎖了所有的隊列消息。普通工具對相互排斥是有用，但是Go通過使用通道來踢掉並發性任務和坐標更加容易。 優秀的錯誤消息 所有與Go相似的語言，自身作出的診斷都是無法與Go相媲美的。例如，一個死鎖程序，在Go運行時會通知你目前哪個線程導致了這種死鎖。編譯的錯誤信息是非常詳細全面和有用的。 其他 這裡還有許多其他吸引人的地方，下面就一概而過的介紹一下，比如高階函數、垃圾回收、哈希映射和可擴展的數組內置語言（部分語言語法，而不是作為一個庫）等等。 當然，Go並不是完美無瑕。在工具方面還有些不成熟的地方和用戶社區較小等，但是隨着谷歌語言的不斷發展，肯定會有整治措施出來。儘管許多語言，尤其是D、Rust和Vala旨在簡化C++並且對其進行簡化，但它們給人的感覺仍是「C++看上去要更好」。

【Go語言的優勢】

可直接編譯成機器碼，不依賴其他庫，glibc的版本有一定要求，部署就是扔一個文件上去就完成了。

靜態類型語言，但是有動態語言的感覺，靜態類型的語言就是可以在編譯的時候檢查出來隱藏的大多數問題，動態語言的感覺就是有很多的包可以使用，寫起來的效率很高。

語言層面支持並發，這個就是Go最大的特色，天生的支持並發，我曾經說過一句話，天生的基因和整容是有區別的，大家一樣美麗，但是你喜歡整容的還是天生基因的美麗呢？Go就是基因裏面支持的並發，可以充分的利用多核，很容易的使用並發。

內置runtime，支持垃圾回收，這屬於動態語言的特性之一吧，雖然目前來說GC不算完美，但是足以應付我們所能遇到的大多數情況，特別是Go1.1之後的GC。

簡單易學，Go語言的作者都有C的基因，那麼Go自然而然就有了C的基因，那麼Go關鍵字是25個，但是表達能力很強大，幾乎支持大多數你在其他語言見過的特性：繼承、重載、對象等。

豐富的標準庫，Go目前已經內置了大量的庫，特別是網絡庫非常強大，我最愛的也是這部分。

內置強大的工具，Go語言裏面內置了很多工具鏈，最好的應該是gofmt工具，自動化格式化代碼，能夠讓團隊review變得如此的簡單，代碼格式一模一樣，想不一樣都很困難。

跨編譯，如果你寫的Go代碼不包含cgo，那麼就可以做到window系統編譯linux的應用，如何做到的呢？Go引用了plan9的代碼，這就是不依賴系統的信息。

內嵌C支持，前面說了作者是C的作者，所以Go裏面也可以直接包含c代碼，利用現有的豐富的C庫。

徹底理解Golang Map

本文目錄如下，閱讀本文後，將一網打盡下面Golang Map相關面試題

Go中的map是一個指針，佔用8個位元組，指向hmap結構體; 源碼 src/runtime/map.go 中可以看到map的底層結構

每個map的底層結構是hmap，hmap包含若干個結構為bmap的bucket數組。每個bucket底層都採用鏈表結構。接下來，我們來詳細看下map的結構

bmap 就是我們常說的「桶」，一個桶裏面會最多裝 8 個 key，這些 key 之所以會落入同一個桶，是因為它們經過哈希計算後，哈希結果是「一類」的，關於key的定位我們在map的查詢和插入中詳細說明。在桶內，又會根據 key 計算出來的 hash 值的高 8 位來決定 key 到底落入桶內的哪個位置（一個桶內最多有8個位置)。

bucket內存數據結構可視化如下：

注意到 key 和 value 是各自放在一起的，並不是 key/value/key/value/… 這樣的形式。源碼里說明這樣的好處是在某些情況下可以省略掉 padding字段，節省內存空間。

當 map 的 key 和 value 都不是指針，並且 size 都小於 128 位元組的情況下，會把 bmap 標記為不含指針，這樣可以避免 gc 時掃描整個 hmap。但是，我們看 bmap 其實有一個 overflow 的字段，是指針類型的，破壞了 bmap 不含指針的設想，這時會把 overflow 移動到 extra 字段來。

map是個指針，底層指向hmap，所以是個引用類型

golang 有三個常用的高級類型 slice 、map、channel, 它們都是 引用類型 ，當引用類型作為函數參數時，可能會修改原內容數據。

golang 中沒有引用傳遞，只有值和指針傳遞。所以 map 作為函數實參傳遞時本質上也是值傳遞，只不過因為 map 底層數據結構是通過指針指向實際的元素存儲空間，在被調函數中修改 map，對調用者同樣可見，所以 map 作為函數實參傳遞時表現出了引用傳遞的效果。

因此，傳遞 map 時，如果想修改map的內容而不是map本身，函數形參無需使用指針

map 底層數據結構是通過指針指向實際的元素 存儲空間 ，這種情況下，對其中一個map的更改，會影響到其他map

map 在沒有被修改的情況下，使用 range 多次遍歷 map 時輸出的 key 和 value 的順序可能不同。這是 Go 語言的設計者們有意為之，在每次 range 時的順序被隨機化，旨在提示開發者們，Go 底層實現並不保證 map 遍歷順序穩定，請大家不要依賴 range 遍歷結果順序。

map 本身是無序的，且遍歷時順序還會被隨機化，如果想順序遍歷 map，需要對 map key 先排序，再按照 key 的順序遍歷 map。

map默認是並發不安全的，原因如下：

Go 官方在經過了長時間的討論後，認為 Go map 更應適配典型使用場景（不需要從多個 goroutine 中進行安全訪問），而不是為了小部分情況（並發訪問），導致大部分程序付出加鎖代價（性能），決定了不支持。

場景: 2個協程同時讀和寫，以下程序會出現致命錯誤：fatal error: concurrent map writes

如果想實現map線程安全，有兩種方式：

方式一：使用讀寫鎖 map + sync.RWMutex

方式二：使用golang提供的 sync.Map

sync.map是用讀寫分離實現的，其思想是空間換時間。和map+RWLock的實現方式相比，它做了一些優化：可以無鎖訪問read map，而且會優先操作read map，倘若只操作read map就可以滿足要求(增刪改查遍歷)，那就不用去操作write map(它的讀寫都要加鎖)，所以在某些特定場景中它發生鎖競爭的頻率會遠遠小於map+RWLock的實現方式。

golang中map是一個kv對集合。底層使用hash table，用鏈表來解決衝突 ，出現衝突時，不是每一個key都申請一個結構通過鏈表串起來，而是以bmap為最小粒度掛載，一個bmap可以放8個kv。在哈希函數的選擇上，會在程序啟動時，檢測 cpu 是否支持 aes，如果支持，則使用 aes hash，否則使用 memhash。

map有3鍾初始化方式，一般通過make方式創建

map的創建通過生成彙編碼可以知道，make創建map時調用的底層函數是 runtime.makemap 。如果你的map初始容量小於等於8會發現走的是 runtime.fastrand 是因為容量小於8時不需要生成多個桶，一個桶的容量就可以滿足

makemap函數會通過 fastrand 創建一個隨機的哈希種子，然後根據傳入的 hint 計算出需要的最小需要的桶的數量，最後再使用 makeBucketArray 創建用於保存桶的數組，這個方法其實就是根據傳入的 B 計算出的需要創建的桶數量在內存中分配一片連續的空間用於存儲數據，在創建桶的過程中還會額外創建一些用於保存溢出數據的桶，數量是 2^(B-4) 個。初始化完成返回hmap指針。

找到一個 B，使得 map 的裝載因子在正常範圍內

Go 語言中讀取 map 有兩種語法：帶 comma 和 不帶 comma。當要查詢的 key 不在 map 里，帶 comma 的用法會返回一個 bool 型變量提示 key 是否在 map 中；而不帶 comma 的語句則會返回一個 value 類型的零值。如果 value 是 int 型就會返回 0，如果 value 是 string 類型，就會返回空字符串。

map的查找通過生成彙編碼可以知道，根據 key 的不同類型，編譯器會將查找函數用更具體的函數替換，以優化效率：

函數首先會檢查 map 的標誌位 flags。如果 flags 的寫標誌位此時被置 1 了，說明有其他協程在執行「寫」操作，進而導致程序 panic。這也說明了 map 對協程是不安全的。

key經過哈希函數計算後，得到的哈希值如下（主流64位機下共 64 個 bit 位）：

m: 桶的個數

從buckets 通過 hash m 得到對應的bucket，如果bucket正在擴容，並且沒有擴容完成，則從oldbuckets得到對應的bucket

計算hash所在桶編號：

用上一步哈希值最後的 5 個 bit 位，也就是 01010 ，值為 10，也就是 10 號桶（範圍是0~31號桶）

計算hash所在的槽位:

用上一步哈希值哈希值的高8個bit 位，也就是 10010111 ，轉化為十進制，也就是151，在 10 號 bucket 中尋找** tophash 值（HOB hash）為 151* 的 槽位**，即為key所在位置，找到了 2 號槽位，這樣整個查找過程就結束了。

如果在 bucket 中沒找到，並且 overflow 不為空，還要繼續去 overflow bucket 中尋找，直到找到或是所有的 key 槽位都找遍了，包括所有的 overflow bucket。

通過上面找到了對應的槽位，這裡我們再詳細分析下key/value值是如何獲取的：

bucket 里 key 的起始地址就是 unsafe.Pointer(b)+dataOffset。第 i 個 key 的地址就要在此基礎上跨過 i 個 key 的大小；而我們又知道，value 的地址是在所有 key 之後，因此第 i 個 value 的地址還需要加上所有 key 的偏移。

通過彙編語言可以看到，向 map 中插入或者修改 key，最終調用的是 mapassign 函數。

實際上插入或修改 key 的語法是一樣的，只不過前者操作的 key 在 map 中不存在，而後者操作的 key 存在 map 中。

mapassign 有一個系列的函數，根據 key 類型的不同，編譯器會將其優化為相應的「快速函數」。

我們只用研究最一般的賦值函數 mapassign 。

map的賦值會附帶着map的擴容和遷移，map的擴容只是將底層數組擴大了一倍，並沒有進行數據的轉移，數據的轉移是在擴容後逐步進行的，在遷移的過程中每進行一次賦值（access或者delete）會至少做一次遷移工作。

1.判斷map是否為nil

每一次進行賦值/刪除操作時，只要oldbuckets != nil 則認為正在擴容，會做一次遷移工作，下面會詳細說下遷移過程

根據上面查找過程，查找key所在位置，如果找到則更新，沒找到則找空位插入即可

經過前面迭代尋找動作，若沒有找到可插入的位置，意味着需要擴容進行插入，下面會詳細說下擴容過程

通過彙編語言可以看到，向 map 中刪除 key，最終調用的是 mapdelete 函數

刪除的邏輯相對比較簡單，大多函數在賦值操作中已經用到過，核心還是找到 key 的具體位置。尋找過程都是類似的，在 bucket 中挨個 cell 尋找。找到對應位置後，對 key 或者 value 進行「清零」操作，將 count 值減 1，將對應位置的 tophash 值置成 Empty

再來說觸發 map 擴容的時機：在向 map 插入新 key 的時候，會進行條件檢測，符合下面這 2 個條件，就會觸發擴容：

1、裝載因子超過閾值

源碼里定義的閾值是 6.5 (loadFactorNum/loadFactorDen)，是經過測試後取出的一個比較合理的因子

我們知道，每個 bucket 有 8 個空位，在沒有溢出，且所有的桶都裝滿了的情況下，裝載因子算出來的結果是 8。因此當裝載因子超過 6.5 時，表明很多 bucket 都快要裝滿了，查找效率和插入效率都變低了。在這個時候進行擴容是有必要的。

對於條件 1，元素太多，而 bucket 數量太少，很簡單：將 B 加 1，bucket 最大數量( 2^B )直接變成原來 bucket 數量的 2 倍。於是，就有新老 bucket 了。注意，這時候元素都在老 bucket 里，還沒遷移到新的 bucket 來。新 bucket 只是最大數量變為原來最大數量的 2 倍( 2^B * 2 ) 。

2、overflow 的 bucket 數量過多

在裝載因子比較小的情況下，這時候 map 的查找和插入效率也很低，而第 1 點識別不出來這種情況。表面現象就是計算裝載因子的分子比較小，即 map 里元素總數少，但是 bucket 數量多（真實分配的 bucket 數量多，包括大量的 overflow bucket）

不難想像造成這種情況的原因：不停地插入、刪除元素。先插入很多元素，導致創建了很多 bucket，但是裝載因子達不到第 1 點的臨界值，未觸發擴容來緩解這種情況。之後，刪除元素降低元素總數量，再插入很多元素，導致創建很多的 overflow bucket，但就是不會觸發第 1 點的規定，你能拿我怎麼辦？overflow bucket 數量太多，導致 key 會很分散，查找插入效率低得嚇人，因此出台第 2 點規定。這就像是一座空城，房子很多，但是住戶很少，都分散了，找起人來很困難

對於條件 2，其實元素沒那麼多，但是 overflow bucket 數特別多，說明很多 bucket 都沒裝滿。解決辦法就是開闢一個新 bucket 空間，將老 bucket 中的元素移動到新 bucket，使得同一個 bucket 中的 key 排列地更緊密。這樣，原來，在 overflow bucket 中的 key 可以移動到 bucket 中來。結果是節省空間，提高 bucket 利用率，map 的查找和插入效率自然就會提升。

由於 map 擴容需要將原有的 key/value 重新搬遷到新的內存地址，如果有大量的 key/value 需要搬遷，會非常影響性能。因此 Go map 的擴容採取了一種稱為「漸進式」的方式，原有的 key 並不會一次性搬遷完畢，每次最多只會搬遷 2 個 bucket。

上面說的 hashGrow() 函數實際上並沒有真正地「搬遷」，它只是分配好了新的 buckets，並將老的 buckets 掛到了 oldbuckets 字段上。真正搬遷 buckets 的動作在 growWork() 函數中，而調用 growWork() 函數的動作是在 mapassign 和 mapdelete 函數中。也就是插入或修改、刪除 key 的時候，都會嘗試進行搬遷 buckets 的工作。先檢查 oldbuckets 是否搬遷完畢，具體來說就是檢查 oldbuckets 是否為 nil。

如果未遷移完畢，賦值/刪除的時候，擴容完畢後（預分配內存），不會馬上就進行遷移。而是採取 增量擴容 的方式，當有訪問到具體 bukcet 時，才會逐漸的進行遷移（將 oldbucket 遷移到 bucket）

nevacuate 標識的是當前的進度，如果都搬遷完，應該和2^B的長度是一樣的

在evacuate 方法實現是把這個位置對應的bucket，以及其衝突鏈上的數據都轉移到新的buckets上。

轉移的判斷直接通過tophash 就可以，判斷tophash中第一個hash值即可

遍歷的過程，就是按順序遍歷 bucket，同時按順序遍歷 bucket 中的 key。

map遍歷是無序的，如果想實現有序遍歷，可以先對key進行排序

為什麼遍歷 map 是無序的？

如果發生過遷移，key 的位置發生了重大的變化，有些 key 飛上高枝，有些 key 則原地不動。這樣，遍歷 map 的結果就不可能按原來的順序了。

如果就一個寫死的 map，不會向 map 進行插入刪除的操作，按理說每次遍歷這樣的 map 都會返回一個固定順序的 key/value 序列吧。但是 Go 杜絕了這種做法，因為這樣會給新手程序員帶來誤解，以為這是一定會發生的事情，在某些情況下，可能會釀成大錯。

Go 做得更絕，當我們在遍歷 map 時，並不是固定地從 0 號 bucket 開始遍歷，每次都是從一個**隨機值序號的 bucket 開始遍歷，並且是從這個 bucket 的一個 隨機序號的 cell **開始遍歷。這樣，即使你是一個寫死的 map，僅僅只是遍歷它，也不太可能會返回一個固定序列的 key/value 對了。

用golang會不會被制裁

用golang不會被制裁。

每一個程序開發軟件都有自己的可取之處，只是錯誤的多少罷了。

golang沒什麼致命的缺陷,但由於Golang崇尚不搞複雜的東西,概念和規則越少越好,有時就會因此遇到不少麻煩。

go語言實現一個簡單的簡單網關

網關=反向代理+負載均衡+各種策略，技術實現也有多種多樣，有基於 nginx 使用 lua 的實現，比如 openresty、kong；也有基於 zuul 的通用網關；還有就是 golang 的網關，比如 tyk。

這篇文章主要是講如何基於 golang 實現一個簡單的網關。

轉自： troy.wang/docs/golang/posts/golang-gateway/

整理：go語言鍾文文檔:

啟動兩個後端 web 服務（代碼）

這裡使用命令行工具進行測試

具體代碼

直接使用基礎庫 httputil 提供的NewSingleHostReverseProxy即可，返回的reverseProxy對象實現了serveHttp方法，因此可以直接作為 handler。

具體代碼

director中定義回調函數，入參為*http.Request，決定如何構造向後端的請求，比如 host 是否向後傳遞，是否進行 url 重寫，對於 header 的處理，後端 target 的選擇等，都可以在這裡完成。

director在這裡具體做了：

modifyResponse中定義回調函數，入參為*http.Response，用於修改響應的信息，比如響應的 Body，響應的 Header 等信息。

最終依舊是返回一個ReverseProxy，然後將這個對象作為 handler 傳入即可。

參考 2.2 中的NewSingleHostReverseProxy，只需要實現一個類似的、支持多 targets 的方法即可，具體實現見後面。

作為一個網關服務，在上面 2.3 的基礎上，需要支持必要的負載均衡策略，比如：

隨便 random 一個整數作為索引，然後取對應的地址即可，實現比較簡單。

具體代碼

使用curIndex進行累加計數，一旦超過 rss 數組的長度，則重置。

具體代碼

輪詢帶權重，如果使用計數遞減的方式，如果權重是5,1,1那麼後端 rs 依次為a,a,a,a,a,b,c,a,a,a,a…，其中 a 後端會瞬間壓力過大；參考 nginx 內部的加權輪詢，或者應該稱之為平滑加權輪詢，思路是：

後端真實節點包含三個權重：

操作步驟：

具體代碼

一致性 hash 算法，主要是用於分佈式 cache 熱點/命中問題；這裡用於基於某 key 的 hash 值，路由到固定後端，但是只能是基本滿足流量綁定，一旦後端目標節點故障，會自動平移到環上最近的那麼個節點。

實現：

具體代碼

每一種不同的負載均衡算法，只需要實現添加以及獲取的接口即可。

然後使用工廠方法，根據傳入的參數，決定使用哪種負載均衡策略。

具體代碼

作為網關，中間件必不可少，這類包括請求響應的模式，一般稱作洋蔥模式，每一層都是中間件，一層層進去，然後一層層出來。

中間件的實現一般有兩種，一種是使用數組，然後配合 index 計數；一種是鏈式調用。

具體代碼