[Design Patterns] 10. 브릿지와 플라이웨이트: 분리와 효율성

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

// 현실적인 문제 상황들
public class DesignChallenges {
    
    // 문제 1: 조합 폭발 (Bridge가 해결)
    public void combinationExplosion() {
        // 원하는 것: 다양한 리모컨 × 다양한 기기
        // WindowsTV, WindowsRadio, MacTV, MacRadio, LinuxTV, LinuxRadio...
        // N개 플랫폼 × M개 기기 = N×M개 클래스 폭발!
        
        // 문제: 새로운 플랫폼이나 기기 추가 시 기하급수적 증가
    }
    
    // 문제 2: 메모리 낭비 (Flyweight가 해결)  
    public void memoryWaste() {
        // 게임 맵에 나무 10만 그루가 있다면?
        // 각 나무마다 텍스처, 모델, 색상 정보를 개별 보관?
        // 10만 × 10MB = 1TB 메모리 필요! 😱
        
        List<Tree> forest = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            forest.add(new Tree(x, y, "oak", "green", textureData)); // 중복!
        }
    }
}

  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

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Timer;
import java.util.TimerTask;

// 문제 상황: 조합 폭발을 피하고 싶은 경우
// 여러 종류의 메시징 시스템 × 여러 종류의 전송 방식

// 구현 인터페이스 (Implementation)
interface MessageSender {
    void sendMessage(String message, String recipient);
    boolean isConnected();
    void connect();
    void disconnect();
}

// 구체적 구현들 (ConcreteImplementation)
class EmailSender implements MessageSender {
    private String smtpServer;
    private int port;
    private boolean connected = false;
    
    public EmailSender(String smtpServer, int port) {
        this.smtpServer = smtpServer;
        this.port = port;
    }
    
    @Override
    public void connect() {
        System.out.println("Connecting to SMTP server: " + smtpServer + ":" + port);
        // SMTP 연결 로직
        connected = true;
    }
    
    @Override
    public void sendMessage(String message, String recipient) {
        if (!connected) connect();
        System.out.println("Sending email to " + recipient + ": " + message);
        // 실제 이메일 전송 로직
    }
    
    @Override
    public boolean isConnected() {
        return connected;
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from SMTP server");
        connected = false;
    }
}

class SMSSender implements MessageSender {
    private String apiKey;
    private String serviceUrl;
    private boolean connected = false;
    
    public SMSSender(String apiKey, String serviceUrl) {
        this.apiKey = apiKey;
        this.serviceUrl = serviceUrl;
    }
    
    @Override
    public void connect() {
        System.out.println("Connecting to SMS service: " + serviceUrl);
        // SMS API 연결 로직
        connected = true;
    }
    
    @Override
    public void sendMessage(String message, String recipient) {
        if (!connected) connect();
        System.out.println("Sending SMS to " + recipient + ": " + message);
        // 실제 SMS 전송 로직
    }
    
    @Override
    public boolean isConnected() {
        return connected;
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from SMS service");
        connected = false;
    }
}

class SlackSender implements MessageSender {
    private String webhookUrl;
    private String channel;
    private boolean connected = false;
    
    public SlackSender(String webhookUrl, String channel) {
        this.webhookUrl = webhookUrl;
        this.channel = channel;
    }
    
    @Override
    public void connect() {
        System.out.println("Connecting to Slack webhook: " + webhookUrl);
        // Slack 웹훅 연결 확인
        connected = true;
    }
    
    @Override
    public void sendMessage(String message, String recipient) {
        if (!connected) connect();
        System.out.println("Sending Slack message to " + channel + ": " + message);
        // 실제 Slack 메시지 전송 로직
    }
    
    @Override
    public boolean isConnected() {
        return connected;
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnecting from Slack");
        connected = false;
    }
}

// 추상화 (Abstraction)
abstract class Notification {
    protected MessageSender sender;
    protected String title;
    
    public Notification(MessageSender sender, String title) {
        this.sender = sender;
        this.title = title;
    }
    
    public abstract void send(String message, String recipient);
    
    // 공통 기능
    protected String formatMessage(String content) {
        return "[" + title + "] " + content;
    }
    
