[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

// Observer 패턴 없이 구현한다면?
public class BadStockSystem {
    private double stockPrice = 100.0;
    
    // 문제: 새로운 Observer 추가 시마다 코드 수정 필요
    private StockDisplay display1;
    private StockDisplay display2; 
    private StockAlert alert;
    private TradingBot bot;
    private AnalyticsEngine analytics;
    
    public void updatePrice(double newPrice) {
        this.stockPrice = newPrice;
        
        // 😱 모든 의존 객체를 하나씩 호출해야 함
        if (display1 != null) display1.update(stockPrice);
        if (display2 != null) display2.update(stockPrice);
        if (alert != null) alert.update(stockPrice);
        if (bot != null) bot.update(stockPrice);
        if (analytics != null) analytics.update(stockPrice);
        
        // 새로운 Observer 추가 시마다 이 코드를 수정해야 함!
        // 강한 결합, 개방-폐쇄 원칙 위배, 확장성 제로
    }
}

  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
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.text.DecimalFormat;

// Observer 패턴으로 우아하게 해결
// 1. Subject 인터페이스 - 관찰 대상
interface Subject {
    void attach(Observer observer);    // 관찰자 등록
    void detach(Observer observer);    // 관찰자 해제  
    void notifyObservers();           // 모든 관찰자에게 통지
}

// 2. Observer 인터페이스 - 관찰자
interface Observer {
    void update(Subject subject);      // 상태 변화 시 호출됨
}

// 3. ConcreteSubject - 구체적인 관찰 대상
class Stock implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String symbol;
    private double price;
    private double previousPrice;
    private LocalDateTime lastUpdate;
    
    public Stock(String symbol, double initialPrice) {
        this.symbol = symbol;
        this.price = initialPrice;
        this.previousPrice = initialPrice;
        this.lastUpdate = LocalDateTime.now();
    }
    
    @Override
    public void attach(Observer observer) {
        if (!observers.contains(observer)) {
            observers.add(observer);
            System.out.println("Observer attached to " + symbol);
        }
    }
    
    @Override
    public void detach(Observer observer) {
        if (observers.remove(observer)) {
            System.out.println("Observer detached from " + symbol);
        }
    }
    
    @Override
    public void notifyObservers() {
        System.out.println("Notifying " + observers.size() + " observers of " + symbol);
        
        // 방어적 복사를 통한 동시 수정 문제 방지
        List<Observer> observersCopy = new ArrayList<>(observers);
        
        for (Observer observer : observersCopy) {
            try {
                observer.update(this);
            } catch (Exception e) {
                System.err.println("Error notifying observer: " + e.getMessage());
                // 에러 발생한 Observer는 자동으로 제거할 수도 있음
            }
        }
    }
    
    // 비즈니스 로직 - 가격 변경
    public void setPrice(double newPrice) {
        if (Double.compare(this.price, newPrice) != 0) {
            this.previousPrice = this.price;
            this.price = newPrice;
            this.lastUpdate = LocalDateTime.now();
            
            // 상태 변경 시 자동으로 모든 Observer에게 통지
            notifyObservers();
        }
    }
    
    // Getter 메서드들
    public double getPrice() { return price; }
    public double getPreviousPrice() { return previousPrice; }
    public double getChange() { return price - previousPrice; }
    public double getChangePercent() { 
        return previousPrice != 0 ? (getChange() / previousPrice) * 100 : 0; 
    }
    public String getSymbol() { return symbol; }
    public LocalDateTime getLastUpdate() { return lastUpdate; }
    public int getObserverCount() { return observers.size(); }
}

// 4. ConcreteObserver들 - 다양한 관찰자 구현
class StockDisplay implements Observer {
    private String displayName;
    private DecimalFormat priceFormat = new DecimalFormat("$#,##0.00");
    private DecimalFormat percentFormat = new DecimalFormat("#0.00%");
    
    public StockDisplay(String displayName) {
        this.displayName = displayName;
    }
    
