[Design Patterns] 11. 옵저버: 이벤트 드리븐 아키텍처의 핵심 — 실습

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

import java.util.ArrayList;
import java.util.List;

// Subject 인터페이스
public interface StockSubject {
    void attach(StockObserver observer);
    void detach(StockObserver observer);
    void notifyObservers();
}

// Observer 인터페이스
public interface StockObserver {
    void update(String symbol, double price, double change);
}

// 참조 구현: Subject 역할을 하는 구체 주식 클래스
public class Stock implements StockSubject {
    private final String symbol;
    private double price;
    private double change;
    private final List<StockObserver> observers = new ArrayList<>();

    public Stock(String symbol, double initialPrice) {
        this.symbol = symbol;
        this.price = initialPrice;
    }

    @Override
    public void attach(StockObserver observer) {
        observers.add(observer);
    }

    @Override
    public void detach(StockObserver observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        // 통지 도중 attach/detach가 호출될 수 있으므로 방어적으로 복사한다
        for (StockObserver observer : new ArrayList<>(observers)) {
            observer.update(symbol, price, change);
        }
    }

    public void setPrice(double newPrice) {
        this.change = newPrice - this.price;
        this.price = newPrice;
        notifyObservers();
    }
}

// 참조 구현: 로그만 남기는 가장 단순한 Observer
public class StockLogger implements StockObserver {
    @Override
    public void update(String symbol, double price, double change) {
        System.out.printf("[LOG] %s: $%.2f (%+.2f)%n", symbol, price, change);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import java.util.ArrayList;
import java.util.List;

public class TemperatureSensor {
    private double temperature;
    private final List<TemperatureObserver> observers = new ArrayList<>();

    public void attach(TemperatureObserver observer) {
        observers.add(observer);
    }

    public void detach(TemperatureObserver observer) {
        observers.remove(observer);
    }

    public void setTemperature(double temperature) {
        this.temperature = temperature;
        notifyObservers();
    }

    private void notifyObservers() {
        // 통지 도중 attach/detach가 호출될 수 있으므로 방어적으로 복사한다
        for (TemperatureObserver observer : new ArrayList<>(observers)) {
            observer.onTemperatureChanged(temperature);
        }
    }
}

public interface TemperatureObserver {
    void onTemperatureChanged(double temperature);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

// StockSubject/StockObserver(위 과제 1 정의)를 구현하는 WeakReference 기반 Subject
public class WeakReferenceStock implements StockSubject {
    private final String symbol;
    private double price;
    private double change;
    private final List<WeakReference<StockObserver>> observers = new ArrayList<>();

    public WeakReferenceStock(String symbol, double initialPrice) {
        this.symbol = symbol;
        this.price = initialPrice;
    }

    @Override
    public void attach(StockObserver observer) {
        observers.add(new WeakReference<>(observer));
    }

    @Override
    public void detach(StockObserver observer) {
        observers.removeIf(ref -> ref.get() == observer);
    }

    @Override
    public void notifyObservers() {
        Iterator<WeakReference<StockObserver>> iterator = observers.iterator();
        while (iterator.hasNext()) {
            WeakReference<StockObserver> ref = iterator.next();
            StockObserver observer = ref.get();

            if (observer == null) {
                iterator.remove(); // GC된 Observer 제거
            } else {
                observer.update(symbol, price, change);
            }
        }
    }

    public void setPrice(double newPrice) {
        this.change = newPrice - this.price;
        this.price = newPrice;
        notifyObservers();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 위 StockObserver 인터페이스(update(symbol, price, change))를 그대로 구현한다
public class AsyncObserver implements StockObserver {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    @Override
    public void update(String symbol, double price, double change) {
        executor.submit(() -> {
            try {
                processUpdate(symbol, price, change);
            } catch (Exception e) {
                // 비동기 작업의 예외는 호출 스레드로 전파되지 않으므로 반드시 여기서 처리한다
                System.err.println("AsyncObserver failed to process update: " + e.getMessage());
            }
        });
    }

    private void processUpdate(String symbol, double price, double change) {
        // 이 자리에서 실제로는 가격 이력 집계, 알림 발송 등 무거운 작업을 수행한다.
        // 여기서는 단순화를 위해 콘솔 출력으로 대체한다.
        System.out.printf("[Async] %s price change recorded: $%.2f (%+.2f)%n",
            symbol, price, change);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 흔한 실수: 메서드 위치는 맞지만 클래스가 Spring 빈으로 등록되지 않음
// -> 컴파일은 되지만 컴포넌트 스캔 대상이 아니므로 handleOrderCreated가
//    이벤트 리스너로 등록되지 않는다
// (OrderCreatedEvent, sendConfirmationEmail 정의는 아래 수정본 참고)
public class EmailService {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        sendConfirmationEmail(event.getOrder());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

// 이 예시를 위한 최소 도메인 타입 (Spring이 제공하는 타입이 아니라 이 글에서 정의)
class Order {
    private final String id;

    public Order(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

class OrderCreatedEvent {
    private final Order order;

    public OrderCreatedEvent(Order order) {
        this.order = order;
    }

    public Order getOrder() {
        return order;
    }
}

@Component
public class OrderService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;

    public void processOrder(Order order) {
        // 주문 처리 로직
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
    }
}

// 수정: @Component를 추가해 Spring 빈으로 등록되어야 컴포넌트 스캔에
// 걸리고, 그래야 메서드에 붙은 @EventListener도 실제로 등록된다
@Component
public class EmailService {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        sendConfirmationEmail(event.getOrder());
    }

    private void sendConfirmationEmail(Order order) {
        System.out.println("Confirmation email sent for order " + order.getId());
    }
}