    public void setSender(MessageSender sender) {
        if (this.sender != null && this.sender.isConnected()) {
            this.sender.disconnect();
        }
        this.sender = sender;
    }
}

// 구체적 추상화들 (RefinedAbstraction)
class SimpleNotification extends Notification {
    public SimpleNotification(MessageSender sender, String title) {
        super(sender, title);
    }
    
    @Override
    public void send(String message, String recipient) {
        String formattedMessage = formatMessage(message);
        sender.sendMessage(formattedMessage, recipient);
    }
}

class UrgentNotification extends Notification {
    private int retryCount;
    
    public UrgentNotification(MessageSender sender, String title, int retryCount) {
        super(sender, title);
        this.retryCount = retryCount;
    }
    
    @Override
    public void send(String message, String recipient) {
        String urgentMessage = "🚨 URGENT 🚨 " + formatMessage(message);
        
        // 재시도 로직 포함
        for (int i = 0; i < retryCount; i++) {
            try {
                sender.sendMessage(urgentMessage, recipient);
                System.out.println("Message sent successfully on attempt " + (i + 1));
                break;
            } catch (Exception e) {
                System.out.println("Attempt " + (i + 1) + " failed, retrying...");
                if (i == retryCount - 1) {
                    System.out.println("All retry attempts failed");
                }
            }
        }
    }
}

class ScheduledNotification extends Notification {
    private LocalDateTime scheduledTime;
    private Timer timer = new Timer();
    
    public ScheduledNotification(MessageSender sender, String title, LocalDateTime scheduledTime) {
        super(sender, title);
        this.scheduledTime = scheduledTime;
    }
    
    @Override
    public void send(String message, String recipient) {
        String scheduledMessage = formatMessage(message + " (Scheduled for: " + scheduledTime + ")");
        
        long delay = Duration.between(LocalDateTime.now(), scheduledTime).toMillis();
        
        if (delay > 0) {
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    sender.sendMessage(scheduledMessage, recipient);
                    System.out.println("Scheduled message sent at: " + LocalDateTime.now());
                }
            }, delay);
            System.out.println("Message scheduled for: " + scheduledTime);
        } else {
            sender.sendMessage(scheduledMessage, recipient);
            System.out.println("Message sent immediately (past scheduled time)");
        }
    }
}

// 사용 예시
public class BridgePatternExample {
    public static void main(String[] args) {
        // 다양한 구현체 생성
        MessageSender emailSender = new EmailSender("smtp.gmail.com", 587);
        MessageSender smsSender = new SMSSender("api-key-123", "https://sms-service.com");
        MessageSender slackSender = new SlackSender("https://hooks.slack.com/...", "#alerts");
        
        // 다양한 추상화 객체 생성
        Notification simpleEmail = new SimpleNotification(emailSender, "System Alert");
        Notification urgentSMS = new UrgentNotification(smsSender, "Critical Error", 3);
        Notification scheduledSlack = new ScheduledNotification(
            slackSender, "Daily Report", 
            LocalDateTime.now().plusMinutes(5)
        );
        
        // 사용
        simpleEmail.send("Server is running normally", "admin@company.com");
        urgentSMS.send("Database connection failed!", "+1234567890");
        scheduledSlack.send("Daily metrics report", "#general");
        
        // 런타임에 구현체 교체 가능
        urgentSMS.setSender(slackSender);  // SMS -> Slack으로 변경
        urgentSMS.send("Now sending via Slack instead", "#emergency");
        
        // 장점: N개 알림 타입 × M개 전송 방식 = N+M개 클래스 (조합 폭발 방지!)
    }
}

 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

// Bridge, Adapter, Strategy의 차이점을 명확히 이해하기

// 1. Bridge: 추상화와 구현을 분리 (구조적 분리)
class MediaPlayer {
    private AudioCodec codec;  // 구현을 참조
    
    public MediaPlayer(AudioCodec codec) {
        this.codec = codec;
    }
    
    public void play(String filename) {
        codec.decode(filename);
        codec.play();
    }
    
