행위 패턴(Behavioral Patterns): 객체 간 책임 분배와 통신

// Subject 인터페이스
public interface EventPublisher<T> {
    void subscribe(EventListener<T> listener);
    void unsubscribe(EventListener<T> listener);
    void notify(T event);
}
 
// Observer 인터페이스
@FunctionalInterface
public interface EventListener<T> {
    void onEvent(T event);
}
 
// 구현: 주문 이벤트 발행자
public class OrderEventPublisher implements EventPublisher<OrderEvent> {
    private final List<EventListener<OrderEvent>> listeners =
        new CopyOnWriteArrayList<>(); // 스레드 안전
 
    public void subscribe(EventListener<OrderEvent> listener) {
        listeners.add(listener);
    }
 
    public void unsubscribe(EventListener<OrderEvent> listener) {
        listeners.remove(listener);
    }
 
    public void notify(OrderEvent event) {
        listeners.forEach(listener -> listener.onEvent(event));
    }
}
 
// 사용
OrderEventPublisher publisher = new OrderEventPublisher();
publisher.subscribe(event -> sendEmail(event));           // 이메일 알림
publisher.subscribe(event -> updateInventory(event));     // 재고 갱신
publisher.subscribe(event -> recordAnalytics(event));     // 분석 기록
publisher.subscribe(event -> notifyWarehouse(event));     // 창고 알림

// 전략 인터페이스
public interface PaymentStrategy {
    PaymentResult pay(Money amount, PaymentDetails details);
    boolean supports(PaymentType type);
}
 
// 구체 전략들
public class CreditCardStrategy implements PaymentStrategy {
    public PaymentResult pay(Money amount, PaymentDetails details) {
        // 신용카드 결제 로직
        return callCardGateway(details.getCardNumber(), amount);
    }
    public boolean supports(PaymentType type) {
        return type == PaymentType.CREDIT_CARD;
    }
}
 
public class BankTransferStrategy implements PaymentStrategy {
    public PaymentResult pay(Money amount, PaymentDetails details) {
        // 계좌이체 로직
        return initiateBankTransfer(details.getAccountNumber(), amount);
    }
    public boolean supports(PaymentType type) {
        return type == PaymentType.BANK_TRANSFER;
    }
}
 
public class CryptoStrategy implements PaymentStrategy {
    public PaymentResult pay(Money amount, PaymentDetails details) {
        // 암호화폐 결제 로직
        return sendCryptoTransaction(details.getWalletAddress(), amount);
    }
    public boolean supports(PaymentType type) {
        return type == PaymentType.CRYPTO;
    }
}
 
// 컨텍스트: 전략을 사용하는 클래스
public class PaymentProcessor {
    private final List<PaymentStrategy> strategies;
 
    public PaymentProcessor(List<PaymentStrategy> strategies) {
        this.strategies = strategies;
    }
 
    public PaymentResult process(PaymentType type, Money amount,
                                  PaymentDetails details) {
        return strategies.stream()
            .filter(s -> s.supports(type))
            .findFirst()
            .orElseThrow(() -> new UnsupportedPaymentException(type))
            .pay(amount, details);
    }
}

// 함수형 Strategy
type SortStrategy<T> = (a: T, b: T) => number;
 
const byPrice: SortStrategy<Product> = (a, b) => a.price - b.price;
const byRating: SortStrategy<Product> = (a, b) => b.rating - a.rating;
const byName: SortStrategy<Product> = (a, b) => a.name.localeCompare(b.name);
 
// 전략을 함수 인자로 전달
const sortedProducts = products.toSorted(byPrice);

public abstract class DataProcessor {
    // Template Method: 알고리즘의 골격 (final로 변경 방지)
    public final ProcessingResult process(DataSource source) {
        RawData raw = extract(source);          // 1. 추출
        ValidatedData validated = validate(raw); // 2. 검증
        TransformedData transformed = transform(validated); // 3. 변환
        load(transformed);                       // 4. 적재
        return createResult(transformed);        // 5. 결과 생성
    }
 
    // 공통 단계: 기본 구현 제공
    protected RawData extract(DataSource source) {
        return source.read();
    }
 
    // 추상 단계: 서브클래스가 반드시 구현
    protected abstract ValidatedData validate(RawData raw);
    protected abstract TransformedData transform(ValidatedData data);
 
    // Hook 메서드: 선택적으로 오버라이드
    protected void load(TransformedData data) {
        defaultStorage.save(data);
    }
 
    protected ProcessingResult createResult(TransformedData data) {
        return new ProcessingResult(data.getRecordCount());
    }
}
 
// CSV 데이터 프로세서
public class CsvDataProcessor extends DataProcessor {
    @Override
    protected ValidatedData validate(RawData raw) {
        // CSV 특화 검증 로직
        return csvValidator.validate(raw);
    }
 