    @Override
    public void update(Subject subject) {
        if (subject instanceof Stock) {
            Stock stock = (Stock) subject;
            double change = stock.getChange();
            String trend = change > 0 ? "📈" : change < 0 ? "📉" : "➡️";
            
            System.out.printf("[%s] %s %s %s (%.2f%%) at %s\n",
                displayName,
                trend,
                stock.getSymbol(),
                priceFormat.format(stock.getPrice()),
                stock.getChangePercent(),
                stock.getLastUpdate().format(DateTimeFormatter.ofPattern("HH:mm:ss"))
            );
        }
    }
}

class StockAlert implements Observer {
    private double upperThreshold;
    private double lowerThreshold;
    private String alertChannel;
    
    public StockAlert(double lowerThreshold, double upperThreshold, String alertChannel) {
        this.lowerThreshold = lowerThreshold;
        this.upperThreshold = upperThreshold;
        this.alertChannel = alertChannel;
    }
    
    @Override
    public void update(Subject subject) {
        if (subject instanceof Stock) {
            Stock stock = (Stock) subject;
            double price = stock.getPrice();
            
            if (price > upperThreshold) {
                sendAlert(stock, "HIGH", "Price exceeded upper threshold!");
            } else if (price < lowerThreshold) {
                sendAlert(stock, "LOW", "Price fell below lower threshold!");
            }
        }
    }
    
    private void sendAlert(Stock stock, String level, String message) {
        System.out.printf("🚨 [%s ALERT via %s] %s: %s (Current: $%.2f)\n",
            level, alertChannel, stock.getSymbol(), message, stock.getPrice());
    }
}

class TradingBot implements Observer {
    private String strategyName;
    private double buyThreshold;
    private double sellThreshold;
    private Map<String, Integer> portfolio = new HashMap<>();
    
    public TradingBot(String strategyName, double buyThreshold, double sellThreshold) {
        this.strategyName = strategyName;
        this.buyThreshold = buyThreshold;
        this.sellThreshold = sellThreshold;
    }
    
    @Override
    public void update(Subject subject) {
        if (subject instanceof Stock) {
            Stock stock = (Stock) subject;
            String symbol = stock.getSymbol();
            double changePercent = stock.getChangePercent();
            
            if (changePercent < -buyThreshold) {
                // 가격이 크게 떨어지면 매수
                buyStock(symbol, stock.getPrice());
            } else if (changePercent > sellThreshold) {
                // 가격이 크게 오르면 매도
                sellStock(symbol, stock.getPrice());
            }
        }
    }
    
    private void buyStock(String symbol, double price) {
        int shares = 100; // 간단히 100주씩
        portfolio.put(symbol, portfolio.getOrDefault(symbol, 0) + shares);
        System.out.printf("🤖 [%s] BUY: %d shares of %s at $%.2f\n",
            strategyName, shares, symbol, price);
    }
    
    private void sellStock(String symbol, double price) {
        int currentShares = portfolio.getOrDefault(symbol, 0);
        if (currentShares > 0) {
            int sharesToSell = Math.min(100, currentShares);
            portfolio.put(symbol, currentShares - sharesToSell);
            System.out.printf("🤖 [%s] SELL: %d shares of %s at $%.2f\n",
                strategyName, sharesToSell, symbol, price);
        }
    }
}

class AnalyticsEngine implements Observer {
    private List<Double> priceHistory = new ArrayList<>();
    private String analysisType;
    
    public AnalyticsEngine(String analysisType) {
        this.analysisType = analysisType;
    }
    
    @Override
    public void update(Subject subject) {
        if (subject instanceof Stock) {
            Stock stock = (Stock) subject;
            priceHistory.add(stock.getPrice());
            
            // 최근 10개 데이터만 유지
            if (priceHistory.size() > 10) {
                priceHistory.remove(0);
            }
            
            if (priceHistory.size() >= 5) {
                performAnalysis(stock);
            }
        }
    }
    
    private void performAnalysis(Stock stock) {
        double average = priceHistory.stream().mapToDouble(Double::doubleValue).average().orElse(0);
        double volatility = calculateVolatility();
        
        System.out.printf("📊 [%s] %s Analysis: Avg=%.2f, Volatility=%.2f%%\n",
            analysisType, stock.getSymbol(), average, volatility);
    }
    
