Observer Design Pattern

public interface OrderListener {
    void onOrderPlaced(Order order);
}

public class OrderService {
    // CopyOnWriteArrayList: iteration is safe even if a listener unsubscribes
    // itself during notification, which is a classic source of
    // ConcurrentModificationException with a plain ArrayList.
    private final List<OrderListener> listeners = new CopyOnWriteArrayList<>();

    public void subscribe(OrderListener l)   { listeners.add(l); }
    public void unsubscribe(OrderListener l) { listeners.remove(l); }

    public Order place(Cart cart) {
        Order order = repository.save(Order.from(cart));
        notifyPlaced(order);
        return order;
    }

    private void notifyPlaced(Order order) {
        for (OrderListener l : listeners) {
            try {
                l.onOrderPlaced(order);
            } catch (RuntimeException e) {
                // One broken listener must not lose the order or stop the others.
                log.error("listener {} failed", l.getClass().getSimpleName(), e);
            }
        }
    }
}

class EmailListener implements OrderListener {
    public void onOrderPlaced(Order order) { mailer.sendConfirmation(order); }
}

// In Spring this is usually ApplicationEventPublisher + @EventListener, which
// is the same pattern with the subscriber list managed by the container.

from typing import Callable, Protocol


class OrderListener(Protocol):
    def __call__(self, order: Order) -> None: ...


class OrderService:
    def __init__(self) -> None:
        # Plain callables, not an ABC: in Python a function IS the observer, and
        # requiring a class per listener buys nothing.
        self._listeners: list[OrderListener] = []

    def subscribe(self, listener: OrderListener) -> Callable[[], None]:
        self._listeners.append(listener)
        # Hand back an unsubscribe closure — far harder to leak than asking the
        # caller to keep the exact same reference around for later removal.
        return lambda: self._listeners.remove(listener)

    def place(self, cart: Cart) -> Order:
        order = repository.save(Order.from_cart(cart))
        for listener in list(self._listeners):   # copy: a listener may unsubscribe
            try:
                listener(order)
            except Exception:
                log.exception("listener %r failed", listener)
        return order


# svc.subscribe(lambda order: mailer.send_confirmation(order))
#
# Careful with bound methods: `svc.subscribe(obj.handle)` stores a strong
# reference to obj, so obj can never be garbage collected. weakref.WeakMethod
# is the fix when observers outlive their usefulness.

#include <functional>
#include <memory>
#include <vector>

class OrderService {
public:
    using Listener = std::function<void(const Order&)>;

    // Returning a token whose destructor unsubscribes (RAII) removes the whole
    // class of "forgot to unsubscribe" bugs that plague this pattern.
    class Subscription {
    public:
        ~Subscription() { if (svc_) svc_->remove(id_); }
        Subscription(Subscription&&) = default;
        Subscription(const Subscription&) = delete;
    private:
        friend class OrderService;
        Subscription(OrderService* s, std::size_t id) : svc_(s), id_(id) {}
        OrderService* svc_; std::size_t id_;
    };

    [[nodiscard]] Subscription subscribe(Listener l) {
        listeners_.emplace_back(next_id_, std::move(l));
        return Subscription(this, next_id_++);
    }

    void place(const Cart& cart) {
        const Order order = repository_.save(Order::from(cart));
        // Copy before iterating: a listener may unsubscribe during the callback.
        auto snapshot = listeners_;
        for (const auto& [id, l] : snapshot) l(order);
    }

private:
    void remove(std::size_t id) { /* erase-remove by id */ }
    std::vector<std::pair<std::size_t, Listener>> listeners_;
    std::size_t next_id_ = 1;
};

// C# has the observer pattern built into the language: `event` IS a subject,
// with += / -= as subscribe / unsubscribe. Hand-rolling a listener list here
// is almost always the wrong move.

public sealed class OrderService
{
    public event EventHandler<OrderPlacedEventArgs>? OrderPlaced;

