Golang實現簡單好用的EventDispatcher

events源代碼

package ax_events

import "fmt"

// 事件類型基類
type Event struct {
    //事件觸發實例
    Target IEventDispatcher
    //事件類型
    Type   string
    //事件攜帶數據源
    Object interface{}
}

// 事件調度器基類
type EventDispatcher struct {
    savers []*EventSaver
}

// 事件調度器中存放的單元
type EventSaver struct {
    Type      string
    Listeners []*EventListener
}

// 監聽器
type EventListener struct {
    Handler EventHandler
}

// 監聽器函數
type EventHandler func(event Event)

// 事件調度接口
type IEventDispatcher interface {
    //事件監聽
    AddEventListener(eventType string, listener *EventListener)
    //移除事件監聽
    RemoveEventListener(eventType string, listener *EventListener) bool
    //是否包含事件
    HasEventListener(eventType string) bool
    //事件派發
    DispatchEvent(event Event) bool
}

// 建立事件派發器
func NewEventDispatcher() *EventDispatcher {
    return new(EventDispatcher)
}

// 建立監聽器
func NewEventListener(h EventHandler) *EventListener {
    l := new(EventListener)
    l.Handler = h
    return l
}

// 建立事件
func NewEvent(eventType string, object interface{}) Event {
    e := Event{Type:eventType, Object:object}
    return e
}

// 克隆事件
func (this *Event)Clone() *Event {
    e := new(Event)
    e.Type = this.Type
    e.Target = e.Target
    return e
}

func (this *Event)ToString() string {
    return fmt.Sprintf("Event Type %v", this.Type)
}

// 事件調度器添加事件
func (this *EventDispatcher)AddEventListener(eventType string, listener *EventListener) {
    for _, saver := range this.savers {
        if saver.Type == eventType {
            saver.Listeners = append(saver.Listeners, listener)
            return
        }
    }

    saver := &EventSaver{Type:eventType, Listeners:[]*EventListener{listener}}
    this.savers = append(this.savers, saver)
}

// 事件調度器移除某個監聽
func (this *EventDispatcher)RemoveEventListener(eventType string, listener *EventListener) bool {
    for _, saver := range this.savers {
        if saver.Type == eventType {
            for i, l := range saver.Listeners {
                if listener == l {
                    saver.Listeners = append(saver.Listeners[:i], saver.Listeners[i + 1:]...)
                    return true
                }
            }
        }
    }
    return false
}

// 事件調度器是否包含某個類型的監聽
func (this *EventDispatcher)HasEventListener(eventType string) bool {
    for _, saver := range this.savers {
        if saver.Type == eventType {
            return true
        }
    }
    return false
}

// 事件調度器派發事件
func (this *EventDispatcher)DispatchEvent(event Event) bool {
    for _, saver := range this.savers {
        if saver.Type == event.Type {
            for _, listener := range saver.Listeners {
                event.Target = this
                listener.Handler(event)
            }
            return true
        }
    }
    return false
}

events中包含幾個核心類：
Event
EventDispatcher
EventListener
EventHandler
EventSaver
接口
IEventDispatcher
使用例子以下：

package main

import (
    "fmt"
    e "alex/ax_events"
    "time"
)

const HELLO_WORLD = "helloWorld"

func main() {
    dispatcher := e.NewEventDispatcher()
    listener := e.NewEventListener(myEventListener)
    dispatcher.AddEventListener(HELLO_WORLD, listener)

    time.Sleep(time.Second * 2)
    //dispatcher.RemoveEventListener(HELLO_WORLD, listener)

    dispatcher.DispatchEvent(e.NewEvent(HELLO_WORLD, nil))
}

func myEventListener(event e.Event) {
    fmt.Println(event.Type, event.Object, event.Target)
}