在實際的系統專案工程中中，我們在寫程式碼的時候要儘量避免不必要的耦合，否則你以後在更新和維護程式碼的時候會發現如同深陷泥潭，隨便改點東西整個系統都要變動的酸爽會讓你深切後悔自己當初為什麼非要把東西都寫到一塊去（我不會說我剛實習的時候就是這麼幹的。。。）

       所以這一篇主要說說如何設計Sever的內部邏輯，將Server處理Client傳送資訊的這部分邏輯與Sevrer處理Socket連線的邏輯進行解耦～

       這一塊的實現靈感主要是在讀一個HTTP開源框架： 

    beego 是基於八大獨立的模組構建的，是一個高度解耦的框架。當初設計 beego 的時候就是考慮功能模組化，使用者即使不使用 beego 的 HTTP 邏輯，也依舊可以使用這些獨立模組，例如：你可以使用 cache 模組來做你的快取邏輯；使用日誌模組來記錄你的操作資訊；使用 config 模組來解析你各種格式的檔案。所以 beego 不僅可以用於 HTTP 類的應用開發，在你的 socket 遊戲開發中也是很有用的模組，這也是 beego 為什麼受歡迎的一個原因。大家如果玩過樂高的話，應該知道很多高階的東西都是一塊一塊的積木搭建出來的，而設計 beego 的時候，這些模組就是積木，高階機器人就是 beego。
 

       這是一個典型的MVC框架，可以看到，當用戶傳送請求到beego後，Beego內部在通過路由進行引數的過濾，然後路由根據使用者發來的引數判斷呼叫哪個Controller執行相關的邏輯，並在controller裡呼叫相關的模組實現功能。通過這種方式，Beego成功的將所有模組都獨立出來，也就是astaxie所說的“樂高積木化”。

       在這裡，我們可以仿照Beego的架構，在Server內部加入一層Router,通過Router對通過Socket發來的資訊通過我們設定的規則進行判斷後，呼叫相關的Controller進行任務的分發處理。在這個過程中不僅Controller彼此獨立，匹配規則和Controller之間也是相互獨立的。

       下面給出Router的實現程式碼，其中Msg的結構對應的是Json字串，當然考慮到實習公司現在也在用這個，修改了一部分，不過核心思路是一樣的哦：

import (
	"utils"
	"fmt"
	"encoding/json"
)

type Msg struct {
	Conditions   map[string]interface{} `json:"meta"`
	Content interface{}            `json:"content"`
}

type Controller interface {
	Excute(message Msg) []byte
}

var routers [][2]interface{}

func Route(judge interface{} ,controller Controller) {
	switch judge.(type) {
	case func(entry Msg)bool:{
		var arr [2]interface{}
		arr[0] = judge
		arr[1] = controller
		routers = append(routers,arr)
	}
	case map[string]interface{}:{
		defaultJudge:= func(entry Msg)bool{
			for keyjudge , valjudge := range judge.(map[string]interface{}){
				val, ok := entry.Meta[keyjudge]
				if !ok {
					return false
				}
				if val != valjudge {
					return false
				}
			}
			return true
		}
		var arr [2]interface{}
		arr[0] = defaultjudge
		arr[1] = controller
		routers = append(routers,arr)
		fmt.Println(routers)
		}
	default:
		fmt.Println("Something is wrong in Router")
	}
}

      通過自定義介面Router，我們將匹配規則judge和對應的controller封裝了進去，然後在Server端負責接收socket傳送資訊的函式handleConnection那裡再實現Router內部的遍歷即可：

for _ ,v := range routers{
		pred := v[0]
		act := v[1]
		var message Msg
		err := json.Unmarshal(postdata,&message)
		if err != nil {
			Log(err)
		}
		if pred.(func(entry Msg)bool)(message) {
			result := act.(Controller).Excute(message)
			conn.Write(result)
			return
		}
	}

       這樣Client每次發來資訊，我們就可以讓Router自動跟現有的規則進行匹配，最後呼叫對應的Controller進行邏輯的實現啦，下面給出一個controller的編寫例項，這個Controll的作用是發來的json型別是mirror的時候，將Client發來的資訊原樣返回：

type MirrorController struct  {

}

func (this *MirrorController) Excute(message Msg)[]byte {
	mirrormsg,err :=json.Marshal(message)
	CheckError(err)
	return mirrormsg
}


func init() {
	var mirror 
	routers = make([][2]interface{} ,0 , 20)
	Route(func(entry Msg)bool{
		if entry.Meta["msgtype"]=="mirror"{
		return true}
		return  false
	},&mirror)
}

我已經把SocketServer系列的程式碼整合到了一起，釋出到了我個人的github上：點選連結， 希望大家有興趣的可以學習star一下～