    // 런타임에 코덱 교체 가능
    public void changeCodec(AudioCodec newCodec) {
        this.codec = newCodec;
    }
}

// 2. Adapter: 인터페이스 불일치 해결 (호환성 문제)
class LegacyAudioAdapter implements AudioCodec {
    private LegacyAudioLibrary legacyLib;
    
    @Override
    public void decode(String filename) {
        legacyLib.loadAudioFile(filename);  // 다른 인터페이스를 변환
    }
}

// 3. Strategy: 알고리즘 교체 (행동 변경)
class CompressionContext {
    private CompressionStrategy strategy;
    
    public void compress(String data) {
        strategy.compress(data);  // 압축 알고리즘 교체
    }
}

/*
비교 요약:
- Bridge: "무엇을 하는가"와 "어떻게 하는가"를 분리
- Adapter: "호환되지 않는 것"을 "호환되게" 만듦
- Strategy: "다양한 방법" 중 "하나를 선택"하여 수행
*/

  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

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// 문제 상황: 텍스트 에디터에서 백만 개의 문자를 렌더링
// 각 문자마다 폰트, 크기, 색상 정보를 개별적으로 저장한다면?

// 비효율적인 방법
class Character_BAD {
    private char c;
    private String fontFamily;  // "Arial" (반복!)
    private int fontSize;       // 12 (반복!)
    private Color color;        // Color.BLACK (반복!)
    private int x, y;          // 위치는 각자 다름
    
    // 1,000,000개 문자 × 100 bytes = 100MB 메모리 사용
}

// Flyweight 방법으로 해결
// 공통된 부분(폰트 정보)은 공유하고, 개별적인 부분(위치)만 따로 저장

// Flyweight 인터페이스
interface CharacterFlyweight {
    void render(Canvas canvas, int x, int y, Color color);
    int getWidth();
    int getHeight();
}

// 구체적 Flyweight - 내재적 상태만 보유
class ConcreteCharacter implements CharacterFlyweight {
    private final char character;      // 내재적 상태
    private final String fontFamily;   // 내재적 상태  
    private final int fontSize;        // 내재적 상태
    private final byte[] glyphData;    // 내재적 상태 (폰트 렌더링 데이터)
    
    // 한 번 생성되면 변경되지 않음 (불변 객체)
    public ConcreteCharacter(char character, String fontFamily, int fontSize) {
        this.character = character;
        this.fontFamily = fontFamily;
        this.fontSize = fontSize;
        this.glyphData = loadGlyphData(character, fontFamily, fontSize);
    }
    
    @Override
    public void render(Canvas canvas, int x, int y, Color color) {
        // x, y, color는 외재적 상태로 매개변수로 받음
        canvas.setColor(color);
        canvas.drawGlyph(glyphData, x, y);
    }
    
    @Override
    public int getWidth() {
        return calculateWidth(glyphData);
    }
    
    @Override
    public int getHeight() {
        return fontSize;
    }
    
    private byte[] loadGlyphData(char c, String font, int size) {
        // 실제로는 폰트 파일에서 글리프 데이터를 로딩
        System.out.println("Loading glyph data for '" + c + "' in " + font + " " + size + "pt");
        return new byte[1024]; // 가상의 글리프 데이터
    }
    
    private int calculateWidth(byte[] glyphData) {
        // 글리프 데이터에서 너비 계산
        return fontSize / 2; // 간단한 예시
    }
}

// Flyweight Factory - 객체 공유 관리
class CharacterFlyweightFactory {
    private static final Map<String, CharacterFlyweight> flyweights = new ConcurrentHashMap<>();
    
    public static CharacterFlyweight getCharacter(char c, String fontFamily, int fontSize) {
        String key = c + "_" + fontFamily + "_" + fontSize;
        
        return flyweights.computeIfAbsent(key, k -> {
            System.out.println("Creating new flyweight for: " + key);
            return new ConcreteCharacter(c, fontFamily, fontSize);
        });
    }
    
    public static int getFlyweightCount() {
        return flyweights.size();
    }
    
    public static void printStatistics() {
        System.out.println("Total flyweights created: " + flyweights.size());
        System.out.println("Memory saved: " + calculateMemorySaved() + " MB");
    }
    
