Skip to main content

Go Advanced OOP Patterns

Advanced OOP patterns in Go combine the fundamental concepts of methods, embedding, interfaces, and composition to create sophisticated software architectures. These patterns enable building complex, maintainable, and scalable applications by leveraging Go's unique approach to object-oriented programming. Understanding advanced OOP patterns is crucial for creating enterprise-level applications and implementing modern software architectures.

Understanding Advanced OOP Patterns in Go​

What Are Advanced OOP Patterns?​

Advanced OOP patterns in Go are sophisticated design techniques that combine multiple fundamental concepts to solve complex software problems. These patterns provide:

  • Scalability - Handle growing complexity and requirements
  • Maintainability - Easy to modify and extend systems
  • Testability - Simple to test individual components
  • Flexibility - Adapt to changing requirements
  • Reusability - Share patterns across different projects

Go's Advanced Pattern Characteristics​

Go's advanced patterns have several distinctive features:

Composition-based Design​

Complex patterns built from simple, composable components.

Interface-driven Architecture​

Interfaces provide contracts for loose coupling and flexibility.

Concurrent-safe Patterns​

Patterns that work well with Go's concurrency model.

Functional Integration​

Combining OOP patterns with functional programming concepts.

Observer Patterns​

Understanding Observer Patterns​

Observer Definition​

Observer patterns define one-to-many dependencies between objects.

Event-driven Communication​

Observers receive notifications when subjects change state.

package main

import "fmt"

func main() {
    // Observer patterns examples
    fmt.Println("Observer patterns examples:")
    
    // Define observer interface
    type Observer interface {
        Update(message string)
    }
    
    // Define subject interface
    type Subject interface {
        AddObserver(observer Observer)
        RemoveObserver(observer Observer)
        NotifyObservers(message string)
    }
    
    // Concrete subject
    type NewsAgency struct {
        observers []Observer
        news      string
    }
    
    func (na *NewsAgency) AddObserver(observer Observer) {
        na.observers = append(na.observers, observer)
    }
    
    func (na *NewsAgency) RemoveObserver(observer Observer) {
        for i, obs := range na.observers {
            if obs == observer {
                na.observers = append(na.observers[:i], na.observers[i+1:]...)
                break
            }
        }
    }
    
    func (na *NewsAgency) NotifyObservers(message string) {
        for _, observer := range na.observers {
            observer.Update(message)
        }
    }
    
    func (na *NewsAgency) SetNews(news string) {
        na.news = news
        na.NotifyObservers(news)
    }
    
    func (na *NewsAgency) GetNews() string {
        return na.news
    }
    
    // Concrete observers
    type NewsChannel struct {
        name string
    }
    
    func (nc NewsChannel) Update(message string) {
        fmt.Printf("%s received: %s\n", nc.name, message)
    }
    
    type EmailSubscriber struct {
        email string
    }
    
    func (es EmailSubscriber) Update(message string) {
        fmt.Printf("Email sent to %s: %s\n", es.email, message)
    }
    
    type SMSSubscriber struct {
        phone string
    }
    
    func (ss SMSSubscriber) Update(message string) {
        fmt.Printf("SMS sent to %s: %s\n", ss.phone, message)
    }
    
    // Use observer pattern
    agency := &NewsAgency{}
    
    // Create observers
    cnn := NewsChannel{name: "CNN"}
    bbc := NewsChannel{name: "BBC"}
    emailSub := EmailSubscriber{email: "[email protected]"}
    smsSub := SMSSubscriber{phone: "+1234567890"}
    
    // Add observers
    agency.AddObserver(cnn)
    agency.AddObserver(bbc)
    agency.AddObserver(emailSub)
    agency.AddObserver(smsSub)
    
    // Set news (triggers notifications)
    fmt.Println("Setting news:")
    agency.SetNews("Breaking news: Go 1.21 released!")
    // Output:
    // Setting news:
    // CNN received: Breaking news: Go 1.21 released!
    // BBC received: Breaking news: Go 1.21 released!
    // Email sent to [email protected]: Breaking news: Go 1.21 released!
    // SMS sent to +1234567890: Breaking news: Go 1.21 released!
    
    // Remove an observer
    agency.RemoveObserver(emailSub)
    
    // Set more news
    fmt.Println("\nSetting more news (after removing email subscriber):")
    agency.SetNews("Update: Go 1.21 includes new features!")
    // Output:
    // Setting more news (after removing email subscriber):
    // CNN received: Update: Go 1.21 includes new features!
    // BBC received: Update: Go 1.21 includes new features!
    // SMS sent to +1234567890: Update: Go 1.21 includes new features!
    
    // Event-driven observer pattern
    type Event struct {
        Type      string
        Data      interface{}
        Timestamp string
    }
    
    type EventObserver interface {
        HandleEvent(event Event)
    }
    
    type EventBus struct {
        observers map[string][]EventObserver
    }
    
    func (eb *EventBus) Subscribe(eventType string, observer EventObserver) {
        if eb.observers == nil {
            eb.observers = make(map[string][]EventObserver)
        }
        eb.observers[eventType] = append(eb.observers[eventType], observer)
    }
    
    func (eb *EventBus) Publish(event Event) {
        if observers, exists := eb.observers[event.Type]; exists {
            for _, observer := range observers {
                observer.HandleEvent(event)
            }
        }
    }
    
    // Event observers
    type LoggingObserver struct {
        name string
    }
    
    func (lo LoggingObserver) HandleEvent(event Event) {
        fmt.Printf("[%s] Event %s: %v\n", lo.name, event.Type, event.Data)
    }
    
    type MetricsObserver struct {
        name string
    }
    
    func (mo MetricsObserver) HandleEvent(event Event) {
        fmt.Printf("[%s] Metrics: Processing event %s\n", mo.name, event.Type)
    }
    
    // Use event-driven observer pattern
    eventBus := &EventBus{}
    
    // Create observers
    logger := LoggingObserver{name: "Logger"}
    metrics := MetricsObserver{name: "Metrics"}
    
    // Subscribe to events
    eventBus.Subscribe("user.login", logger)
    eventBus.Subscribe("user.login", metrics)
    eventBus.Subscribe("user.logout", logger)
    
    // Publish events
    fmt.Println("\nEvent-driven observer pattern:")
    eventBus.Publish(Event{
        Type:      "user.login",
        Data:      "User ID: 123",
        Timestamp: "2023-12-07T10:00:00Z",
    })
    
    eventBus.Publish(Event{
        Type:      "user.logout",
        Data:      "User ID: 123",
        Timestamp: "2023-12-07T11:00:00Z",
    })
    // Output:
    // Event-driven observer pattern:
    // [Logger] Event user.login: User ID: 123
    // [Metrics] Metrics: Processing event user.login
    // [Logger] Event user.logout: User ID: 123
}