    private double calculateVolatility() {
        if (priceHistory.size() < 2) return 0;
        
        double avg = priceHistory.stream().mapToDouble(Double::doubleValue).average().orElse(0);
        double variance = priceHistory.stream()
            .mapToDouble(price -> Math.pow(price - avg, 2))
            .average().orElse(0);
        
        return Math.sqrt(variance) / avg * 100; // 변동성을 백분율로
    }
}

// 사용 예시: 실제 주식 거래 시뮬레이션
public class ObserverPatternDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1. Subject 생성 (관찰 대상)
        Stock appleStock = new Stock("AAPL", 150.00);
        
        // 2. 다양한 Observer들 생성 및 등록
        StockDisplay mainDisplay = new StockDisplay("Main Dashboard");
        StockDisplay mobileApp = new StockDisplay("Mobile App");
        StockAlert priceAlert = new StockAlert(140.0, 160.0, "SMS");
        TradingBot dayTrader = new TradingBot("DayTrader", 2.0, 3.0); // 2% 하락시 매수, 3% 상승시 매도
        AnalyticsEngine technicalAnalysis = new AnalyticsEngine("Technical");
        
        // Observer 등록
        appleStock.attach(mainDisplay);
        appleStock.attach(mobileApp);
        appleStock.attach(priceAlert);
        appleStock.attach(dayTrader);
        appleStock.attach(technicalAnalysis);
        
        System.out.println("=== Stock Trading Simulation Started ===\n");
        
        // 3. 주식 가격 변화 시뮬레이션
        double[] priceChanges = {152.50, 148.00, 155.00, 162.00, 158.50, 145.00, 167.00};
        
        for (double newPrice : priceChanges) {
            System.out.println(">>> Price Update Event <<<");
            appleStock.setPrice(newPrice);
            System.out.println();
            Thread.sleep(1000); // 1초 간격
        }
        
        // 4. Observer 동적 제거 테스트
        System.out.println("=== Removing Mobile App Observer ===");
        appleStock.detach(mobileApp);
        
        appleStock.setPrice(170.00);
        
        System.out.println("\n=== Final Statistics ===");
        System.out.println("Total observers: " + appleStock.getObserverCount());
        System.out.println("Final price: $" + appleStock.getPrice());
        System.out.println("Total change: $" + appleStock.getChange());
    }
}

/*
출력 예시:
=== Stock Trading Simulation Started ===

>>> Price Update Event <<<
Notifying 5 observers of AAPL
[Main Dashboard] 📈 AAPL $152.50 (1.67%) at 14:23:15
[Mobile App] 📈 AAPL $152.50 (1.67%) at 14:23:15
📊 [Technical] AAPL Analysis: Avg=151.25, Volatility=1.12%

>>> Price Update Event <<<
Notifying 5 observers of AAPL
[Main Dashboard] 📉 AAPL $148.00 (-2.95%) at 14:23:16
[Mobile App] 📉 AAPL $148.00 (-2.95%) at 14:23:16
🤖 [DayTrader] BUY: 100 shares of AAPL at $148.00
📊 [Technical] AAPL Analysis: Avg=150.17, Volatility=2.34%
...
*/

 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

// Observer 패턴이 제공하는 핵심 가치들

public class ObserverPatternBenefits {
    
    /*
    1. 느슨한 결합 (Loose Coupling)
    - Subject는 Observer의 구체적인 타입을 몰라도 됨
    - Observer는 Subject의 내부 구현을 몰라도 됨
    - 서로의 존재만 인터페이스를 통해 알고 있음
    */
    
    /*
    2. 개방-폐쇄 원칙 (Open-Closed Principle) 
    - 새로운 Observer 추가: Subject 코드 변경 없음
    - 새로운 Subject 추가: 기존 Observer 코드 변경 없음
    - 확장에는 열려있고, 수정에는 닫혀있음
    */
    
    /*
    3. 런타임 관계 설정
    - 프로그램 실행 중에 Observer 등록/해제 가능
    - 동적인 의존성 관리
    - 사용자 설정에 따른 유연한 기능 활성화
    */
    
