剖析Go编写的Socket服务器模块解耦及基础模块的设计

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的。。。