    @Override
    protected TransformedData transform(ValidatedData data) {
        // CSV 특화 변환 로직
        return csvTransformer.transform(data);
    }
}

// Command 인터페이스
public interface Command {
    CommandResult execute();
    void undo(); // 실행 취소
    String describe(); // 로깅용
}
 
// 구체 Command
public class CreateOrderCommand implements Command {
    private final OrderService orderService;
    private final OrderRequest request;
    private String createdOrderId;
 
    public CreateOrderCommand(OrderService orderService, OrderRequest request) {
        this.orderService = orderService;
        this.request = request;
    }
 
    @Override
    public CommandResult execute() {
        Order order = orderService.create(request);
        this.createdOrderId = order.getId(); // undo를 위해 저장
        return CommandResult.success(order);
    }
 
    @Override
    public void undo() {
        if (createdOrderId != null) {
            orderService.cancel(createdOrderId);
        }
    }
 
    @Override
    public String describe() {
        return "CreateOrder: " + request.getProductId();
    }
}
 
// 명령 실행기 (Invoker)
public class CommandQueue {
    private final Queue<Command> pending = new ConcurrentLinkedQueue<>();
    private final Deque<Command> executed = new ConcurrentLinkedDeque<>();
 
    public void enqueue(Command command) {
        pending.offer(command);
    }
 
    public void processAll() {
        while (!pending.isEmpty()) {
            Command cmd = pending.poll();
            try {
                cmd.execute();
                executed.push(cmd);
            } catch (Exception e) {
                // 실패 시 이전 명령들 롤백
                rollbackAll();
                throw e;
            }
        }
    }
 
    public void rollbackAll() {
        while (!executed.isEmpty()) {
            executed.pop().undo();
        }
    }
}

클라이언트 ──→ Command Bus ──→ Command Handler ──→ Write DB
클라이언트 ──→ Query Bus  ──→ Query Handler  ──→ Read DB

[기존 방식: 상태 저장]
Account: { id: 1, balance: 1500 }
→ 어떻게 1500이 되었는지 알 수 없음
 
[Event Sourcing: 이벤트 저장]
1. AccountCreated { id: 1, initialBalance: 0 }
2. MoneyDeposited { id: 1, amount: 2000 }
3. MoneyWithdrawn { id: 1, amount: 500 }
→ 재생하면 balance = 0 + 2000 - 500 = 1500
→ 모든 변경 이력이 완벽하게 보존됨

// 도메인 이벤트
public sealed interface AccountEvent {
    record AccountCreated(String accountId, Money initialBalance,
                          Instant timestamp) implements AccountEvent {}
    record MoneyDeposited(String accountId, Money amount,
                          Instant timestamp) implements AccountEvent {}
    record MoneyWithdrawn(String accountId, Money amount,
                          Instant timestamp) implements AccountEvent {}
}
 
// 이벤트 저장소
public interface EventStore {
    void append(String streamId, List<AccountEvent> events, long expectedVersion);
    List<AccountEvent> getEvents(String streamId);
    List<AccountEvent> getEvents(String streamId, long fromVersion);
}
 
// Aggregate: 이벤트를 재생하여 상태 복원
public class Account {
    private String id;
    private Money balance;
    private long version;
 
    // 이벤트 재생으로 상태 복원
    public static Account reconstitute(List<AccountEvent> events) {
        Account account = new Account();
        events.forEach(account::apply);
        return account;
    }
 
    private void apply(AccountEvent event) {
        switch (event) {
            case AccountCreated e -> {
                this.id = e.accountId();
                this.balance = e.initialBalance();
            }
            case MoneyDeposited e -> {
                this.balance = this.balance.add(e.amount());
            }
            case MoneyWithdrawn e -> {
                this.balance = this.balance.subtract(e.amount());
            }
        }
        this.version++;
    }
}

이벤트 1 → 이벤트 2 → ... → 이벤트 1000 → [스냅샷] → 이벤트 1001 → ...
                                              ↑
                               복원 시 여기부터 재생 시작

Order Service ──→ [OrderCreated Event]
                         │
                    ├──→ Payment Service ──→ [PaymentCompleted Event]
                    │                              │
                    │                         ├──→ Inventory Service ──→ [ItemReserved]
                    │                         │                              │
                    │                         │                         Shipping Service
                    │                         │
                    │                    [PaymentFailed] → 보상 트랜잭션 실행

                    Saga Orchestrator
                    ┌──────────────┐
                    │ 1. 주문 생성   │──→ Order Service
                    │ 2. 결제 처리   │──→ Payment Service
                    │ 3. 재고 예약   │──→ Inventory Service
                    │ 4. 배송 요청   │──→ Shipping Service
                    └──────────────┘
                    실패 시 역순으로 보상 트랜잭션 실행

          성공
    ┌──────────────┐
    ▼              │