    public Order Place(Cart cart)
    {
        var order = _repository.Save(Order.From(cart));

        // ?.Invoke captures the delegate once, so a handler unsubscribing mid-
        // notification can't null it out from under us.
        foreach (var handler in OrderPlaced?.GetInvocationList() ?? [])
        {
            try
            {
                ((EventHandler<OrderPlacedEventArgs>)handler)(this, new(order));
            }
            catch (Exception ex)
            {
                // A multicast delegate stops at the first throw — catching per
                // handler is the only way the rest still run.
                _log.LogError(ex, "listener {Handler} failed", handler.Method.Name);
            }
        }
        return order;
    }
}

// orders.OrderPlaced += (_, e) => mailer.SendConfirmation(e.Order);
//
// A long-lived publisher holding a handler on a short-lived subscriber is the
// classic .NET memory leak. Always -= in Dispose.

// Node has EventEmitter and the browser has EventTarget; both are this pattern.
// Here it is by hand, to show the moving parts.

export class OrderService {
  #listeners = new Set()

  subscribe(listener) {
    this.#listeners.add(listener)
    return () => this.#listeners.delete(listener)   // unsubscribe handle
  }

  async place(cart) {
    const order = await repository.save(Order.from(cart))

    // Copy the Set first: a listener that unsubscribes during notification
    // would otherwise mutate the collection being iterated.
    for (const listener of [...this.#listeners]) {
      try {
        await listener(order)
      } catch (err) {
        console.error('listener failed', err)
      }
    }
    return order
  }
}

// const off = orders.subscribe(order => mailer.sendConfirmation(order))
// off()   // later
//
// Note the `await` in the loop: listeners run one after another, so a slow one
// delays the rest. Promise.allSettled runs them concurrently instead — pick
// deliberately, because the choice is invisible at the call site.

package orders

import "sync"

type Listener func(Order)

type Service struct {
	mu        sync.RWMutex
	listeners map[int]Listener
	nextID    int
}

// Subscribe returns the function that removes this listener again — much
// harder to misuse than exporting an Unsubscribe(Listener), since funcs
// aren't comparable in Go and couldn't be looked up by value anyway.
func (s *Service) Subscribe(l Listener) (cancel func()) {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.listeners == nil {
		s.listeners = map[int]Listener{}
	}
	s.nextID++
	id := s.nextID
	s.listeners[id] = l
	return func() {
		s.mu.Lock()
		defer s.mu.Unlock()
		delete(s.listeners, id)
	}
}

func (s *Service) Place(cart Cart) (Order, error) {
	order, err := s.repo.Save(FromCart(cart))
	if err != nil {
		return Order{}, err
	}

	// Snapshot under the read lock, then notify without holding it — a listener
	// that calls back into Subscribe would otherwise deadlock.
	s.mu.RLock()
	snapshot := make([]Listener, 0, len(s.listeners))
	for _, l := range s.listeners {
		snapshot = append(snapshot, l)
	}
	s.mu.RUnlock()

	for _, l := range snapshot {
		l(order)
	}
	return order, nil
}

// Go's other idiom is a channel per subscriber, which decouples timing too —
// but then you own the buffering and the slow-consumer problem.

type Listener<T> = (event: T) => void | Promise<void>

interface OrderPlaced {
  readonly order: Order
  readonly at: Date
}

export class OrderService {
  // The generic is what plain JS can't give you: subscribing with a handler
  // that reads `event.custmer` is a compile error, not a 2 a.m. undefined.
  #listeners = new Set<Listener<OrderPlaced>>()

  subscribe(listener: Listener<OrderPlaced>): () => void {
    this.#listeners.add(listener)
    return () => { this.#listeners.delete(listener) }
  }

  async place(cart: Cart): Promise<Order> {
    const order = await repository.save(Order.from(cart))
    const event: OrderPlaced = { order, at: new Date() }

    // allSettled, not a sequential await: listeners are independent, and one
    // slow subscriber shouldn't hold up the others or the caller's response.
    const results = await Promise.allSettled(
      [...this.#listeners].map(l => l(event)),
    )
    for (const r of results) {
      if (r.status === 'rejected') console.error('listener failed', r.reason)
    }
    return order
  }
}