    /*
    4. 브로드캐스트 통신
    - 하나의 이벤트로 여러 객체에게 동시 통지
    - 효율적인 일대다 통신
    - 이벤트 기반 아키텍처의 기초
    */
    
    // 실제 활용 예시
    public void demonstrateBenefits() {
        Stock stock = new Stock("TSLA", 200.0);
        
        // 런타임에 동적으로 Observer 추가
        if (UserPreferences.isNotificationEnabled()) {
            stock.attach(new StockDisplay("User Dashboard"));
        }
        
        if (UserPreferences.isAlertEnabled()) {
            stock.attach(new StockAlert(180.0, 220.0, "Email"));
        }
        
        if (UserPreferences.isAutoTradingEnabled()) {
            stock.attach(new TradingBot("AutoTrader", 5.0, 5.0));
        }
        
        // 하나의 이벤트로 모든 활성화된 Observer에게 통지
        stock.setPrice(195.0);
    }
}

 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

import java.util.List;
import java.util.ArrayList;
import java.time.LocalDateTime;

// Push Model: Subject가 데이터를 밀어넣음
interface PushObserver {
    void update(String symbol, double price, double previousPrice, 
                double change, double volume, LocalDateTime timestamp);
}

class PushStock {
    private List<PushObserver> observers = new ArrayList<>();
    private String symbol;
    private double price, previousPrice;
    private double volume;
    private LocalDateTime lastUpdate;
    
    public void updateMarketData(double newPrice, double newVolume) {
        previousPrice = price;
        price = newPrice;
        volume = newVolume;
        lastUpdate = LocalDateTime.now();
        double change = price - previousPrice;
        
        // Push: 모든 관련 정보를 한 번에 전달
        for (PushObserver observer : observers) {
            observer.update(symbol, price, previousPrice, change, volume, lastUpdate);
        }
    }
}

class QuickTrader implements PushObserver {
    @Override
    public void update(String symbol, double price, double previousPrice, 
                      double change, double volume, LocalDateTime timestamp) {
        // 모든 데이터가 이미 전달되어 즉시 처리 가능
        if (Math.abs(change) > 1.0 && volume > 100000) {
            executeTrade(symbol, price, change > 0 ? "SELL" : "BUY");
        }
    }
    
    private void executeTrade(String symbol, double price, String action) {
        System.out.printf("[Quick] %s: %s at $%.2f\n", action, symbol, price);
    }
}

/*
Push Model 장점:
- 빠른 응답: Observer가 즉시 모든 정보를 받음
- 단순한 Observer: 복잡한 데이터 조회 로직 불필요
- 네트워크 효율성: 한 번의 호출로 모든 정보 전달

Push Model 단점:
- 불필요한 데이터 전송: Observer가 사용하지 않는 데이터도 전달
- 높은 결합도: Subject가 Observer의 요구사항을 알아야 함
- 인터페이스 변경 어려움: 새 데이터 추가 시 모든 Observer 수정
*/

  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
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.time.LocalDateTime;

// Pull Model: Observer가 필요한 데이터를 끌어옴
interface PullObserver {
    void update(Subject subject); // Subject 참조만 전달
}

class PullStock implements Subject {
    private List<PullObserver> observers = new ArrayList<>();
    private String symbol;
    private double price, previousPrice;
    private double volume, marketCap;
    private LocalDateTime lastUpdate;
    private Map<String, Object> additionalData = new HashMap<>();
    
    public void updateMarketData(double newPrice, double newVolume) {
        previousPrice = price;
        price = newPrice;
        volume = newVolume;
        lastUpdate = LocalDateTime.now();
        
        // Pull: 변경 사실만 통지
        notifyObservers();
    }
    
    @Override
    public void notifyObservers() {
        for (PullObserver observer : observers) {
            observer.update(this); // this만 전달
        }
    }
    
    // Pull을 위한 다양한 getter 메서드들
    public double getPrice() { return price; }
    public double getPreviousPrice() { return previousPrice; }
    public double getChange() { return price - previousPrice; }
    public double getVolume() { return volume; }
    public String getSymbol() { return symbol; }
    public LocalDateTime getLastUpdate() { return lastUpdate; }
    public double getMarketCap() { return marketCap; }
    public Object getAdditionalData(String key) { return additionalData.get(key); }
}

