Go語言實現-觀察者模式

前前言

這個類經過我的正式投入使用啊，發現不對勁，這樣做可能會導致線程死鎖

比如你dispatch一個event，然后在這個回調里把那個事件的偵聽給remove掉了，那么就會導致線程死鎖（這個問題找了好久啊，剛剛調試的時候才發現了）

還有就是獲取func的引用的問題，golang那半c半java的語法，我改用了新的方法

源碼已經修改！

前言：

呀，學Go語言兩周了，感覺上手挺快的，golang雖然和c語言很想，但是避免掉了很多指針相關的東東，所以學起來特別輕松。

但是途中坎坷頗多啊，資料是少之又少啊，搜索引擎都搜不到啥東西，唯有golang.org和github的ebook上才有比較完整的資料，加了個golang群么，大牛都潛水不說話，然后我瞎了，只能自己琢磨。

也是自己鬧着玩吧，最近想寫一個服務器（目前已經能同步移動了），我也想學一門后端語言，於是就選了google的go語言了，聽說並發性能挺好的。

然而，golang這語言貌似都是被用作web服務開發了的，群里一般都是在討論web開發的問題，而我是做socket開發的，當然，golang里面不叫socket。

工作比較忙，只有下班后那點時間來學golang了，學得比較基礎，大牛就當走走場好了。

正題：

我是一名頁游前端開發人員，當然我是as3開發者，對as3的觀察者模式-事件機制，那是太依賴了，而golang里面原生並不提供這種機制。

golang有的只是十分相似的goroutine，也就是底層支持的並發機制，然后線程間通訊就是channel，好比於as3中的Event，當然不能直接比較，要封裝過。

觀察者模式就是指一對多的依賴關系，生產者分派消息，消費者全都能收到消息（全局觀察模式），這樣，可以降低模塊間的耦合度，我們要做的，就是來管理這三者。

然后，用golang來實現這一設計模式是很簡單的，我僅用了一百多行，就簡單地實現了，直接看代碼吧：

 

package tbs

import (
    //"fmt"
    "unsafe"
)

type Dispatcher struct {
    listeners map[string]*EventChain
}

type EventChain struct {
    chs       []chan *Event
    callbacks []*EventCallback
}

func createEventChain() *EventChain {
    return &EventChain{chs: []chan *Event{}, callbacks: []*EventCallback{}}
}

type Event struct {
    eventName string
    Params    map[string]interface{}
}

func CreateEvent(eventName string, params map[string]interface{}) *Event {
    return &Event{eventName: eventName, Params: params}
}

type EventCallback func(*Event)

var _instance *Dispatcher

func SharedDispatcher() *Dispatcher {
    if _instance == nil {
        _instance = &Dispatcher{}
        _instance.Init()
    }

    return _instance
}

func (this *Dispatcher) Init() {
    this.listeners = make(map[string]*EventChain)
}

func (this *Dispatcher) AddEventListener(eventName string, callback *EventCallback) {
    eventChain, ok := this.listeners[eventName]
    if !ok {
        eventChain = createEventChain()
        this.listeners[eventName] = eventChain
    }

    exist := false
    //fmt.Println("add len:", len(eventChain.callbacks))
    for _, item := range eventChain.callbacks {
        a := *(*int)(unsafe.Pointer(item))
        b := *(*int)(unsafe.Pointer(callback))
        //fmt.Println("add", a, b)
        if a == b {
            exist = true
            break
        }
    }

    if exist {
        return
    }

    ch := make(chan *Event)

    eventChain.chs = append(eventChain.chs[:], ch)
    eventChain.callbacks = append(eventChain.callbacks[:], callback)

    go this.handler(eventName, ch, callback)
}

func (this *Dispatcher) handler(eventName string, ch chan *Event, callback *EventCallback) {
    //fmt.Printf("add listener: %s\n", eventName)
    //fmt.Println("chan: ", ch)
    for {
        event := <-ch
        //fmt.Println("event out:", eventName, event, ch)
        if event == nil {
            break
        }
        go (*callback)(event)
    }
}