Builder Patterns​

Understanding Builder Patterns​

Builder Definition​

Builder patterns construct complex objects step by step.

Fluent Interface Design​

Builders provide a fluent interface for object construction.

package main

import "fmt"

func main() {
    // Builder patterns examples
    fmt.Println("Builder patterns examples:")
    
    // Define product
    type Computer struct {
        CPU       string
        RAM       int
        Storage   string
        Graphics  string
        Monitor   string
        Keyboard  string
        Mouse     string
    }
    
    func (c Computer) String() string {
        return fmt.Sprintf("Computer{CPU: %s, RAM: %dGB, Storage: %s, Graphics: %s, Monitor: %s, Keyboard: %s, Mouse: %s}",
            c.CPU, c.RAM, c.Storage, c.Graphics, c.Monitor, c.Keyboard, c.Mouse)
    }
    
    // Define builder
    type ComputerBuilder struct {
        computer Computer
    }
    
    func NewComputerBuilder() *ComputerBuilder {
        return &ComputerBuilder{}
    }
    
    func (cb *ComputerBuilder) SetCPU(cpu string) *ComputerBuilder {
        cb.computer.CPU = cpu
        return cb
    }
    
    func (cb *ComputerBuilder) SetRAM(ram int) *ComputerBuilder {
        cb.computer.RAM = ram
        return cb
    }
    
    func (cb *ComputerBuilder) SetStorage(storage string) *ComputerBuilder {
        cb.computer.Storage = storage
        return cb
    }
    
    func (cb *ComputerBuilder) SetGraphics(graphics string) *ComputerBuilder {
        cb.computer.Graphics = graphics
        return cb
    }
    
    func (cb *ComputerBuilder) SetMonitor(monitor string) *ComputerBuilder {
        cb.computer.Monitor = monitor
        return cb
    }
    
    func (cb *ComputerBuilder) SetKeyboard(keyboard string) *ComputerBuilder {
        cb.computer.Keyboard = keyboard
        return cb
    }
    
    func (cb *ComputerBuilder) SetMouse(mouse string) *ComputerBuilder {
        cb.computer.Mouse = mouse
        return cb
    }
    
    func (cb *ComputerBuilder) Build() Computer {
        return cb.computer
    }
    
    // Use builder pattern
    gamingPC := NewComputerBuilder().
        SetCPU("Intel i7-12700K").
        SetRAM(32).
        SetStorage("1TB NVMe SSD").
        SetGraphics("RTX 4080").
        SetMonitor("27\" 4K Gaming Monitor").
        SetKeyboard("Mechanical Gaming Keyboard").
        SetMouse("Gaming Mouse").
        Build()
    
    fmt.Printf("Gaming PC: %s\n", gamingPC)
    // Output: Gaming PC: Computer{CPU: Intel i7-12700K, RAM: 32GB, Storage: 1TB NVMe SSD, Graphics: RTX 4080, Monitor: 27" 4K Gaming Monitor, Keyboard: Mechanical Gaming Keyboard, Mouse: Gaming Mouse}
    
    officePC := NewComputerBuilder().
        SetCPU("Intel i5-12400").
        SetRAM(16).
        SetStorage("512GB SSD").
        SetGraphics("Integrated").
        SetMonitor("24\" Full HD Monitor").
        SetKeyboard("Standard Keyboard").
        SetMouse("Standard Mouse").
        Build()
    
    fmt.Printf("Office PC: %s\n", officePC)
    // Output: Office PC: Computer{CPU: Intel i5-12400, RAM: 16GB, Storage: 512GB SSD, Graphics: Integrated, Monitor: 24" Full HD Monitor, Keyboard: Standard Keyboard, Mouse: Standard Mouse}
    
    // Advanced builder with validation
    type DatabaseConfig struct {
        Host     string
        Port     int
        Database string
        Username string
        Password string
        SSL      bool
        PoolSize int
    }
    
    func (dc DatabaseConfig) String() string {
        return fmt.Sprintf("DatabaseConfig{Host: %s, Port: %d, Database: %s, Username: %s, SSL: %t, PoolSize: %d}",
            dc.Host, dc.Port, dc.Database, dc.Username, dc.SSL, dc.PoolSize)
    }
    
    type DatabaseConfigBuilder struct {
        config DatabaseConfig
        errors []string
    }
    
    func NewDatabaseConfigBuilder() *DatabaseConfigBuilder {
        return &DatabaseConfigBuilder{
            config: DatabaseConfig{
                Port:     5432,
                SSL:      false,
                PoolSize: 10,
            },
        }
    }
    
    func (dcb *DatabaseConfigBuilder) Host(host string) *DatabaseConfigBuilder {
        if host == "" {
            dcb.errors = append(dcb.errors, "host cannot be empty")
        } else {
            dcb.config.Host = host
        }
        return dcb
    }
    
    func (dcb *DatabaseConfigBuilder) Port(port int) *DatabaseConfigBuilder {
        if port <= 0 || port > 65535 {
            dcb.errors = append(dcb.errors, "port must be between 1 and 65535")
        } else {
            dcb.config.Port = port
        }
        return dcb
    }
    
    func (dcb *DatabaseConfigBuilder) Database(db string) *DatabaseConfigBuilder {
        if db == "" {
            dcb.errors = append(dcb.errors, "database name cannot be empty")
        } else {
            dcb.config.Database = db
        }
        return dcb
    }
    
    func (dcb *DatabaseConfigBuilder) Credentials(username, password string) *DatabaseConfigBuilder {
        if username == "" {
            dcb.errors = append(dcb.errors, "username cannot be empty")
        } else {
            dcb.config.Username = username
        }
        
        if password == "" {
            dcb.errors = append(dcb.errors, "password cannot be empty")
        } else {
            dcb.config.Password = password
        }
        return dcb
    }
    
    func (dcb *DatabaseConfigBuilder) WithSSL() *DatabaseConfigBuilder {
        dcb.config.SSL = true
        return dcb
    }
    
    func (dcb *DatabaseConfigBuilder) PoolSize(size int) *DatabaseConfigBuilder {
        if size <= 0 {
            dcb.errors = append(dcb.errors, "pool size must be positive")
        } else {
            dcb.config.PoolSize = size
        }
        return dcb
    }
    
    func (dcb *DatabaseConfigBuilder) Build() (DatabaseConfig, error) {
        if len(dcb.errors) > 0 {
            return DatabaseConfig{}, fmt.Errorf("validation errors: %v", dcb.errors)
        }
        return dcb.config, nil
    }
    
    // Use advanced builder
    config, err := NewDatabaseConfigBuilder().
        Host("localhost").
        Port(5432).
        Database("mydb").
        Credentials("user", "password").
        WithSSL().
        PoolSize(20).
        Build()
    
    if err != nil {
        fmt.Printf("Error building config: %v\n", err)
    } else {
        fmt.Printf("Database config: %s\n", config)
    }
    // Output: Database config: DatabaseConfig{Host: localhost, Port: 5432, Database: mydb, Username: user, SSL: true, PoolSize: 20}
    
    // Test validation
    invalidConfig, err := NewDatabaseConfigBuilder().
        Host("").
        Port(0).
        Database("").
        Credentials("", "").
        Build()
    
    if err != nil {
        fmt.Printf("Validation errors: %v\n", err)
    } else {
        fmt.Printf("Invalid config: %s\n", invalidConfig)
    }
    // Output: Validation errors: validation errors: [host cannot be empty port must be between 1 and 65535 database name cannot be empty username cannot be empty password cannot be empty]
}