class SmartAnalyzer implements PullObserver {
    private String analysisType;
    
    public SmartAnalyzer(String analysisType) {
        this.analysisType = analysisType;
    }
    
    @Override
    public void update(Subject subject) {
        if (subject instanceof PullStock) {
            PullStock stock = (PullStock) subject;
            
            // 분석 타입에 따라 필요한 데이터만 선택적으로 pull
            switch (analysisType) {
                case "PRICE_ONLY":
                    double price = stock.getPrice(); // 가격만 필요
                    analyzePriceTrend(price);
                    break;
                    
                case "VOLUME_ANALYSIS":
                    double volume = stock.getVolume(); // 거래량만 필요
                    double change = stock.getChange();
                    analyzeVolumePattern(volume, change);
                    break;
                    
                case "COMPREHENSIVE":
                    // 포괄적 분석은 여러 데이터 필요
                    performComprehensiveAnalysis(stock);
                    break;
            }
        }
    }
    
    private void analyzePriceTrend(double price) {
        System.out.printf("📈 Price Analysis: Current price $%.2f\n", price);
    }
    
    private void analyzeVolumePattern(double volume, double change) {
        System.out.printf("📊 Volume Analysis: %.0f shares, change $%.2f\n", volume, change);
    }
    
    private void performComprehensiveAnalysis(PullStock stock) {
        System.out.printf("🔍 Comprehensive: %s - Price: $%.2f, Volume: %.0f, Cap: $%.2fB\n",
            stock.getSymbol(), stock.getPrice(), stock.getVolume(), stock.getMarketCap() / 1_000_000_000);
    }
}

/*
Pull Model 장점:
- 낮은 결합도: Subject는 Observer의 요구사항을 몰라도 됨
- 유연성: Observer가 필요한 데이터만 선택적으로 가져감
- 확장성: 새로운 데이터 추가 시 기존 Observer 영향 없음
- 지연 계산: 필요할 때만 expensive operation 수행

Pull Model 단점:
- 잠재적 성능 오버헤드: 여러 번의 메서드 호출 필요
- 복잡한 Observer: 데이터 조회 로직을 Observer가 구현해야 함
- 일관성 문제: 여러 번 호출 사이에 데이터가 변경될 수 있음
*/

 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

// 하이브리드 모델: 중요한 데이터는 Push, 상세 데이터는 Pull
interface HybridObserver {
    void update(String symbol, double price, double change, Subject subject);
}

class HybridStock implements Subject {
    private List<HybridObserver> observers = new ArrayList<>();
    // ... 필드들
    
    public void updatePrice(double newPrice) {
        double previousPrice = this.price;
        this.price = newPrice;
        double change = newPrice - previousPrice;
        
        // 핵심 데이터는 Push로 즉시 전달 + 상세 조회를 위한 Subject 참조도 함께
        for (HybridObserver observer : observers) {
            observer.update(symbol, price, change, this);
        }
    }
}

class AdaptiveTrader implements HybridObserver {
    @Override
    public void update(String symbol, double price, double change, Subject subject) {
        // 1. Push로 받은 핵심 데이터로 빠른 판단
        if (Math.abs(change) > 2.0) {
            // 긴급 상황: Push 데이터만으로 즉시 대응
            emergencyTrade(symbol, price, change);
        } else {
            // 2. 일반 상황: Pull로 추가 데이터 조회 후 신중한 판단
            HybridStock stock = (HybridStock) subject;
            double volume = stock.getVolume();
            double marketCap = stock.getMarketCap();
            
            normalTrade(symbol, price, change, volume, marketCap);
        }
    }
    
    private void emergencyTrade(String symbol, double price, double change) {
        System.out.printf("⚡ Emergency Trade: %s at $%.2f (%.2f change)\n", 
                          symbol, price, change);
    }
    
    private void normalTrade(String symbol, double price, double change, 
                           double volume, double marketCap) {
        System.out.printf("🤔 Analyzed Trade: %s - considering all factors\n", symbol);
    }
}

 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

import java.util.concurrent.atomic.AtomicBoolean;

