Server的解耦—通過Router+Controller實現邏輯分發
在實際的系統項目工程中中，我們在寫代碼的時候要盡量避免不必要的耦合，否則你以後在更新和維護代碼的時候會發現如同深陷泥潭，隨便改點東西整個系統都要變動的酸爽會讓你深切後悔自己當初為什麼非要把東西都寫到一塊去（我不會說我剛實習的時候就是這麼乾的。。。）
所以這一篇主要說說如何設計Sever的內部邏輯，將Server處理Client發送資訊的這部分邏輯與Sevrer處理Socket串連的邏輯進行解耦～
這一塊的實現靈感主要是在讀一個HTTP開源架構： Beego 的原始碼的時候產生的，Beego的整個架構就是高度解耦的，這裡引用一下作者的介紹：
beego 是基於八大獨立的模組構建的，是一個高度解耦的架構。當初設計 beego 的時候就是考慮功能模組化，使用者即使不使用 beego 的 HTTP 邏輯，也依舊可以使用這些獨立模組，例如：你可以使用 cache 模組來做你的緩衝邏輯；使用日誌模組來記錄你的操作資訊；使用 config 模組來解析你各種格式的檔案。所以 beego 不僅可以用於 HTTP 類的應用開發，在你的 socket 遊戲開發中也是很有用的模組，這也是 beego 為什麼受歡迎的一個原因。大家如果玩過樂高的話，應該知道很多進階的東西都是一塊一塊的積木搭建出來的，而設計 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)
}
日誌模組的設計與定時任務模組模組
作為一個Server，日誌（Log）功能是必不可少的，一個設計良好的日誌模組，不論是開發Server時的調試，還是運行時候的維護，都是非常有協助的。
因為這裡寫的是一個比較簡化的Server架構，因此我選擇對Golang本身的log庫進行擴充，從而實現一個簡單的Log模組。
在這裡，我將日誌的等級大致分為Debug，Operating，Error 3個等級，Debug主要用於存放調試階段的日誌資訊，Operateing用於儲存Server日常運行時產生的資訊，Error則是儲存報錯資訊。
模組代碼如下：
複製代碼 代碼如下:
func LogErr(v ...interface{}) {
logfile := os.Stdout
log.Println(v...)
logger := log.New(logfile,"\r\n",log.Llongfile|log.Ldate|log.Ltime);
logger.SetPrefix("[Error]")
logger.Println(v...)
defer logfile.Close();
}
func Log(v ...interface{}) {
logfile := os.Stdout
log.Println(v...)
logger := log.New(logfile,"\r\n",log.Ldate|log.Ltime);
logger.SetPrefix("[Info]")
logger.Println(v...)
defer logfile.Close();
}
func LogDebug(v ...interface{}) {
logfile := os.Stdout
log.Println(v...)
logger := log.New(logfile,"\r\n",log.Ldate|log.Ltime);
logger.SetPrefix("[Debug]")
logger.Println(v...)
defer logfile.Close();
}
func CheckError(err error) {
if err != nil {
LogErr(os.Stderr, "Fatal error: %s", err.Error())
}
}
注意這裡log的輸出我使用的是stdout，因為這樣在Server啟動並執行時候可以直接將log重新導向到指定的位置，方便整個Server的部署。不過在日常開發的時候，為了方便調試代碼，我推薦將log輸出到指定檔案位置下，這樣在調試的時候會方便很多（主要是因為golang的調試實在太麻煩，很多時候都要依靠打log的時候進行步進。便於調試的Log模組代碼示意：
複製代碼 代碼如下:
func Log(v ...interface{}) {
logfile := os.OpenFile("server.log",os.O_RDWR|os.O_APPEND|os.O_CREATE,0);
if err != nil {
fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
return }
log.Println(v...)
logger := log.New(logfile,"\r\n",log.Ldate|log.Ltime);
logger.SetPrefix("[Info]")
logger.Println(v...)
defer logfile.Close();
}
然後就是計時迴圈模組啦，日常運行中，Server經常要執行一些定時任務，比如隔一定時間重新整理後台，隔一段時間自動重新整理爬蟲等等，在這裡我設計了一個Task介面，通過類似於TaskList的的方式將所有定時任務註冊後統一執行，代碼如下：
複製代碼 代碼如下:
type DoTask interface {
Excute()
}
var tasklist []interface{}
func AddTask(controller DoTask) {
var arr interface{}
arr = controller
tasklist = append(tasklist,arr)
fmt.Println(tasklist)
}
在這裡以一個定時報時任務作為例子：
複製代碼 代碼如下:
type Task1 struct {}
func (this * Task1)Excute() {
timer := time.NewTicker(2 * time.Second)
for {
select {
case <-timer.C:
go func() {
Log(time.Now())
}()
}
}
}
func init() {
var task1 Task1
tasklist = make([]interface{} ,0 , 20)
AddTask(&task1)
for _, v := range tasklist {
v.(DoTask).Excute()
}
}
注意這裡的定時任務要做成非阻塞的，否則整個Server都會卡在tasklist的第一個task的。。。