Dependency Injection​

Understanding Dependency Injection​

Dependency Injection Definition​

Dependency injection provides dependencies to objects rather than having them create dependencies themselves.

Interface-based Injection​

Go's interfaces enable clean dependency injection patterns.

package main

import "fmt"

func main() {
    // Dependency injection examples
    fmt.Println("Dependency injection examples:")
    
    // Define interfaces
    type UserRepository interface {
        GetUser(id string) (*User, error)
        SaveUser(user *User) error
    }
    
    type EmailService interface {
        SendEmail(to, subject, body string) error
    }
    
    type Logger interface {
        Log(message string)
    }
    
    // Define models
    type User struct {
        ID    string
        Name  string
        Email string
    }
    
    func (u User) String() string {
        return fmt.Sprintf("User{ID: %s, Name: %s, Email: %s}", u.ID, u.Name, u.Email)
    }
    
    // Concrete implementations
    type InMemoryUserRepository struct {
        users map[string]*User
    }
    
    func NewInMemoryUserRepository() *InMemoryUserRepository {
        return &InMemoryUserRepository{
            users: make(map[string]*User),
        }
    }
    
    func (r *InMemoryUserRepository) GetUser(id string) (*User, error) {
        if user, exists := r.users[id]; exists {
            return user, nil
        }
        return nil, fmt.Errorf("user not found")
    }
    
    func (r *InMemoryUserRepository) SaveUser(user *User) error {
        r.users[user.ID] = user
        return nil
    }
    
    type SMTPEmailService struct {
        host string
        port int
    }
    
    func NewSMTPEmailService(host string, port int) *SMTPEmailService {
        return &SMTPEmailService{host: host, port: port}
    }
    
    func (s *SMTPEmailService) SendEmail(to, subject, body string) error {
        fmt.Printf("Sending email via SMTP (%s:%d) to %s: %s\n", s.host, s.port, to, subject)
        return nil
    }
    
    type ConsoleLogger struct {
        level string
    }
    
    func NewConsoleLogger(level string) *ConsoleLogger {
        return &ConsoleLogger{level: level}
    }
    
    func (l *ConsoleLogger) Log(message string) {
        fmt.Printf("[%s] %s\n", l.level, message)
    }
    
    // Service with dependency injection
    type UserService struct {
        userRepo    UserRepository
        emailService EmailService
        logger      Logger
    }
    
    func NewUserService(userRepo UserRepository, emailService EmailService, logger Logger) *UserService {
        return &UserService{
            userRepo:     userRepo,
            emailService: emailService,
            logger:       logger,
        }
    }
    
    func (us *UserService) CreateUser(name, email string) (*User, error) {
        us.logger.Log("Creating new user")
        
        user := &User{
            ID:    "user_" + fmt.Sprintf("%d", len(us.userRepo.(*InMemoryUserRepository).users)+1),
            Name:  name,
            Email: email,
        }
        
        if err := us.userRepo.SaveUser(user); err != nil {
            us.logger.Log("Failed to save user")
            return nil, err
        }
        
        if err := us.emailService.SendEmail(email, "Welcome", "Welcome to our service!"); err != nil {
            us.logger.Log("Failed to send welcome email")
            return nil, err
        }
        
        us.logger.Log("User created successfully")
        return user, nil
    }
    
    func (us *UserService) GetUser(id string) (*User, error) {
        us.logger.Log("Getting user by ID")
        return us.userRepo.GetUser(id)
    }
    
    // Dependency injection container
    type Container struct {
        services map[string]interface{}
    }
    
    func NewContainer() *Container {
        return &Container{
            services: make(map[string]interface{}),
        }
    }
    
    func (c *Container) Register(name string, service interface{}) {
        c.services[name] = service
    }
    
    func (c *Container) Get(name string) interface{} {
        return c.services[name]
    }
    
    // Use dependency injection
    container := NewContainer()
    
    // Register dependencies
    container.Register("userRepo", NewInMemoryUserRepository())
    container.Register("emailService", NewSMTPEmailService("smtp.example.com", 587))
    container.Register("logger", NewConsoleLogger("INFO"))
    
    // Create service with injected dependencies
    userService := NewUserService(
        container.Get("userRepo").(UserRepository),
        container.Get("emailService").(EmailService),
        container.Get("logger").(Logger),
    )
    
    // Use service
    user, err := userService.CreateUser("Alice", "[email protected]")
    if err != nil {
        fmt.Printf("Error creating user: %v\n", err)
    } else {
        fmt.Printf("Created user: %s\n", user)
    }
    // Output:
    // [INFO] Creating new user
    // Sending email via SMTP (smtp.example.com:587) to [email protected]: Welcome
    // [INFO] User created successfully
    // Created user: User{ID: user_1, Name: Alice, Email: [email protected]}
    
    // Get user
    retrievedUser, err := userService.GetUser("user_1")
    if err != nil {
        fmt.Printf("Error getting user: %v\n", err)
    } else {
        fmt.Printf("Retrieved user: %s\n", retrievedUser)
    }
    // Output:
    // [INFO] Getting user by ID
    // Retrieved user: User{ID: user_1, Name: Alice, Email: [email protected]}
    
    // Factory for dependency injection
    type ServiceFactory struct {
        container *Container
    }
    
    func NewServiceFactory() *ServiceFactory {
        factory := &ServiceFactory{
            container: NewContainer(),
        }
        
        // Register all dependencies
        factory.container.Register("userRepo", NewInMemoryUserRepository())
        factory.container.Register("emailService", NewSMTPEmailService("smtp.example.com", 587))
        factory.container.Register("logger", NewConsoleLogger("INFO"))
        
        return factory
    }
    
    func (sf *ServiceFactory) CreateUserService() *UserService {
        return NewUserService(
            sf.container.Get("userRepo").(UserRepository),
            sf.container.Get("emailService").(EmailService),
            sf.container.Get("logger").(Logger),
        )
    }
    
    // Use factory
    factory := NewServiceFactory()
    userService2 := factory.CreateUserService()
    
    user2, err := userService2.CreateUser("Bob", "[email protected]")
    if err != nil {
        fmt.Printf("Error creating user: %v\n", err)
    } else {
        fmt.Printf("Created user: %s\n", user2)
    }
    // Output:
    // [INFO] Creating new user
    // Sending email via SMTP (smtp.example.com:587) to [email protected]: Welcome
    // [INFO] User created successfully
    // Created user: User{ID: user_1, Name: Bob, Email: [email protected]}
}