    private static long calculateMemorySaved() {
        // 단순 계산 예시
        return flyweights.size() * 100; // 각 flyweight가 100KB 절약한다고 가정
    }
}

// Context - 외재적 상태 보유
class CharacterContext {
    private final int x, y;                    // 외재적 상태 (위치)
    private final Color color;                 // 외재적 상태 (색상)
    private final CharacterFlyweight flyweight; // Flyweight 참조
    
    public CharacterContext(int x, int y, Color color, char c, String fontFamily, int fontSize) {
        this.x = x;
        this.y = y;
        this.color = color;
        this.flyweight = CharacterFlyweightFactory.getCharacter(c, fontFamily, fontSize);
    }
    
    public void render(Canvas canvas) {
        flyweight.render(canvas, x, y, color);
    }
    
    public int getX() { return x; }
    public int getY() { return y; }
    public Color getColor() { return color; }
    public CharacterFlyweight getFlyweight() { return flyweight; }
}

// 텍스트 문서 - Flyweight 활용
class TextDocument {
    private List<CharacterContext> characters = new ArrayList<>();
    private String defaultFontFamily = "Arial";
    private int defaultFontSize = 12;
    
    public void addText(String text, int startX, int startY, Color color) {
        int currentX = startX;
        int currentY = startY;
        
        for (char c : text.toCharArray()) {
            if (c == '\n') {
                currentX = startX;
                currentY += defaultFontSize + 2; // 줄 간격
                continue;
            }
            
            CharacterContext context = new CharacterContext(
                currentX, currentY, color, c, defaultFontFamily, defaultFontSize
            );
            characters.add(context);
            
            // 다음 문자 위치 계산
            currentX += context.getFlyweight().getWidth();
        }
    }
    
    public void render(Canvas canvas) {
        System.out.println("Rendering document with " + characters.size() + " characters");
        for (CharacterContext character : characters) {
            character.render(canvas);
        }
    }
    
    public void printMemoryUsage() {
        System.out.println("Document statistics:");
        System.out.println("- Total characters: " + characters.size());
        System.out.println("- Unique flyweights: " + CharacterFlyweightFactory.getFlyweightCount());
        
        // 메모리 절약 계산
        long withoutFlyweight = characters.size() * 100L; // 각 문자당 100 bytes
        long withFlyweight = CharacterFlyweightFactory.getFlyweightCount() * 100L + characters.size() * 20L; // flyweight + context
        long saved = withoutFlyweight - withFlyweight;
        
        System.out.println("- Memory without Flyweight: " + withoutFlyweight + " bytes");
        System.out.println("- Memory with Flyweight: " + withFlyweight + " bytes");
        System.out.println("- Memory saved: " + saved + " bytes (" + 
                          (saved * 100 / withoutFlyweight) + "% reduction)");
    }
}

// 사용 예시
public class FlyweightPatternExample {
    public static void main(String[] args) {
        Canvas canvas = new MockCanvas();
        TextDocument document = new TextDocument();
        
        // 대량의 텍스트 추가 (현실적인 시나리오)
        document.addText("Hello World! This is a sample text.", 10, 10, Color.BLACK);
        document.addText("Hello World! This is another line.", 10, 30, Color.BLUE);
        document.addText("Same characters appear multiple times.", 10, 50, Color.BLACK);
        
        // 더 많은 텍스트 추가 (Flyweight 효과 확인)
        for (int i = 0; i < 100; i++) {
            document.addText("Line " + i + ": Hello World!", 10, 70 + i * 20, 
                           i % 2 == 0 ? Color.BLACK : Color.BLUE);
        }
        
        // 렌더링
        document.render(canvas);
        
        // 메모리 사용량 분석
        document.printMemoryUsage();
        CharacterFlyweightFactory.printStatistics();
        
        /*
         * 출력 예시:
         * Creating new flyweight for: H_Arial_12
         * Creating new flyweight for: e_Arial_12
         * Creating new flyweight for: l_Arial_12
         * Creating new flyweight for: o_Arial_12
         * Creating new flyweight for:  _Arial_12  (공백)
         * ...
         * 
         * Document statistics:
         * - Total characters: 3847
         * - Unique flyweights: 26  (a-z, A-Z, 0-9, 공백, 특수문자 등)
         * - Memory without Flyweight: 384,700 bytes
         * - Memory with Flyweight: 79,540 bytes
         * - Memory saved: 305,160 bytes (79% reduction)
         */
    }
}

