Multi-Protocol Support

Table of Contents

1. Introduction
2. Project Structure
3. Core Components
4. Architecture Overview
5. Detailed Component Analysis
6. Dependency Analysis
7. Performance Considerations
8. Troubleshooting Guide
9. Conclusion
10. Appendix

Introduction

This document systematically describes the multi-protocol support in this repository, covering the following aspects:

• Supported messaging protocols and their characteristics
• Unified event bus interface design
• Implementation differences and adaptation strategies for each protocol
• Protocol selection suggestions and applicable scenarios
• Configuration methods and parameter descriptions for each protocol
• Extension methods and best practices for new protocols

Project Structure

Multi-protocol support related code is mainly located in the pkg/eventbus directory, including:

• Unified event bus interface definition
• Memory, NATS, RabbitMQ, Redis and other protocol implementations
• Configuration items and initialization logic for each protocol

• EventBus Interface: Unified event bus interface, defines Pub/Sub/Unsub/Close and other methods
• Memory Event Bus: Pure memory implementation, suitable for testing and local development
• NATS Event Bus: Based on NATS messaging system, supports publish/subscribe and queue patterns
• RabbitMQ Event Bus: Based on RabbitMQ messaging system, supports multiple exchange types and routing patterns
• Redis Event Bus: Based on Redis Pub/Sub, lightweight and high-performance

The multi-protocol architecture adopts the strategy pattern, defining a unified EventBus interface through abstraction, with specific protocol implementations independently completing adaptation. Application layer selects appropriate protocol implementation through configuration and dependency injection.

Unified Event Bus Interface

• Interface Definition
  • Pub: Publish events to specified topic
  • Sub: Subscribe to specified topic and register handler
  • Unsub: Unsubscribe from specified topic
  • Close: Close event bus connection and cleanup resources
• Design Principles
  • Simple and clear, hiding underlying protocol complexity
  • Context-driven, supporting timeout and cancellation
  • Error return, facilitating upper layer handling

• Implementation Characteristics
  • Pure memory storage, no external dependencies
  • Asynchronous handler calls, supports timeout control
  • Thread-safe, uses read-write lock protection
  • Supports statistics, facilitating debugging and monitoring
• Applicable Scenarios
  • Unit testing
  • Local development
  • Rapid verification of event processing chain
  • Scenarios not requiring persistence

• Implementation Characteristics
  • Based on NATS core functionality
  • Supports publish/subscribe and queue group patterns
  • High performance, low latency
  • Supports cluster mode
• Applicable Scenarios
  • High-performance messaging scenarios
  • Scenarios requiring cluster deployment
  • Microservices architecture

• Implementation Characteristics
  • Based on RabbitMQ AMQP protocol
  • Supports multiple exchange types (Direct, Topic, Fanout, Headers)
  • Supports message persistence and acknowledgment
  • Supports dead letter queue
• Applicable Scenarios
  • Enterprise messaging scenarios
  • Scenarios requiring complex routing
  • Scenarios requiring message persistence

• Implementation Characteristics
  • Based on Redis Pub/Sub functionality
  • Lightweight, low resource consumption
  • High performance, suitable for high-frequency scenarios
  • Does not support message persistence
• Applicable Scenarios
  • Lightweight messaging scenarios
  • Scenarios with high real-time requirements
  • Scenarios already using Redis

• Memory Event Bus
  • Advantages: No external dependencies, fastest startup, suitable for testing
  • Disadvantages: No persistence, process termination loses data, not suitable for production
• NATS Event Bus
  • Advantages: High performance, low latency, supports cluster, simple and easy to use
  • Disadvantages: Core functionality doesn't support persistence (requires JetStream)
• RabbitMQ Event Bus
  • Advantages: Full functionality, supports persistence, complex routing, enterprise-level features
  • Disadvantages: Higher resource consumption, complex configuration, higher latency
• Redis Event Bus
  • Advantages: Lightweight, high performance, low resource consumption, simple and easy to use
  • Disadvantages: No persistence, limited functionality, single-threaded processing

• Memory Event Bus

  • No configuration required, created directly

• NATS Event Bus

  • URL: NATS server address
  • MaxReconnects: Maximum reconnection attempts
  • ReconnectWait: Reconnection wait time

• RabbitMQ Event Bus

  • URL: RabbitMQ server address
  • Exchange: Exchange name
  • ExchangeType: Exchange type
  • Durable: Whether to persist
  • AutoDelete: Whether to auto-delete

• Redis Event Bus

  • Addr: Redis server address
  • Password: Password
  • DB: Database number

• Implement EventBus Interface

  • Implement Pub/Sub/Unsub/Close methods
  • Handle context cancellation and timeout
  • Ensure thread safety

• Configuration Support

  • Provide corresponding configuration struct
  • Support configuration through configuration files or environment variables

• Documentation and Testing

  • Provide detailed documentation
  • Provide complete unit tests and integration tests

• Performance Optimization

  • Implement connection pooling
  • Support batch processing
  • Optimize serialization and deserialization

• Protocol Selection

  • Select appropriate protocol based on business needs
  • Consider persistence, performance, complexity and other factors

• Configuration Management

  • Centralized configuration management
  • Support dynamic configuration updates

• Error Handling

  • Unified error handling strategy
  • Set up monitoring and alarm mechanisms

• Resource Management

  • Timely cleanup of resources
  • Avoid connection leaks

• Connection Failure

  • Check server status
  • Check network connectivity
  • Check configuration correctness

• Publish Failure

  • Check connection status
  • Check topic format
  • Check message size

• Subscribe Failure

  • Check handler registration
  • Check topic subscription
  • Check permission configuration

• Performance Issues

  • Check connection pooling configuration
  • Check batch processing configuration
  • Check serialization performance

Multi-protocol support provides flexible messaging infrastructure choices through unified interface abstraction. Different protocols have their own characteristics and applicable scenarios, and reasonable selection should be made based on business needs. Following best practices and correct error handling can ensure system stability and performance.

Appendix

Protocol Comparison Table

Feature	Memory	NATS	RabbitMQ	Redis
Persistence	No	Optional	Yes	No
Performance	Highest	High	Medium	High
Latency	Lowest	Low	Medium	Low
Cluster Support	No	Yes	Yes	Yes
Complexity	Low	Low	High	Low
Resource Consumption	Lowest	Low	High	Low
Message Routing	Simple	Simple	Complex	Simple
Dead Letter Queue	No	No	Yes	No
Suitable Scenarios	Testing/Development	High Performance	Enterprise	Lightweight

Configuration Example

// Memory Event Bus (no configuration required)
memBus := eventbus.NewMemoryEventBus()

// NATS Event Bus
natsBus, err := eventbus.NewNATSEventBus(&config.NATSConfig{
    URL:           "nats://localhost:4222",
    MaxReconnects: 10,
    ReconnectWait: time.Second,
})

// RabbitMQ Event Bus
rabbitBus, err := eventbus.NewRabbitMQEventBus(&config.RabbitMQConfig{
    URL:          "amqp://guest:guest@localhost:5672/",
    Exchange:     "events",
    ExchangeType: "topic",
    Durable:      true,
})

// Redis Event Bus
redisBus, err := eventbus.NewRedisEventBus(&config.RedisConfig{
    Addr:     "localhost:6379",
    Password: "",
    DB:       0,
})