Event-Driven Architectures​

Understanding Event-Driven Architectures​

Event-Driven Definition​

Event-driven architectures use events to trigger and communicate between services.

Loose Coupling​

Events enable loose coupling between different parts of the system.

package main

import "fmt"

func main() {
    // Event-driven architectures examples
    fmt.Println("Event-driven architectures examples:")
    
    // Define event types
    type EventType string
    
    const (
        UserCreated EventType = "user.created"
        UserUpdated EventType = "user.updated"
        UserDeleted EventType = "user.deleted"
        OrderPlaced EventType = "order.placed"
        PaymentProcessed EventType = "payment.processed"
    )
    
    // Define event
    type Event struct {
        Type      EventType
        Data      interface{}
        Timestamp string
        Source    string
    }
    
    func (e Event) String() string {
        return fmt.Sprintf("Event{Type: %s, Source: %s, Timestamp: %s, Data: %v}",
            e.Type, e.Source, e.Timestamp, e.Data)
    }
    
    // Define event handler interface
    type EventHandler interface {
        HandleEvent(event Event) error
        CanHandle(eventType EventType) bool
    }
    
    // Define event bus
    type EventBus struct {
        handlers map[EventType][]EventHandler
    }
    
    func NewEventBus() *EventBus {
        return &EventBus{
            handlers: make(map[EventType][]EventHandler),
        }
    }
    
    func (eb *EventBus) Subscribe(eventType EventType, handler EventHandler) {
        eb.handlers[eventType] = append(eb.handlers[eventType], handler)
    }
    
    func (eb *EventBus) Publish(event Event) error {
        if handlers, exists := eb.handlers[event.Type]; exists {
            for _, handler := range handlers {
                if handler.CanHandle(event.Type) {
                    if err := handler.HandleEvent(event); err != nil {
                        fmt.Printf("Error handling event %s: %v\n", event.Type, err)
                        return err
                    }
                }
            }
        }
        return nil
    }
    
    // Define event handlers
    type UserEventHandler struct {
        name string
    }
    
    func (ueh UserEventHandler) HandleEvent(event Event) error {
        fmt.Printf("[%s] Handling event: %s\n", ueh.name, event.Type)
        return nil
    }
    
    func (ueh UserEventHandler) CanHandle(eventType EventType) bool {
        return eventType == UserCreated || eventType == UserUpdated || eventType == UserDeleted
    }
    
    type OrderEventHandler struct {
        name string
    }
    
    func (oeh OrderEventHandler) HandleEvent(event Event) error {
        fmt.Printf("[%s] Handling event: %s\n", oeh.name, event.Type)
        return nil
    }
    
    func (oeh OrderEventHandler) CanHandle(eventType EventType) bool {
        return eventType == OrderPlaced || eventType == PaymentProcessed
    }
    
    type NotificationHandler struct {
        name string
    }
    
    func (nh NotificationHandler) HandleEvent(event Event) error {
        fmt.Printf("[%s] Sending notification for event: %s\n", nh.name, event.Type)
        return nil
    }
    
    func (nh NotificationHandler) CanHandle(eventType EventType) bool {
        return eventType == UserCreated || eventType == OrderPlaced || eventType == PaymentProcessed
    }
    
    // Define event store
    type EventStore struct {
        events []Event
    }
    
    func NewEventStore() *EventStore {
        return &EventStore{
            events: make([]Event, 0),
        }
    }
    
    func (es *EventStore) Append(event Event) {
        es.events = append(es.events, event)
    }
    
    func (es *EventStore) GetEvents(eventType EventType) []Event {
        var filtered []Event
        for _, event := range es.events {
            if event.Type == eventType {
                filtered = append(filtered, event)
            }
        }
        return filtered
    }
    
    func (es *EventStore) GetAllEvents() []Event {
        return es.events
    }
    
    // Define event publisher
    type EventPublisher struct {
        eventBus   *EventBus
        eventStore *EventStore
    }
    
    func NewEventPublisher(eventBus *EventBus, eventStore *EventStore) *EventPublisher {
        return &EventPublisher{
            eventBus:   eventBus,
            eventStore: eventStore,
        }
    }
    
    func (ep *EventPublisher) PublishEvent(event Event) error {
        // Store event
        ep.eventStore.Append(event)
        
        // Publish event
        return ep.eventBus.Publish(event)
    }
    
    // Use event-driven architecture
    eventBus := NewEventBus()
    eventStore := NewEventStore()
    eventPublisher := NewEventPublisher(eventBus, eventStore)
    
    // Create handlers
    userHandler := UserEventHandler{name: "UserHandler"}
    orderHandler := OrderEventHandler{name: "OrderHandler"}
    notificationHandler := NotificationHandler{name: "NotificationHandler"}
    
    // Subscribe handlers to events
    eventBus.Subscribe(UserCreated, userHandler)
    eventBus.Subscribe(UserCreated, notificationHandler)
    eventBus.Subscribe(UserUpdated, userHandler)
    eventBus.Subscribe(UserDeleted, userHandler)
    eventBus.Subscribe(OrderPlaced, orderHandler)
    eventBus.Subscribe(OrderPlaced, notificationHandler)
    eventBus.Subscribe(PaymentProcessed, orderHandler)
    eventBus.Subscribe(PaymentProcessed, notificationHandler)
    
    // Publish events
    fmt.Println("Publishing events:")
    
    events := []Event{
        {
            Type:      UserCreated,
            Data:      "User ID: 123, Name: Alice",
            Timestamp: "2023-12-07T10:00:00Z",
            Source:    "UserService",
        },
        {
            Type:      OrderPlaced,
            Data:      "Order ID: 456, Amount: $99.99",
            Timestamp: "2023-12-07T10:05:00Z",
            Source:    "OrderService",
        },
        {
            Type:      PaymentProcessed,
            Data:      "Payment ID: 789, Amount: $99.99",
            Timestamp: "2023-12-07T10:06:00Z",
            Source:    "PaymentService",
        },
        {
            Type:      UserUpdated,
            Data:      "User ID: 123, Updated: Email",
            Timestamp: "2023-12-07T10:10:00Z",
            Source:    "UserService",
        },
    }
    
    for _, event := range events {
        fmt.Printf("\nPublishing: %s\n", event.Type)
        if err := eventPublisher.PublishEvent(event); err != nil {
            fmt.Printf("Error publishing event: %v\n", err)
        }
    }
    // Output:
    // Publishing events:
    // 
    // Publishing: user.created
    // [UserHandler] Handling event: user.created
    // [NotificationHandler] Sending notification for event: user.created
    // 
    // Publishing: order.placed
    // [OrderHandler] Handling event: order.placed
    // [NotificationHandler] Sending notification for event: order.placed
    // 
    // Publishing: payment.processed
    // [OrderHandler] Handling event: payment.processed
    // [NotificationHandler] Sending notification for event: payment.processed
    // 
    // Publishing: user.updated
    // [UserHandler] Handling event: user.updated
    
    // Query event store
    fmt.Println("\nEvent store queries:")
    userCreatedEvents := eventStore.GetEvents(UserCreated)
    fmt.Printf("User created events: %d\n", len(userCreatedEvents))
    
    allEvents := eventStore.GetAllEvents()
    fmt.Printf("Total events: %d\n", len(allEvents))
    // Output:
    // Event store queries:
    // User created events: 1
    // Total events: 4
}