// Mock Canvas for demonstration
class MockCanvas implements Canvas {
    private Color currentColor = Color.BLACK;
    
    @Override
    public void setColor(Color color) {
        this.currentColor = color;
    }
    
    @Override
    public void drawGlyph(byte[] glyphData, int x, int y) {
        // 실제로는 화면에 그리기
        // System.out.println("Drawing glyph at (" + x + "," + y + ") with color " + currentColor);
    }
}

interface Canvas {
    void setColor(Color color);
    void drawGlyph(byte[] glyphData, int x, int y);
}

enum Color {
    BLACK, BLUE, RED, GREEN
}

  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

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

// 게임에서 파티클 시스템 최적화
// 수만 개의 파티클이 동시에 존재하는 상황
// 아래 Texture / Graphics / TextureManager / SparkParticle / ExplosionParticle 는
// 실제 게임 엔진(예: libGDX, LWJGL)이 제공한다고 가정한 가상 타입이며, 이 파일 안에서는 정의하지 않는다.

// Flyweight 인터페이스
interface ParticleFlyweight {
    void update(float deltaTime, float x, float y, float velocityX, float velocityY);
    void render(Graphics graphics, float x, float y, float scale, float alpha);
}

// 구체적 Flyweight들
class FireParticle implements ParticleFlyweight {
    private final Texture texture;      // 내재적 상태
    private final Color baseColor;      // 내재적 상태
    private final float baseLifetime;   // 내재적 상태
    
    public FireParticle() {
        this.texture = TextureManager.load("fire_particle.png");
        this.baseColor = Color.ORANGE;
        this.baseLifetime = 2.0f;
    }
    
    @Override
    public void update(float deltaTime, float x, float y, float velocityX, float velocityY) {
        // 물리 업데이트 (외재적 상태를 매개변수로 받음)
        // 실제로는 더 복잡한 파티클 물리 계산
    }
    
    @Override
    public void render(Graphics graphics, float x, float y, float scale, float alpha) {
        graphics.setColor(baseColor.withAlpha(alpha));
        graphics.drawTexture(texture, x, y, scale);
    }
}

class SmokeParticle implements ParticleFlyweight {
    private final Texture texture;
    private final Color baseColor;
    private final float baseLifetime;
    
    public SmokeParticle() {
        this.texture = TextureManager.load("smoke_particle.png");
        this.baseColor = Color.GRAY;
        this.baseLifetime = 5.0f;
    }
    
    @Override
    public void update(float deltaTime, float x, float y, float velocityX, float velocityY) {
        // 연기 특유의 물리 업데이트
    }
    
    @Override
    public void render(Graphics graphics, float x, float y, float scale, float alpha) {
        graphics.setColor(baseColor.withAlpha(alpha * 0.7f)); // 연기는 더 투명
        graphics.drawTexture(texture, x, y, scale);
    }
}

// Flyweight Factory
class ParticleTypeFactory {
    private static final Map<String, ParticleFlyweight> particleTypes = new HashMap<>();
    
    static {
        particleTypes.put("fire", new FireParticle());
        particleTypes.put("smoke", new SmokeParticle());
        particleTypes.put("spark", new SparkParticle());
        particleTypes.put("explosion", new ExplosionParticle());
    }
    
    public static ParticleFlyweight getParticleType(String type) {
        return particleTypes.get(type);
    }
}

// Context - 각 파티클의 개별 상태
class Particle {
    private float x, y;              // 외재적 상태 (위치)
    private float velocityX, velocityY; // 외재적 상태 (속도)
    private float scale;             // 외재적 상태 (크기)
    private float alpha;             // 외재적 상태 (투명도)
    private float lifetime;          // 외재적 상태 (수명)
    private ParticleFlyweight type;  // Flyweight 참조
    