[CLOSED] ──실패 누적──→ [OPEN] ──타임아웃──→ [HALF-OPEN]
    ▲                      │                    │
    │                      ▼                    │
    │               즉시 실패 반환          일부 요청 허용
    │                                           │
    └──────────── 성공 ──────────────────────────┘
                    실패 → [OPEN]으로 복귀

public class CircuitBreaker {
    private enum State { CLOSED, OPEN, HALF_OPEN }
 
    private volatile State state = State.CLOSED;
    private final AtomicInteger failureCount = new AtomicInteger(0);
    private final int failureThreshold;
    private final Duration timeout;
    private volatile Instant lastFailureTime;
 
    public <T> T execute(Supplier<T> operation, Supplier<T> fallback) {
        if (state == State.OPEN) {
            if (isTimeoutExpired()) {
                state = State.HALF_OPEN;
            } else {
                return fallback.get(); // Fail Fast
            }
        }
 
        try {
            T result = operation.get();
            onSuccess();
            return result;
        } catch (Exception e) {
            onFailure();
            return fallback.get();
        }
    }
 
    private void onSuccess() {
        failureCount.set(0);
        state = State.CLOSED;
    }
 
    private void onFailure() {
        lastFailureTime = Instant.now();
        if (failureCount.incrementAndGet() >= failureThreshold) {
            state = State.OPEN;
        }
    }
 
    private boolean isTimeoutExpired() {
        return Duration.between(lastFailureTime, Instant.now()).compareTo(timeout) > 0;
    }
}

public interface ChatMediator {
    void sendMessage(String message, User sender);
    void addUser(User user);
}
 
public class ChatRoom implements ChatMediator {
    private final List<User> users = new ArrayList<>();
 
    public void addUser(User user) {
        users.add(user);
    }
 
    public void sendMessage(String message, User sender) {
        users.stream()
            .filter(user -> !user.equals(sender))
            .forEach(user -> user.receive(message, sender.getName()));
    }
}

public interface RequestHandler {
    Response handle(Request request);
}
 
public abstract class Middleware implements RequestHandler {
    private Middleware next;
 
    public Middleware setNext(Middleware next) {
        this.next = next;
        return next; // Fluent API
    }
 
    public Response handle(Request request) {
        if (next != null) {
            return next.handle(request);
        }
        return Response.ok();
    }
}
 
public class AuthMiddleware extends Middleware {
    public Response handle(Request request) {
        if (!isAuthenticated(request)) {
            return Response.unauthorized();
        }
        return super.handle(request); // 다음 핸들러로 전달
    }
}
 
public class RateLimitMiddleware extends Middleware {
    public Response handle(Request request) {
        if (isRateLimited(request)) {
            return Response.tooManyRequests();
        }
        return super.handle(request);
    }
}
 
public class LoggingMiddleware extends Middleware {
    public Response handle(Request request) {
        log(request);
        Response response = super.handle(request);
        log(response);
        return response;
    }
}
 
// 체인 구성
Middleware chain = new LoggingMiddleware();
chain.setNext(new AuthMiddleware())
     .setNext(new RateLimitMiddleware())
     .setNext(new BusinessLogicHandler());

public interface OrderState {
    OrderState pay(Order order);
    OrderState ship(Order order);
    OrderState deliver(Order order);
    OrderState cancel(Order order);
}
 
public class PendingState implements OrderState {
    public OrderState pay(Order order) {
        order.setPaymentDate(Instant.now());
        return new PaidState();
    }
    public OrderState cancel(Order order) {
        order.setCancelReason("Cancelled before payment");
        return new CancelledState();
    }
    public OrderState ship(Order order) {
        throw new IllegalStateException("Cannot ship unpaid order");
    }
    public OrderState deliver(Order order) {
        throw new IllegalStateException("Cannot deliver unpaid order");
    }
}
 
public class PaidState implements OrderState {
    public OrderState ship(Order order) {
        order.setShippingDate(Instant.now());
        return new ShippedState();
    }
    public OrderState cancel(Order order) {
        order.refund(); // 환불 처리
        return new CancelledState();
    }
    // ...
}

클라이언트 요청들
    │   │   │
    ▼   ▼   ▼
[이벤트 디멀티플렉서 (Event Demultiplexer)]
    (select, epoll, kqueue, io_uring)
              │
              ▼
    [이벤트 디스패처 (Reactor/Event Loop)]
              │
        ┌─────┼─────┐
        ▼     ▼     ▼
    Handler Handler Handler

[Actor System]
    │
    ├── /user
    │     ├── /user/orderProcessor (Actor)
    │     │     ├── /user/orderProcessor/validator
    │     │     └── /user/orderProcessor/shipper
    │     └── /user/paymentHandler (Actor)
    │
    └── /system (시스템 Actor)