// 안티패턴: Polling으로 가격 변화를 감지
class PollingTrader {
    private final Stock stock;
    private double lastKnownPrice;
    private final AtomicBoolean running = new AtomicBoolean(true);

    public PollingTrader(Stock stock) {
        this.stock = stock;
        this.lastKnownPrice = stock.getPrice();
    }

    public void startPolling() throws InterruptedException {
        while (running.get()) {
            double currentPrice = stock.getPrice();
            if (Double.compare(currentPrice, lastKnownPrice) != 0) {
                System.out.printf("Price changed: %.2f -> %.2f%n", lastKnownPrice, currentPrice);
                lastKnownPrice = currentPrice;
            }
            Thread.sleep(100); // 100ms마다 폴링
        }
    }

    public void stop() {
        running.set(false);
    }
}

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

// 안티패턴: Observer 내부에서 동기적으로 다른 Subject를 갱신해 순환 통지가 발생
class CorrelatedStock extends Stock {
    private CorrelatedStock pairedStock;

    public CorrelatedStock(String symbol, double initialPrice) {
        super(symbol, initialPrice);
    }

    public void pairWith(CorrelatedStock other) {
        this.pairedStock = other;
        this.attach(new Observer() {
            @Override
            public void update(Subject subject) {
                // 페어링된 종목 가격을 연동 갱신 -> 다시 notifyObservers() 호출을 유발
                double correlatedPrice = ((Stock) subject).getPrice() * 0.98;
                pairedStock.setPrice(correlatedPrice);
            }
        });
    }
}

// stockA.pairWith(stockB); stockB.pairWith(stockA); 로 상호 등록한 뒤
// stockA.setPrice(...)를 한 번만 호출해도 A -> B -> A -> B ... 로 재귀 호출이 이어져
// 결국 StackOverflowError로 종료된다.

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

// 해결책 1: 통지 중 재진입을 막는 가드 플래그
class GuardedStock extends Stock {
    private boolean notifying = false;

    public GuardedStock(String symbol, double initialPrice) {
        super(symbol, initialPrice);
    }

    @Override
    public void notifyObservers() {
        if (notifying) {
            return; // 이미 통지가 진행 중이면 재진입 통지를 무시
        }
        notifying = true;
        try {
            super.notifyObservers();
        } finally {
            notifying = false;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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

// 문제가 있는 코드: 강한 참조로 인한 메모리 누수
public class MemoryLeakExample {
    public void demonstrate() {
        Stock stock = new Stock("AAPL", 150.0);

        for (int i = 0; i < 10000; i++) {
            StockDisplay display = new StockDisplay("Display" + i);
            stock.attach(display);

            // display는 로컬 스코프를 벗어나지만
            // stock이 강한 참조를 유지하므로 GC되지 않음!
        }

        // 10,000개의 StockDisplay 객체가 메모리에 남아있음
        System.out.println("Observers: " + stock.getObserverCount()); // 10000
    }
}

 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

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

// WeakReference로 해결: 참조되지 않는 Observer는 자동 회수
class WeakReferenceStock implements Subject {
    private List<WeakReference<Observer>> observers = new ArrayList<>();

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

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

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

            if (observer == null) {
                iterator.remove(); // GC된 Observer 자동 제거
            } else {
                observer.update(this);
            }
        }
    }
}

 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

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

// 자동 정리 메커니즘: 주기적으로 무효 Observer를 제거
class AutoCleanupStock implements Subject {
    private List<Observer> observers = new CopyOnWriteArrayList<>();
    private ScheduledExecutorService cleanupService;

    public AutoCleanupStock() {
        cleanupService = Executors.newScheduledThreadPool(1);
        cleanupService.scheduleAtFixedRate(this::cleanup, 5, 5, TimeUnit.SECONDS);
    }

    private void cleanup() {
        observers.removeIf(observer -> {
            try {
                // 더미 호출로 Observer 생존 여부 확인
                observer.getClass(); // 단순히 클래스 정보 조회
                return false; // 정상적이면 유지
            } catch (Exception e) {
                return true; // 문제가 있으면 제거
            }
        });

        System.out.println("Cleanup completed. Active observers: " + observers.size());
    }
}