What You've Learned​

Congratulations! You now have a comprehensive understanding of Go's advanced OOP patterns:

Observer Patterns​

  • Understanding observer patterns and event-driven communication
  • Implementing one-to-many dependencies between objects
  • Creating flexible notification systems
  • Building event-driven architectures

Builder Patterns​

  • Understanding builder patterns and fluent interfaces
  • Implementing step-by-step object construction
  • Creating validation and error handling in builders
  • Building complex objects with clean APIs

Dependency Injection​

  • Understanding dependency injection and inversion of control
  • Implementing interface-based dependency injection
  • Creating dependency injection containers
  • Building testable and maintainable services

Event-Driven Architectures​

  • Understanding event-driven architectures and loose coupling
  • Implementing event buses and event handlers
  • Creating event stores and event publishers
  • Building scalable and maintainable systems

Key Concepts​

  • Observer patterns - One-to-many dependencies and notifications
  • Builder patterns - Step-by-step object construction
  • Dependency injection - Inversion of control and loose coupling
  • Event-driven architectures - Event-based communication and loose coupling
  • Advanced patterns - Combining multiple patterns for complex systems

Next Steps​

You now have a solid foundation in Go's advanced OOP patterns. These patterns form the foundation for building enterprise-level applications and implementing modern software architectures.

Understanding advanced OOP patterns is crucial for creating scalable, maintainable, and testable applications. These concepts form the foundation for all the more advanced programming techniques we'll cover in the coming chapters.

Ready to learn about error handling? Let's explore Go's error handling philosophy and learn how to build robust, error-resistant applications!