func (this *Dispatcher) RemoveEventListener(eventName string, callback *EventCallback) {
    eventChain, ok := this.listeners[eventName]
    if !ok {
        return
    }

    var ch chan *Event
    exist := false
    key := 0
    for k, item := range eventChain.callbacks {
        a := *(*int)(unsafe.Pointer(item))
        b := *(*int)(unsafe.Pointer(callback))
        //fmt.Println("remove", a, b)
        if a == b {
            exist = true
            ch = eventChain.chs[k]
            key = k
            break
        }
    }

    if exist {
        //fmt.Printf("remove listener: %s\n", eventName)
        //fmt.Println("chan: ", ch)
        ch <- nil

        eventChain.chs = append(eventChain.chs[:key], eventChain.chs[key+1:]...)
        eventChain.callbacks = append(eventChain.callbacks[:key], eventChain.callbacks[key+1:]...)
        //fmt.Println(len(eventChain.chs))
    }
}

func (this *Dispatcher) DispatchEvent(event *Event) {
    eventChain, ok := this.listeners[event.eventName]
    if ok {
        ////fmt.Printf("dispatch event: %s\n", event.eventName)
        for _, chEvent := range eventChain.chs {
            chEvent <- event
        }
    }
}

 

 

這個類里定義了三個結構，Dispatcher:分派器主類，Event:事件類，EventChain:事件鏈類

如果你要使用這個類，那你只要那Dispatcher的單例方法：

 

SharedDispatcher()

 

來進行操作好了

要創建Event，你是要使用創建方法

 

CreateEvent(eventNamestring,paramsmap[string]interface{})

 

來創建

當然，demo還得貼上

 

package main

import (
    "fmt"
    "tbs"
    "time"
)

type MClass struct {
    dispatcher tbs.Dispatcher
}

func main() {
    mc := &MClass{}
    mc.Start()
}

func (this *MClass) Start() {
    //獲取分派器單例
    dispatcher := tbs.SharedDispatcher()

    //添加監聽1
    var fun1 tbs.EventCallback = this.onTest
    dispatcher.AddEventListener("test", &fun1)

    //再添加監聽2
    var fun2 tbs.EventCallback = this.onTest2
    dispatcher.AddEventListener("test", &fun2)

    //隨便弄個事件攜帶的參數，我把參數定義為一個map
    params := make(map[string]interface{})
    params["id"] = 1000
    //創建一個事件對象
    event := tbs.CreateEvent("test", params)
    //把事件分派出去
    dispatcher.DispatchEvent(event)

    //移除監聽1
    dispatcher.RemoveEventListener("test", &fun1)

    //再把事件分派出去一次
    dispatcher.DispatchEvent(event)

    //因為主線程不會等子線程而直接關閉進程，這樣會看不到效果，所以我在這里加了阻塞式延時
    time.Sleep(time.Second * 1)
}

//回調出得到的就是一個event對象了
func (this *MClass) onTest(event *tbs.Event) {
    fmt.Println("onTest", event.Params["id"])
}

func (this *MClass) onTest2(event *tbs.Event) {
    fmt.Println("onTest2", event.Params["id"])
}

 

 

輸出結果：

add listener: test
add listener: test
dispatch event: test
onTest 1000
remove listener: test
dispatch event: test
onTest2 1000
onTest2 1000
成功: 進程退出代碼 0.

哈哈，成功地運行了。

demo你面的注釋已經非常詳盡了，看不懂就在下面問我好了！

昨晚我拿他來封裝了一下golang的socket，改成了事件驅動，耦合度瞬間降低了很多。

 

func onServerStarted(event *tbs.Event) {
    fmt.Println("server started.")
}

func onAccept(event *tbs.Event) {
    socket := (event.Params["socket"]).(*tbs.Socket)

    fmt.Printf("client[#%d] connect on:%s\n", socket.Sign, socket.Conn.RemoteAddr().String())
}

func onData(event *tbs.Event) {
    socket := (event.Params["socket"]).(*tbs.Socket)
    bytes := (event.Params["bytes"]).([]byte)

    fmt.Printf("[#%d]:", socket.Sign)
    fmt.Println(bytes)
}

func onClosed(event *tbs.Event) {
    socket := (event.Params["socket"]).(*tbs.Socket)
    fmt.Printf("[#%d] closed\n", socket.Sign)
}

 

我還是模仿了as3提供的socket，看如上四個回調，只要監聽並開啟了serversocket，那么我只要坐等這四個回調來處理游戲的邏輯即可，每個socket都綁有累加的Sign作為標識。

 

總結：

golang是一門不錯的語言，特別靈活，反射也很方便，應該會火吧，希望國內能有更多golang的開發者社區能建立起來吧！

貼上我自己的博客地址：http://blog.codeforever.net/