Awesome Open Source
Awesome Open Source


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.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



go get

Main method

  • On/Listen(name string, listener Listener, priority 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 by name and params
  • 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"})

Note: The second listener has a higher priority, so it will be executed first.

Using the wildcard

Register event listener and name end with wildcard *:

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

	event.On("app.db.*", dbListener1, event.Normal)

Trigger events on other logic:

func doCreate() {
	// do something ...
	// Trigger event
	event.MustFire("app.db.create", event.M{"arg0": "val0", "arg1": "val1"})

func doUpdate() {
	// do something ...
	// Trigger event
	event.MustFire("app.db.update", event.M{"arg0": "val0"})

Like the above, triggering the app.db.create app.db.update event will trigger the execution of the dbListener1 listener.

Write event listeners

Using anonymous functions

You can use anonymous function for quick write an event lister.

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

You can use struct write an event lister, and it should implementation interface event.Listener.


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


Implementation interface event.Listener

package mypgk

import ""

type MyListener struct {
	// userData string

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

Register multiple event listeners

Can implementation interface event.Subscriber for register multiple event listeners at once.


// 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

If you want to customize the event object or define some fixed event information in advance, you can implement the event.Event interface.


// 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 ""

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



Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
Go (171,982
Listener (5,910
Ini (2,803
Eventbus (1,539
Event Listener (547
Event Management (254
Event Dispatcher (73
Gookit (4