EventBus alternatives and similar packages
Based on the "Messaging" category.
Alternatively, view EventBus alternatives based on common mentions on social networks and blogs.
-
Confluent Kafka Golang Client
confluent-kafka-go is Confluent's Golang client for Apache Kafka and the Confluent Platform. -
NATS Go Client
A lightweight and high performance publish-subscribe and distributed queueing messaging system -
NATS
A lightweight and highly performant publish-subscribe and distributed queueing messaging system. -
Mercure
Server and library to dispatch server-sent updates using the Mercure protocol (built on top of Server-Sent Events). -
Gollum
A n:m multiplexer that gathers messages from different sources and broadcasts them to a set of destinations. -
mangos
Pure go implementation of the Nanomsg ("Scalable Protocols") with transport interoperability. -
emitter
Emits events using Go way, with wildcard, predicates, cancellation possibilities and many other good wins. -
messagebus
messagebus is a Go simple async message bus, perfect for using as event bus when doing event sourcing, CQRS, DDD. -
guble
A messaging server using push notifications (Google Firebase Cloud Messaging, Apple Push Notification services, SMS) as well as websockets, a REST API, featuring distributed operation and message-persistence. -
Commander
A high-level event driven consumer/producer supporting various "dialects" such as Apache Kafka. -
go-res
Package for building REST/real-time services where clients are synchronized seamlessly, using NATS and Resgate. -
jazz
A simple RabbitMQ abstraction layer for queue administration and publishing and consuming of messages. -
rmqconn
RabbitMQ Reconnection. Wrapper over amqp.Connection and amqp.Dial. Allowing to do a reconnection when the connection is broken before forcing the call to the Close () method to be closed.
Get performance insights in less than 4 minutes
Do you think we are missing an alternative of EventBus or a related project?
Popular Comparisons
README
EventBus
Package EventBus is the little and lightweight eventbus with async compatibility for GoLang.
Installation
Make sure that Go is installed on your computer. Type the following command in your terminal:
go get github.com/asaskevich/EventBus
After it the package is ready to use.
Import package in your project
Add following line in your *.go
file:
import "github.com/asaskevich/EventBus"
If you unhappy to use long EventBus
, you can do something like this:
import (
evbus "github.com/asaskevich/EventBus"
)
Example
func calculator(a int, b int) {
fmt.Printf("%d\n", a + b)
}
func main() {
bus := EventBus.New();
bus.Subscribe("main:calculator", calculator);
bus.Publish("main:calculator", 20, 40);
bus.Unsubscribe("main:calculator", calculator);
}
Implemented methods
- New()
- Subscribe()
- SubscribeOnce()
- HasCallback()
- Unsubscribe()
- Publish()
- SubscribeAsync()
- SubscribeOnceAsync()
- WaitAsync()
New()
New returns new EventBus with empty handlers.
bus := EventBus.New();
Subscribe(topic string, fn interface{}) error
Subscribe to a topic. Returns error if fn
is not a function.
func Handler() { ... }
...
bus.Subscribe("topic:handler", Handler)
SubscribeOnce(topic string, fn interface{}) error
Subscribe to a topic once. Handler will be removed after executing. Returns error if fn
is not a function.
func HelloWorld() { ... }
...
bus.SubscribeOnce("topic:handler", HelloWorld)
Unsubscribe(topic string, fn interface{}) error
Remove callback defined for a topic. Returns error if there are no callbacks subscribed to the topic.
bus.Unsubscribe("topic:handler", HelloWord);
HasCallback(topic string) bool
Returns true if exists any callback subscribed to the topic.
Publish(topic string, args ...interface{})
Publish executes callback defined for a topic. Any additional argument will be transferred to the callback.
func Handler(str string) { ... }
...
bus.Subscribe("topic:handler", Handler)
...
bus.Publish("topic:handler", "Hello, World!");
SubscribeAsync(topic string, fn interface{}, transactional bool)
Subscribe to a topic with an asynchronous callback. Returns error if fn
is not a function.
func slowCalculator(a, b int) {
time.Sleep(3 * time.Second)
fmt.Printf("%d\n", a + b)
}
bus := EventBus.New()
bus.SubscribeAsync("main:slow_calculator", slowCalculator, false)
bus.Publish("main:slow_calculator", 20, 60)
fmt.Println("start: do some stuff while waiting for a result")
fmt.Println("end: do some stuff while waiting for a result")
bus.WaitAsync() // wait for all async callbacks to complete
fmt.Println("do some stuff after waiting for result")
Transactional determines whether subsequent callbacks for a topic are run serially (true) or concurrently(false)
SubscribeOnceAsync(topic string, args ...interface{})
SubscribeOnceAsync works like SubscribeOnce except the callback to executed asynchronously
WaitAsync()
WaitAsync waits for all async callbacks to complete.
Cross Process Events
Works with two rpc services:
- a client service to listen to remotely published events from a server
- a server service to listen to client subscriptions
server.go
func main() {
server := NewServer(":2010", "/_server_bus_", New())
server.Start()
// ...
server.EventBus().Publish("main:calculator", 4, 6)
// ...
server.Stop()
}
client.go
func main() {
client := NewClient(":2015", "/_client_bus_", New())
client.Start()
client.Subscribe("main:calculator", calculator, ":2010", "/_server_bus_")
// ...
client.Stop()
}
Notes
Documentation is available here: godoc.org. Full information about code coverage is also available here: EventBus on gocover.io.
Support
If you do have a contribution for the package feel free to put up a Pull Request or open Issue.