GitHub go.mod Go version GoDoc Actions Status Coverage Status Go Report Card

Lightweight event management, dispatch tool library implemented by Go

  • Support for custom definition event objects
  • Support for adding multiple listeners to an event
  • Supports setting the priority of the event listener. The higher the priority, the higher the trigger.
  • Support for a set of event listeners based on the event name prefix PREFIX.*.
    • add app.* event listen, trigger app.run app.end, Both will trigger the app.* event at the same time
  • Support for using the wildcard * to listen for triggers for all events
  • Complete unit testing, unit coverage > 95%


中文说明请看 README.zh-CN


Main method

  • On/Listen(name string, listener Listener, priority ...int) Register event listener
  • Subscribe/AddSubscriber(sbr Subscriber) Subscribe to support registration of multiple event listeners
  • Trigger/Fire(name string, params M) (error, Event) Trigger event
  • MustTrigger/MustFire(name string, params M) Event Trigger event, there will be panic if there is an error
  • FireEvent(e Event) (err error) Trigger an event based on a given event instance
  • FireBatch(es ...interface{}) (ers []error) Trigger multiple events at once
  • AsyncFire(e Event) Async fire event by 'go' keywords

Quick start

package main

import (


func main() {
    // Register event listener
    event.On("evt1", event.ListenerFunc(func(e event.Event) error {
        fmt.Printf("handle event: %s\n", e.Name())
        return nil
    }), event.Normal)

    // Register multiple listeners
    event.On("evt1", event.ListenerFunc(func(e event.Event) error {
        fmt.Printf("handle event: %s\n", e.Name())
        return nil
    }), event.High)

    // ... ...

    // Trigger event
    // Note: The second listener has a higher priority, so it will be executed first.
    event.MustFire("evt1", event.M{"arg0": "val0", "arg1": "val1"})

Write event listeners

Using anonymous functions

package mypgk

import (


var fnHandler = func(e event.Event) error {
    fmt.Printf("handle event: %s\n", e.Name())
    return nil

func Run() {
    // register
    event.On("evt1", event.ListenerFunc(fnHandler), event.High)

Using the structure method


// Listener interface
type Listener interface {
    Handle(e Event) error


Implementation interface event.Listener

package mypgk

import "github.com/gookit/event"

type MyListener struct {
    // userData string

func (l *MyListener) Handle(e event.Event) error {
    e.Set("result", "OK")
    return nil

Register multiple event listeners


// Subscriber event subscriber interface.
// you can register multi event listeners in a struct func.
type Subscriber interface {
    // SubscribedEvents register event listeners
    // key: is event name
    // value: can be Listener or ListenerItem interface
    SubscribedEvents() map[string]interface{}


Implementation interface event.Subscriber

package mypgk

import (


type MySubscriber struct {
    // ooo

func (s *MySubscriber) SubscribedEvents() map[string]interface{} {
    return map[string]interface{}{
        "e1": event.ListenerFunc(s.e1Handler),
        "e2": event.ListenerItem{
            Priority: event.AboveNormal,
            Listener: event.ListenerFunc(func(e Event) error {
                return fmt.Errorf("an error")
        "e3": &MyListener{},

func (s *MySubscriber) e1Handler(e event.Event) error {
    e.Set("e1-key", "val1")
    return nil

Write custom events


// Event interface
type Event interface {
    Name() string
    // Target() interface{}
    Get(key string) interface{}
    Add(key string, val interface{})
    Set(key string, val interface{})
    Data() map[string]interface{}
    SetData(M) Event
    IsAborted() bool


package mypgk

import "github.com/gookit/event"

type MyEvent struct {
    customData string

func (e *MyEvent) CustomData() string {
    return e.customData


e := &MyEvent{customData: "hello"}

// add listener
event.On("e1", event.ListenerFunc(func(e event.Event) error {
    fmt.Printf("custom Data: %s\n", e.(*MyEvent).CustomData())
    return nil

// trigger
event.Fire("e1", nil)
// OR
// event.FireEvent(e)

Gookit packages

  • gookit/ini Go config management, use INI files
  • gookit/rux Simple and fast request router for golang HTTP
  • gookit/gcli build CLI application, tool library, running CLI commands
  • gookit/slog Lightweight, extensible, configurable logging library written in Go
  • gookit/event Lightweight event manager and dispatcher implements by Go
  • gookit/cache Generic cache use and cache manager for golang. support File, Memory, Redis, Memcached.
  • gookit/config Go config management. support JSON, YAML, TOML, INI, HCL, ENV and Flags
  • gookit/color A command-line color library with true color support, universal API methods and Windows support
  • gookit/filter Provide filtering, sanitizing, and conversion of golang data
  • gookit/validate Use for data validation and filtering. support Map, Struct, Form data
  • gookit/goutil Some utils for the Go: string, array/slice, map, format, cli, env, filesystem, test and more
  • More, please see https://github.com/gookit




📢 Lightweight event manager and dispatcher implements by Go. Go实现的轻量级的事件管理、调度程序库, 支持设置监听器的优先级, 支持根据事件名称来进行一组事件的监听

Event Info

⭐ Stars 191
🔗 Homepage pgk.go.dev
🔗 Source Code github.com
🕒 Last Update 5 months ago
🕒 Created 4 years ago
🐞 Open Issues 3
➗ Star-Issue Ratio 64
😎 Author gookit