    public Particle(float x, float y, String typeName) {
        this.x = x;
        this.y = y;
        this.velocityX = (float) (Math.random() - 0.5) * 100;
        this.velocityY = (float) (Math.random() - 0.5) * 100;
        this.scale = 1.0f;
        this.alpha = 1.0f;
        this.lifetime = 0.0f;
        this.type = ParticleTypeFactory.getParticleType(typeName);
    }
    
    public void update(float deltaTime) {
        // 위치 업데이트
        x += velocityX * deltaTime;
        y += velocityY * deltaTime;
        
        // 수명 업데이트
        lifetime += deltaTime;
        alpha = Math.max(0, 1.0f - lifetime / 3.0f); // 3초 후 완전 투명
        
        // Flyweight에 위임
        type.update(deltaTime, x, y, velocityX, velocityY);
    }
    
    public void render(Graphics graphics) {
        if (alpha > 0) {
            type.render(graphics, x, y, scale, alpha);
        }
    }
    
    public boolean isAlive() {
        return alpha > 0;
    }
}

// 파티클 시스템
class ParticleSystem {
    private List<Particle> particles = new ArrayList<>();
    
    public void emit(String particleType, float x, float y, int count) {
        for (int i = 0; i < count; i++) {
            particles.add(new Particle(x + (float) Math.random() * 10, 
                                     y + (float) Math.random() * 10, 
                                     particleType));
        }
    }
    
    public void update(float deltaTime) {
        // 파티클 업데이트 및 죽은 파티클 제거
        particles.removeIf(particle -> {
            particle.update(deltaTime);
            return !particle.isAlive();
        });
    }
    
    public void render(Graphics graphics) {
        for (Particle particle : particles) {
            particle.render(graphics);
        }
    }
    
    public void printStatistics() {
        System.out.println("Active particles: " + particles.size());
        System.out.println("Particle types: " + ParticleTypeFactory.particleTypes.size());
        
        // 메모리 계산
        long withoutFlyweight = particles.size() * 1000L; // 각 파티클이 1KB라고 가정
        long withFlyweight = particles.size() * 100L + ParticleTypeFactory.particleTypes.size() * 500L;
        
        System.out.println("Memory usage - Without Flyweight: " + withoutFlyweight + " bytes");
        System.out.println("Memory usage - With Flyweight: " + withFlyweight + " bytes");
        System.out.println("Memory saved: " + (withoutFlyweight - withFlyweight) + " bytes");
    }
}

 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

// 두 패턴의 근본적 차이점 이해하기

// Bridge: "구조적 분리"를 통한 유연성
class DatabaseManager {
    private DatabaseConnector connector;  // 구현과 분리
    
    public DatabaseManager(DatabaseConnector connector) {
        this.connector = connector;
    }
    
    public void saveUser(User user) {
        // 추상화 레벨의 비즈니스 로직
        validateUser(user);
        String sql = "INSERT INTO users...";
        connector.execute(sql);  // 구현에 위임
    }
    
    // 런타임에 구현체 교체 가능 (Bridge의 핵심)
    public void switchDatabase(DatabaseConnector newConnector) {
        this.connector = newConnector;
    }
}

// Flyweight: "상태 분리"를 통한 효율성
class Icon {
    private final String imagePath;    // 내재적 상태 (공유)
    private final byte[] imageData;    // 내재적 상태 (공유)
    
    // 외재적 상태는 매개변수로 받음
    public void draw(Graphics g, int x, int y, int size) {
        g.drawImage(imageData, x, y, size, size);
    }
}

/*
핵심 차이점:

Bridge 패턴:
- 목적: 추상화와 구현의 독립적 변화
- 관점: 구조적 유연성 (Structural Flexibility)
- 해결: 조합 폭발 문제
- 시점: 설계 타임 분리, 런타임 교체

Flyweight 패턴:  
- 목적: 메모리 사용량 최적화
- 관점: 자원 효율성 (Resource Efficiency)
- 해결: 메모리 낭비 문제
- 시점: 런타임 상태 분리, 객체 공유
*/